集合、泛型和枚举

Table of Contents

Java 的集合就像一个容器,用来存储 Java 类的对象。

集合

在编程时,可以使用数组来保存多个对象,但数组长度一旦指定就不可变化,而且数组无法保存具有映射关系的数据。

为了保存数量不确定的数据,以及保存具有映射关系的数据(也被称为关联数组),Java 提供了集合类。

集合类主要负责保存、盛装其他数据,因此集合类也被称为容器类。Java 所有的集合类都位于 java.util 包下,提供了一个表示和操作对象集合的统一构架,包含了大量集合接口,以及这些接口的实现类和操作的算法。

集合类和数组不一样,数组元素既可以是基本类型的值,也可以是对象(实际上保存的是对象的引用变量),而集合里只能保存对象。

Java 集合类型分为 CollectionMap ,它们是 Java 集合的根接口,这两个接口又包含了一些子接口或实现类。

java-8.png

Figure 1: Collection 接口基本结构

Figure 2: Map 接口基本结构

*注:上图中,黄色块为集合的接口,蓝色为集合的实现类。

Table 1: Java 集合接口的作用
接口名称 作用
Iterator 集合的输出接口,主要用于遍历输出(即迭代访问) Collection 集合中的元素, Iterator 对象被称之为迭代器。迭代器接口是集合接口的父接口,实现类实现 Collection 时就必须实现 Iterator 接口。
Collection List、SetQueue 的父接口,是存放一组单值的最大接口。所谓的单值是指集合中的每个元素都是一个对象,一般很少使用此接口直接操作。
Queue Queue 是 Java 提供的队列实现,有点类似于 List
Dueue Queue 的一个子接口,为双向队列。
List 是最常用的接口。是有序集合,允许有相同的元素。使用 List 能够精确地控制每个元素插入的位置,用户能够使用索引来访问 List 中的元素,与数组类似。
Set 不能包含重复的元素。
Map 是存放一对值的最大接口,即接口中的每个元素都是一对,以 key → value 的形式保存。

对于 Set、List、QueueMap 这 4 种集合,Java 最常用的实现类分别是 HashSet、TreeSet、ArrayList、ArrayDueue、LinkedListHashMap、TreeMap 等。

Table 2: Java 集合实现类的作用
类名称 作用
HashSet 为优化查询速度而设计的 Set 。它是基于 HashMap 实现的, HashSet 底层使用 HashMap 来保存所有元素,实现比较简单。
TreeSet 实现了 Set 接口,是一个有序的 Set ,这样就能从 Set 里面提取一个有序序列。
ArrayList 一个用数组实现的 List ,能进行快速的随机访问,效率高而且实现了可变大小的数组。
ArrayDueue 是一个基于数组实现的双端队列,按“先进先出”的方式操作集合元素。
LinkedList 对顺序访问进行了优化,但随机访问的速度相对较慢。此外它还有 addFirst()、addLast()、getFirst()、getLast()、removeFirst()removeLast() 等方法,能把它当成栈( Stack ) 或队列( Queue )来用。
HashMap 按哈希算法来存取键对象。
TreeMap 可以对键对象进行排序。

Colletion 接口

Collection 接口是 List、SetQueue 接口的父接口,通常情况下不被直接使用。 Collection 接口定义了一些通用的方法,通过这些方法可以实现对集合的基本操作,它们也可用于操作 Set、List、Queue

List、Set、Queue 继承自 Collection 接口,自然已经实现了 Collection 接口中的方法。
Table 3: Collection 接口的常用方法
方法名称 说明
boolean add(E e) 向集合中添加一个元素,如果集合对象被添加操作改变了,则返回 trueE 是元素的数据类型。
boolean addAll(Collection c) 向集合中添加集合 c 中的所有元素,如果集合对象被添加操作改变了,则返回 true
void clear() 清除集合中的所有元素,将集合长度变为 0
boolean contains(Object o) 判断集合中是否存在指定元素
boolean containsAll(Collection c) 判断集合中是否包含集合 c 中的所有元素
boolean isEmpty() 判断集合是否为空
Iterator<E> iterator() 返回一个 Iterator 对象,用于遍历集合中的元素
boolean remove(Object o) 从集合中删除一个指定元素,当集合中包含了一个或多个元素 o 时,该方法 只删除第一个 符合条件的元素,该方法将返回 true
boolean removeAll(Collection c) 从集合中删除所有在集合 c 中出现的元素(相当于把调用该方法的集合减去集合 c )。如果该操作改变了调用该方法的集合,则该方法返回 true
boolean retainAll(Collection c) 从集合中删除集合 c 里不包含的元素(相当于把调用该方法的集合变成该集合和集合 c 的交集),如果该操作改变了调用该方法的集合,则该方法返回 true
int size() 返回集合中元素的个数
Object[] toArray() 把集合转换为一个数组,所有的集合元素变成对应的数组元素。

*注: retainAll() 方法的作用与 removeAll() 方法相反,它保留两个集合中相同的元素,其他全部删除。

集合类像容器,现实生活中容器的功能,就是添加对象、删除对象、清空容器和判断容器是否为空等,集合类为这些功能提供了对应的方法。

看,其实只要联系现实,记忆就突然变得简单了,这就是用以为学了。

在传统模式下,把一个对象“丢进”集合中后,集合会忘记这个对象的类型。也就是说,系统把所有的集合元素都当成 Object 类型。从 Java 5 以后,可以使用泛型来限制集合里元素的类型,并让集合记住所有集合元素的类型。

List 集合

List 是一个有序、可重复的集合,集合中每个元素都有其对应的顺序索引,默认按元素的添加顺序设置元素的索引,可以通过索引来访问指定位置的元素。

List 实现了 Collection 接口,它主要有两个常用的实现类: ArrayList 类和 LinkedList 类。

ArrayList 类

ArrayList 类实现了可变数组的大小,存储在内的数据称为元素。它还提供了快速基于索引访问元素的方式,对 尾部成员 的增加和删除支持较好。

*注:向 ArrayList 中(除尾部成员)插入与删除元素的速度相对较慢。

ArrayList 类的常用构造方法有如下两种重载形式:

  • ArrayList() :构造一个初始容量为 10 的空列表;
  • ArrayList(Collection<?extends E> c) :构造一个包含指定 Collection 元素的列表,这些元素是按照 Collection 的迭代器返回它们的顺序排列的。

ArrayList 类除了包含 Collection 接口的所有方法之外,还包括 List 接口中提供的如下表所示的方法。

Table 4: ArrayList 类的常用方法
方法名称 说明
E get(int index) 获取此集合中指定索引位置的元素, E 为集合中元素的数据类型
E set(int index, E element) 将此集合中指定索引位置的元素修改为 element 参数指定的对象。此方法返回此集合中指定索引位置的原元素
int index(Object o) 返回此集合中第一次出现指定元素的索引,如果此集合不包含该元素,则返回 -1
int lastIndexOf(Object o) 返回此集合中最后一次出现指定元素的索引,如果此集合不包含该元素,则返回 -1
List<E> subList(int fromIndex, int toIndex) 返回一个新的集合,新集合中包含 fromIndextoIndex 索引之间的所有元素(左闭右开)

LinkedList 类

LinkedList 类采用链表结构保存对象,这种结构的优点是便于向集合中插入或者删除元素。

*注:需要频繁向集合中插入和删除元素时,使用 LinkedList 类比 ArrayList 类效果高,但是 LinkedList 类随机访问元素的速度则相对较慢。

LinkedList 类除了包含 Collection 接口中的所有方法之外,还特别提供了下表所示的方法:

Table 5: LinkList 类中的方法
方法名称 说明
void addFirst(E e) 将指定元素添加到此集合的开头
void addLast(E e) 将指定元素添加到此集合的末尾
E getFirst() 返回此集合的第一个元素
E getLast() 返回此集合的最后一个元素
E removeFirst() 删除此集合中的第一个元素
E removeLast() 删除此集合中的最后一个元素

LinkedList<String> 中的 <String> 是 Java 中的泛型, 用于指定集合中元素的数据类型 ,例如这里指定元素类型为 String ,则该集合中不能添加非 String 类型的元素。

ArrayList VS LinkedList

ArrayListLinkedList 都是 List 接口的实现类,因此都实现了 List 的所有未实现的方法,只是实现的方式有所不同。

*注: LinkedList 类同时实现了 Dueue 接口和 List 接口。

ArrayList 是基于动态数组数据结构的实现,访问速度优于 LinkedListLinkedList 是基于链表数据结构的实现,占用的内存空间较大,但在批量插入或删除数据时优于 ArrayList

不同的结构对应于不同的算法,有的考虑节省占用空间,有的考虑提高运行效率,对于程序员而言,它们就像是“熊掌”和“鱼肉”,不可兼得。高运行速度往往是以牺牲空间为代价的,而节省占用空间往往是以牺牲运行速度为代价的。

Set 集合

Set 集合类似于一个罐子,程序可以把多个对象“丢进” Set 集合,而 Set 集合通常不能记住元素的添加顺序。也就是说, Set 集合中的对象不按特定的方式排序,只是简单地把对象加入集合,它不能包含重复的对象,并且最多只允许包含一个 null 元素。

Set 实现了 Collection 接口,它主要有两个常用的实现类: HashSet 类和 TreeSet 类。

HashSet 类

HashSetSet 接口的典型实现,大多数时候使用 Set 集合时就是使用这个实现类。 HashSet 是按照 Hash 算法来存储集合中的元素,因此具有很好的存取和查找性能。

HashSet 具有以下特点:

  • 不能保证元素的排列顺序,顺序可能与添加顺序不同,顺序也有可能发生变化;
  • HashSet 不是同步的,如果多个线程同时访问或修改一个 HashSet ,则必须通过代码来保证其同步;
  • 集合元素值可以是 null

当向 HashSet 集合中存入一个元素时, HashSet 会调用该对象的 hasCode() 方法来得到该对象的 hasCode 值,然后根据该 hasCode 值决定该对象在 HashSet 中的存储位置。

如果有两个元素通过 equals() 方法比较返回的结果为 true ,但它们的 hasCode 不相等, HashSet 将会把它们存储在不同的位置,依然可以添加成功。

也就是说,两个对象的 hasCode 值相等且通过 equals() 方法比较返回结果为 true ,则 HashSet 集合认为两个元素相等。

HashSet 类中实现了 Collection 接口中的所有方法, HashSet 类的常用构造方法重载形式如下:

  • HashSet() :构造一个新的空的 Set 集合;
  • HashSet(Collection<? extends E> c) :构造一个包含指定 Collection 集合元素的新 Set 集合。其中, < > 中的 extends 表示 HashSet 的父类,即指明该 Set 集合中存放的集合元素类型。 c 表示其中的元素将被存放在此 Set 集合中。

下面的代码演示了创建两种不同形式的 HashSet 对象:

1: HashSet hs = new HashSet();                  // 调用无参的构造函数创建 HashSet 对象
2: HashSet<String> hss = new HashSet<String>(); // 创建泛型的 HashSet 集合对象

TreeSet 类

TreeSet 类同时实现了 Set 接口和 SortedSet 接口。 SortedSet 接口是 Set 接口的子接口,可以实现对集合进行自然排序,因此使用 TreeSet 类实现的 Set 接口默认情况下是自然排序(升序排序)的。

TreeSet 只能对实现了 Comparable 接口的类对象进行排序,因为 Comparable 接口有一个 compareTo(Object o) 方法用于比较两个对象的大小。

例如 a.compareTo(b) ,如果 ab 相等,则该方法返回 0 ;如果 a 大于 b ,则该方法返回大于 0 的值;如果 a 小于 b ,则该方法返回小于 0 的值。

下表列举了 JDK 类库中实现 Comparable 接口的类,以及这些类对象的比较方式:

Table 6: 实现 Comparable 接口类对象的比较方式
比较方式
包装类( BigDecimal、BigInteger、Byte、Double、Float、Integer、LongShort 按数字大小比较
Character 按字符的 Unicode 值的数字大小比较
String 按字符中字符的 Unicode 值的数字大小比较

TreeSet 类除了实现 Collection 接口的所有方法之外,还提供了如下表所示的方法:

Table 7: TreeSet 类的常用方法
方法名称 说明
E first() 返回此集合中的第一个元素。其中, E 表示集合中元素的数据类型。
E last() 返回此集合中的最后一个元素
E poolFirst() 获取并移除此集合中的第一个元素
E poolLast() 获取并移除此集合中的最后一个元素
SortedSet<E> subSet(E fromElement, E toElement) 返回一个新的集合,新集合包含原集合中 fromElement 对象与 toElement 对象之间的所有对象,左闭右开。
SortedSet<E> headSet<E toElement> 返回一个新的集合,新集合包含原集合中 toElement 对象之前的所有对象,不包含 toElement 对象。
SortedSet<E> tailSet<E fromElement> 返回一个新的集合,新集合包含原集合中 fromElement 对象之后的所有对象,包含 fromElement 对象。

*注:表面上看起来这些方法很多,其实很简单。因为 TreeSet 中的元素是 有序的 ,所以增加了访问第一个、前一个、后一个、最后一个元素的方法,并提供了 3 个从 TreeSet 中截取子 TreeSet 的方法。

在使用自然排序时只能向 TreeSet 集合中添加相同数据类型的对象,否则会抛出 ClassCastException 异常。

Map 集合

Map 是一种键值对( key-value )集合,用于保存具有映射关系的数据。

Map 集合里保存着两组值,一组值用于保存 Key ,另一组值用于保存 valueKeyvalue 都可以是任何引用类型的数据 。其中, key 不允许重复, value 可以重复。

Map 中的 keyvalue 之间存在单向一对一关系,即通过指定的 key ,总能找到唯一的、确定的 value

Map 接口主要有两个实现类: HashMap 类和 TreeMap 类。其中, HashMap 类按哈希算法来存取键对象,而 TreeMap 类可以对键对象进行排序。

Table 8: Map 接口的常用方法
方法名称 说明
void clear() 删除该 Map 对象中的所有 key-value 对。
boolean containsKey(Object key) 查询 Map 中是否包含指定的 key ,如果包含则返回 true
boolean containsValue(Object value) 查询 Map 中是否包含一个或多个的 value ,如果包含则返回 true
V get(Object key) 返回 Map 集合中指定键对象所对应的值, V 表示值的数据类型。
V put(K key, V value) Map 集合中添加键-值对,如果当前 Map 中已有一个与该 key 相等的 key-value 对,则新的 key-value 对会覆盖原来的 key-value 对。
void putAll(Map m) 将指定 Map 中的 key-value 对复制到本 Map 中。
V remove(Object key) Map 集合中删除 key 对应的键-值对,返回 key 对应的 value ,如果该 key 不存在,则返回 null
boolean remove(Object key, Object value) (Java 8 新增)删除指定 key、value 所对应的 key-value 对。如果从该 Map 中成功地删除该 key-value 对,该方法返回 true ,否则返回 false
Set entrySet() 返回 Map 集合中所有键-值对的 Set 集合,此 Set 集合中元素的数据类型为 Map.Entry
Set keySet() 返回 Map 集合中所有键对象的 Set 集合
boolean isEmpty() 查询该 Map 是否为空(即不包含任何 key-value 对),如果为空则返回 true
int size() 返回该 Mapkey-value 对的个数
Collection values() 返回该 Map 里所有 value 组成的 Collection

Map 集合最典型的用法就是成对地添加、删除 key-value 对,接下来即可判断该 Map 中是否包含指定 key ,也可以通过 Map 提供的 keySet() 方法获取所有 key 组成的集合,进而遍历 Map 中所有的 key-value 对。

*注: TreeMap 类的使用方法与 HashMap 类相同,唯一不同的是 TreeMap 类可以对键对象进行排序。

#. 遍历 Map 集合

Map 集合的遍历与 ListSet 集合不同。 Map 有两组值,因此遍历时可以只遍历值的集合,也可以只遍历键的集合,也可以同时遍历。 Map 以及实现 Map 的接口类(如 HashMap、TreeMap、LinkedHashMap、Hashtable 等)都可以用以下几种方式遍历。

(1)在 for 循环中使用 entries 实现 Map 的遍历(最常见和最常用的)。

 1: public static void main(String[] args) {
 2:     Map<String, String> map = new HashMap<String, String>();
 3:     map.put("Java Tutor", "tutor/java/");
 4:     map.put("C++ Tutor", "tutor/cpp/");
 5: 
 6:     for (Map.Entry<String, String> entry : map.entrySet()) {
 7:         String mapKey = entry.getKey();
 8:         String mapValue = entry.getValue();
 9:         System.out.println(mapKey + ": " + mapValue);
10:     }
11: }

(2)使用 for-each 循环遍历 key 或者 values ,一般适用于只需要 Map 中的 key 或者 value 时使用,性能上 entrySet 较好。

 1: public static void main(String[] args) {
 2:     Map<String, String> map = new HashMap<String, String>();
 3:     map.put("Java Tutor", "tutor/java/");
 4:     map.put("C++ Tutor", "tutor/cpp/");
 5: 
 6:     for (String key : map.keySet()) {
 7:         System.out.println(key);
 8:     }
 9: 
10:     for (String value : map.values()) {
11:         System.out.println(value);
12:     }
13: }

(3)使用迭代器( Iterator )遍历

 1: public static void main(String[] args) {
 2:     Map<String, String> map = new HashMap<String, String>();
 3:     map.put("Java Tutor", "tutor/java/");
 4:     map.put("C++ Tutor", "tutor/cpp/");
 5: 
 6:     Iterator<Entry<String, String>> entries = map.entrySet().iterator();
 7:     while (entries.hasNext()) {
 8:         Entry<String, String> entry = entries.next();
 9:         String key = entry.getKey();
10:         String value = entry.getValue();
11:         System.out.println(key + ": " + value);
12:     }
13: }

(4)通过键值遍历,这种方式的效率比较低,因为本身从键值是耗时的操作。

1: for (String key : map.keySet()) {
2:     String value = map.get(key);
3:     System.out.println(key + ": " + value);
4: }

TODO Collections 类

泛型

前面我们提到 Java 集合有个缺点,就是把一个对象“丢进”集合里之后,集合就会“忘记”这个对象的数据类型,当再次取出对象时,该对象的编译类型就变成了 Object 类型(其运行时类型没变)

Java 集合之所以被设计成这样,是因为集合的设计者不知道我们用集合来保存什么类型的对象,所以他们把集合设计成能保存任何类型的对象,只需求具有很好的通用性。但这样做带来如下两个问题:

(1)集合对元素类型没有任何限制,这可能引发一些问题,例如,想创建一个只能保存 Dog 对象的集合,但程序也可以轻易地将 Cat 对象“丢”进去,所以可能引发异常。

(2)由于把对象“丢进”集合时,集合丢失了对象的状态信息,集合只知道它盛装的是 Object ,因此取出集合元素后通常还需要进行强制类型转换。这种强制类型转换既增加了编程的复杂度,也可能引发 ClassCastException 异常。

为了解决上述问题,从 Java 1.5 开始提供了泛型。

泛型可以在编译的时候检查类型安全,并且所有的强制转换都是自动和隐式的,提高了代码的重用率。

泛型集合

泛型,本质上是提供类型的“类型参数”,也就是参数化类型。

我们可以为类、接口或方法指定一个类型参数,通过这个参数限制操作的数据类型,从而保证类型转换的绝对安全。

来看个例子,下面将结合泛型与集合编写一个案例实现图书信息输出:

(1)首先创建一个表示图书的实体类 Book ,其中包括图书信息的编号、名称和价格。代码如下:

 1: public class Book {
 2:     private int Id;
 3:     private String Name;
 4:     private int Price;
 5: 
 6:     public Book(int id, String name, int price) {
 7:         this.Id = id;
 8:         this.Name = name;
 9:         this.Price = price;
10:     }
11: 
12:     public String toString() {
13:         return this.Id + ", " + this.Name + ", " + this.Price;
14:     }
15: }

(2)使用 Book 作为类型创建 Map 和 List 两个泛型集合,然后向集合中添加图书元素,最后输出集合中的内容,代码如下:

 1: public class Test {
 2:     public static void main(String[] args) {
 3:         Book book1 = new Book(1, "BOOK1", 8);
 4:         Book book2 = new Book(2, "BOOK2", 12);
 5:         Book book3 = new Book(3, "BOOK3", 22);
 6: 
 7:         // 定义泛型 Map 集合
 8:         Map<Integer, Book> books = new HashMap<Integer, Book>();
 9:         books.put(1001, book1);
10:         books.put(1002, book2);
11:         books.put(1003, book3);
12:         System.out.println("泛型 Map 存储的图书信息如下:");
13:         for (Integer id : books.keySet()) {
14:             System.out.println(id + "--");
15:             System.out.println(books.get(id)); // 不需要类型转换
16:         }
17: 
18:         // 定义泛型的 List 集合
19:         List<Book> bookList = new ArrayList<Book>();
20:         bookList.add(book1);
21:         bookList.add(book2);
22:         bookList.add(book3);
23:         System.out.println("泛型 List 存储的图书信息如下:");
24:         for (int i = 0; i < bookList.size(); i++) {
25:             System.out.println(bookList.get(i)); // 不需要类型转换
26:         }
27:     }
28: }

在该示例中,第 8 行代码创建了一个键类型为 Integer 、值类型为 Book 的泛型集合,即该 Map 集合中存放的键必须是 Integer 类型、值必须为 Book 类型,否则编译出错。在获取 Map 集合中的元素时,不需要将 books.get(id); 获取的值强制转换为 Book 类型,程序会隐式转换。

第 19 行代码在创建 List 集合时,同样使用了泛型,因此在获取集合中的元素时也不需要将 bookList.get(i) 代码强制转换为 Book 类型,程序会隐式转换。

泛型类

除了可以定义泛型集合之外,还可以直接限定泛型类的类型参数,语法格式如下:

public class class_name<data_type1, data_type2, ...> {}

其中, class_name 表示类的名称, data_type1 等表示类型参数。Java 泛型支持声明一个以上的类型参数,只需要将类型用逗号隔开即可。

泛型类一般用于类中的属性类型不确定的情况下。 在声明属性时,使用下面的语句:

1: private data_type1 property_name1;
2: private data_type2 property_name2;

该语句中的 data_type1 与类声明中的 data_type1 表示的是同一种数据类型。

在实例化泛型类时,需要指明泛型类中的类型参数,并赋予泛型类属性相应类型的值。

下面我们来看一个例子,创建了一个表示学生的泛型类,该类中包括 3 个属性,分别是姓名、年龄和性别。

 1: public class Stu<N, A, S> {
 2:     private N name;
 3:     private A age;
 4:     private S sex;
 5: 
 6:     // 创建类的构造函数
 7:     public Stu(N name, A age, S sex) {
 8:         this.name = name;
 9:         this.age = age;
10:         this.sex = sex;
11:     }
12: 
13:     // 下面是上面 3 个属性的 setter/getter 方法
14:     public N getName() {
15:         return name;
16:     }
17:     public void setName(N name) {
18:         this.name = name;
19:     }
20: 
21:     public A getAge() {
22:         return age;
23:     }
24:     public void setAge(A age) {
25:         this.age = age;
26:     }
27: 
28:     public S getSex() {
29:         return sex;
30:     }
31:     public void setSex(S sex) {
32:         this.sex = sex;
33:     }
34: }

接着创建测试类,在测试类中调用 Stu 类的构造方法实例化 Stu 对象,并给该类中的 3 个属性赋初始值,最终需要输出学生信息,代码如下:

 1: public class Test {
 2:     public static void main(String[] args) {
 3:         Stu<String, Integer, Character> stu = new Stu<String, Integer, Character>("Amy", 32, "Female" );
 4:         String name = stu.getName();
 5:         Integer age = stu.getAge();
 6:         Character sex = stu.getSex();
 7: 
 8:         System.out.println("NAME: " + name + ", AGE: " + age + ", SEX: " + sex);
 9:         // → NAME: Amy, AGE: 32, SEX: Female
10:     }
11: }

在程序的 Stu 类中,定义了 3 个类型参数,分别使用 N、AS 来代替,同时实现了这 3 个属性的 setter/getter 方法。在主类中,调用 Stu 类的构造函数创建了 Stu 类的对象,同时指定 3 个类型参数,分别为 String、IntegerCharacter 。在获取学生姓名、年龄和性别时,不需要类型转换,程序隐式地将 Object 类型的数据转换为相应的数据类型。

泛型方法

泛型同样可以应用在类中包含参数化的方法,而方法所在的类可以是泛型类,也可以不是泛型类。

泛型方法使得该方法能够独立于类而产生变化,如果使用泛型方法可以取代类泛型化,那么就应该只使用泛型方法。另外,对一个 static 的方法而言,无法访问泛型类的类型参数。因此,如果 static 方法需要使用泛型能力,就必须使其成为泛型方法。

定义泛型方法的语法格式如下:

[访问权限修饰符] [static] [final] <类型参数列表> 返回值类型方法名([形式参数列表])

如:

1: public static List<T> find(Class<T>class, int userId) {}

一般来说编写 Java 泛型方法,其返回值类型至少有一个参数类型应该是泛型,而且类型应该是一致的,如果只有返回值类型或参数类型之一使用了泛型,那么这个泛型方法的使用就被限制了。

下面来定义一个泛型方法,具体介绍泛型方法的创建和使用。

定义泛型方法,参数类型使用 T 来代替,在方法的主体中打印出图书信息,代码实现如下:

 1: public class Test {
 2:     public static <T> void List(T book) { // 定义泛型方法
 3:         if (book != null) {
 4:             System.out.println(book);
 5:         }
 6:     }
 7: 
 8:     public static void main(String[] args) {
 9:         Book stu = new Book(1, "Learn Coding", 28);
10:         List(stu);                       // 调用泛型方法
11:         // → 1, Learn Coding, 28
12:     }
13: }

该程序中的 Book 类为前面示例中使用到的 Book 类。在该程序中定义了一个名称为 List 的方法,该方法的返回值类型为 void ,类型参数使用 T 来代替。在调用该泛型方法时,将一个 Book 对象作为参数传递到该方法中,相当于指明了该泛型方法的参数类型为 Book 。

TODO 泛型的高级用法

图书信息查询

在实际开发中,泛型集合是较常用的,一般定义集合都会使用泛型来定义。

下面我们使用泛型集合来模拟实现某图书管理系统的查询功能 – 在图书管理系统中为了方便管理图书,将图书划分为几个类别,每个类别对应多本图书,这就具备了一对多的关系映射。

在这种情况下就可以使用 Map 映射来存储类别和图书信息,其键为 Category (类别)类型,值为 List<Book> 类型(Book 类为图书类),然后使用嵌套循环遍历输出每个类别所对应的多个图书信息。具体的实现步骤如下:

(1)创建表示图书类的 Category 类,在该类中有两个属性: idname ,分别表示编号和类别名称,并实现了它们的 setter/getter ,具体内容如下:

 1: public class Category {
 2:     private int id;             // 类别编号
 3:     private String name;        // 类别名称
 4: 
 5:     public Category(int id, String name) {
 6:         this.id = id;
 7:         this.name = name;
 8:     }
 9: 
10:     public String toString() {
11:         return "所属分类:" + this.name;
12:     }
13: 
14:     // getter/setter
15:     // ...
16: }

(2)创建表示图书明细信息的 BookInfo 类,在该类中包含 5 个属性: id、name、price、authorstartTime ,分另表示图书编号、名称、价格、作者和出版时间,同样实现的 getter/setter ,具体内容如下:

 1: public class BookInfo {
 2:     private int id;             // 编号
 3:     private String name;        // 名称
 4:     private int price;          // 价格
 5:     private String author;      // 作者
 6:     private String startTime;   // 出版时间
 7: 
 8:     public BookInfo(int id, String name, int price, String author, String startTime) {
 9:         this.id = id;
10:         this.name = name;
11:         this.price = price;
12:         this.author = author;
13:         this.startTime = startTime;
14:     }
15: 
16:     public String toString() {
17:         return this.id + "\t\t" + this.name + "\t\t" + this.price + "\t\t" + this.author + "\t\t" + this.startTime;
18:     }
19: 
20:     // 上面 5 个属性的 setter/getter
21:     // ...
22: }

(3)创建 CategoryDao 类,在该类中定义了一个泛型的 Map 映射,其键为 Category 类型的对象,值为 List<BookInfo> 类型的对象,并定义 printCategoryInfo() 方法,用于打印类别和图书明细,具体代码如下:

 1: public class CategoryDao {
 2:     // 定义泛型 Map ,存储图书信息
 3:     public static Map<Category, List<BookInfo>> categoryMap = new HashMap<Category, List<BookInfo>>();
 4: 
 5:     public static void printDeptmentInfo() {
 6:         for (Category cate : categoryMap.keySet()) {
 7:             System.out.println("所属类别:" + cate.getName());
 8:             List<BookInfo> books = categoryMap.get(cate);
 9:             System.out.println("图书编号\t\t图书名称\t\t图书价格\t\t图书作者\t\t出版时间");
10:             for (inti = 0; i < books.size(); i++) {
11:                 BookInfo b = books.get(i); // 获取图书
12:                 System.out.println(b.getId() + "\t\t" + b.getName() + "\t\t" + b.getPrice() + "\t\t" + b.getAuthor() + "\t\t" + b.getStartTime());
13:             }
14:             System.out.println();
15:         }
16:     }
17: }

(4)创建测试类 Test

 1: public class Test {
 2:     public static void main(String[] args) {
 3:         // 创建类别信息
 4:         Category category1 = new Category(1, "程序设计");
 5:         Category category2 = new Category(2, "数据库");
 6:         Category category3 = new Category(3, "平面设计");
 7: 
 8:         // 创建图书信息
 9:         BookInfo book1 = new BookInfo(1, "细说 Java 编程", 25, "张晓玲", "2012-01-01");
10:         BookInfo book2 = new BookInfo(2, "影视后期处理宝典", 78, "刘水波", "2012-10-05");
11:         BookInfo book3 = new BookInfo(3, "MySQL 从入门到精通", 41, "王志亮", "2012-03-02");
12:         BookInfo book4 = new BookInfo(4, "Java 从入门到精通", 27, "陈奚静", "2012-11-01");
13:         BookInfo book5 = new BookInfo(5, "SQL Server 一百例", 68, "张晓玲", "2012-01-01");
14: 
15:         // 向类别 1 添加图书
16:         List<BookInfo> pList1 = new ArrayList<BookInfo>();
17:         pList1.add(book1);
18:         pList1.add(book4);
19:         // 向类别 2 添加图书
20:         List<BookInfo> pList2 = new ArrayList<BookInfo>();
21:         pList2.add(book3);
22:         pList2.add(book5);
23:         // 向类别 3 添加图书
24:         List<BookInfo> pList3 = new ArrayList<BookInfo>();
25:         pList.add(book2);
26: 
27:         // 映射
28:         CategoryDao.categoryMap.put(category1, pList1);
29:         CategoryDao.categoryMap.put(category2, pList2);
30:         CategoryDao.categoryMap.put(category3, pList3);
31: 
32:         CategoryDao.printDeptmentInfo();
33:     }
34: }

在该程序中,使用了泛型 List 和泛型 Map 分别存储图书类别和特定类别下的图书明信息。可见,使用泛型不仅减少了代码的编写量,也提高了类型的安全性。

运行该程序,输出结果如下:

所属类别:程序设计
图书编号  图书名称  图书价格  图书作者  出版时间
3  MySQL 从入门到精通  41  王志亮  2012-3-2
5  SQL Server 一百例   68  张晓玲  2012-01-01

所属类别:数据库
图书编号  图书名称  图书价格  图书作者  出版时间
1  细说 Java 编程     25  张晓玲  2012-01-01
4  Java 从入门到精通  27  陈奚静  2012-11-01

所属类别:平面设计
图书编号  图书名称  图书价格  图书作者  出版时间
2  影视后期处理宝典   78  刘水波  2012-10-05

枚举

枚举是一个被命名的整型常数的集合,用于声明一组带标识符的常数。

枚举在日常生活中很常见,例如一个人的性别只能是“男”或者“女”,一周的星期只能是 7 天中的一个等。类似这种当一个变量有几种固定可能的取值时,就可以将它定义为枚举类型。

在 JDK 1.5 之前没有枚举类型,那时候一般用接口常量来代替,而使用 Java 枚举类型 enum 可以更贴近地表示这种常量。

声明枚举

声明枚举必须使用 enum 关键字 ,然后定义枚举的名称、可访问性、基础类型和成员等,语法格式如下:

enum-modifiers enum enumname:enum-base {
    enum-body;
}

其中:

  • enum-modifiers 表示枚举的修饰符主要包括 public、privateinternal
  • enumname 表示声明的枚举名称;
  • enum-base 表示基础类型;
  • enum-body 表示枚举的成员,它是枚举类型的命名常数。

任意两个枚举成员不能具有相同的名称,且它的常数值必须在该枚举的基础类型的范围之内,多个枚举成员之间使用逗号分隔。

*注:如果没有显式地声明基础类型的枚举,那么意味着它所对应的基础类型是 int

来看几个例子吧。

如需要定义一个表示性别的枚举类型 SexEnum 和一个表示颜色的枚举类型 Color ,代码如下:

1: public enum SexEnum {
2:     male, female;
3: }
4: 
5: public enum Color {
6:     RED, BLUE, GREEN, BLACK;
7: }

之后便可以通过枚举类型名直接引用常量 ,如 SexEnum.male、Color.RED

使用枚举还可以使 switch 语句的可读性更强,如下:

 1: enum Signal {
 2:     // 定义一个枚举类型
 3:     GREEN, YELLOW, RED;
 4: }
 5: public class TrafficLight {
 6:     Signal color = Signal.RED;
 7:     public void change() {
 8:         switch(color) {
 9:         case RED:
10:             color = Signal.GREEN;
11:             break;
12:         case YELLOW:
13:             color = Signal.RED;
14:             break;
15:         case GREEN:
16:             color = Signal.YELLOW;
17:             break;
18:         }
19:     }
20: }

枚举类型

Java 中的每一个枚举类都继承自 java.lang.Enum

当定义一个枚举类型时,每一个枚举类型成员都可以看作是 Enum 类的实例,这些枚举成员默认都被 final、public、static 修饰,当使用枚举类型成员时,直接使用枚举名称调用成员即可。

*所有枚举实例都可以调用 Enum 类的方法*,如下:

Table 9: Enum 类的常用方法
方法名称 描述
values() 以数组形式返回枚举类型的所有成员
valueOf() 将普通字符串转换为枚举实例
compateTo() 比较两个枚举成员在定义时的顺序
ordinal() 获取枚举成员的索引位置

来看一个例子吧,如下:

 1: public class TestEnum {
 2:     public enum Sex {
 3:         // 定义一个枚举
 4:         male, female;
 5:     }
 6: 
 7:     public static void main(String[] args) {
 8:         compare(Sex.valueOf("male")); // 将变通字符串转换为枚举实例
 9:     }
10: 
11:     public static void compare(Sex s) {
12:         for (int i = 0; i < Sex.values().length; i++) {
13:             System.out.println("索引" + Signal.values()[i].ordinal() + "," + s + "与" + Sex.values()[i] + "的比较结果是:" + s.compareTo(Sex.values()[i]));
14:         }
15:     }
16: 
17:     // → 索引0,male与male的比较结果是:0
18:     // → 索引1,male与female的比较结果是:-1
19: }

为枚举添加方法

Java 为枚举类型提供了一些内置方法,同时枚举常量也可以有自己的方法。要注意,必须在枚举实例的最后一个成员后添加分号,而且必须先定义枚举实例。

 1: enum WeekDay {
 2:     Mon("Monday"), Tue("Tuesday"), Wed("Wednesday"), Thu("Thursday"), Fri("Friday"), Sat("Saturday"), Sun("Sunday");
 3:     // 以上是枚举的成员,必须先定义,而且使用分号结束
 4:     private final String day;
 5:     private WeekDay(String day) {
 6:         this.day = day;
 7:     }
 8: 
 9:     public static void printDay(int i) {
10:         switch(i) {
11:             case 1:
12:                 System.out.println(WeekDay.Mon);
13:                 break;
14:             case 2:
15:                 System.out.println(WeekDay.Tue);
16:                 break;
17:             ...
18:             case 7:
19:                 System.out.println(WeekDay.Sun);
20:                 break;
21:             default:
22:                 System.out.println("wrong number!");
23:         }
24:     }
25: 
26:     public String getDay() {
27:         return day;
28:     }
29: }

上面创建了 WeekDay 枚举类型,下面遍历该枚举中的所有成员,并调用 printDay() 方法,代码如下:

 1: public static void main(String[] args) {
 2:     for (WeekDay day : WeekDay.values()) {
 3:         System.out.println(day + "→ " + day.getDay());
 4:     }
 5:     WeekDay.printDay(5);
 6: }
 7: 
 8: // → Mon → Monday
 9: // → Tue → Tuesday
10: // ...
11: // → Sum → Sunday
12: // → Fri

Java 中的 enum 还可以跟 Class 类一样的覆盖基类的方法,如下创建的 Color 枚举类型覆盖了 toString() 方法:

 1: public class Test {
 2:     public enum Color {
 3:         RED("红色", 1), GREEN("绿色", 2), WHITE("白色", 3), YELLOW("黄色", 4);
 4:         // 成员变量
 5:         private String name;
 6:         private int index;
 7:         // 构造方法
 8:         private Color(String name, int index) {
 9:             this.name = name;
10:             this.index = index;
11:         }
12:         // 覆盖方法
13:         @Override
14:         public String toString() {
15:             return this.index + "-" + this.name;
16:         }
17:     }
18: 
19:     public static void main(String[] args) {
20:         System.out.println(Color.RED.toString()); // → 1-红色
21:     }
22: }

EnumMap 与 EnumSet

为了更好地支持枚举类型, java.util 中添加了现个新类: EnumMapEnumSet ,使用它们可以更高效地操作枚举类型。

1. EnumMap 类

EnumMap 是专门为枚举类型量身定做的 Map 实现。虽然使用其他的 Map (如 HashMap )实现也能完成枚举类型实例到值的映射,但是使用 EnumMap 会更加高效。

HashMap 只能接收同一枚举类型的实例作为键值,并且由于枚举类型实例的数量相对固定并且有限,所以 EnumMap 使用数组来存放与枚举类型对应的值,使得 EnumMap 的效率非常高。

下面是使用 EnumMap 的一个代码示例,枚举类型 DataBaseType 里存放了现在支持的所有数据库类型,针对不同的数据库,一些数据库相关的方法需要返回不一样的值,如示例中 getURL() 方法:

 1: // 定义数据库类型枚举
 2: public enum DataBaseType {
 3:     MYSQL, ORACLE, DB2, SQLSERVER;
 4: }
 5: // 某类中定义的获取数据库 URL 的方法以及 EnumMap 的声明
 6: private EnumMap<DataBaseType, String> urls = new EnumMap<DataBaseType, String>(DataBaseType.class);
 7: public DataBaseInfo() {
 8:     urls.put(DataBaseType.DB2, "jdbc:db2://localhost:5000/sample");
 9:     urls.put(DataBaseType.MYSQL, "jdbc:mysql://localhost/mydb");
10:     urls.put(DataBaseType.ORACLE, "jdbc:oracle:thin:@localhost:1521:sample");
11:     urls.put(DataBaseType.SQLSEVER, "jdbc:microsoft:sqlserver://sql:1433;Database=mydb");
12: }
13: // 根据不同的数据库类型,返回对应的 URL
14: // @param type DataBaseType 枚举类新实例
15: // @return
16: public String getURL(DataBaseType type) {
17:     return this.urls.get(type);
18: }

在实际使用中,EnumMap 对象 urls 往往是由外部负责整个应用初始化的代码来填充的。这里为了演示方便,类自己做了内容填充。

从本例中可以看出,使用 EnumMap 可以很方便地为枚举类型在不同的环境中绑定到不同的值上。本例子中 getURL 绑定到 URL 上,在其他的代码中可能又被绑定到数据库驱动上去。

2. EnumSet 类

EnumSet 是枚举类型的高性能 Set 实现,它要求放入它的枚举常量必须属于同一枚举类型。 EnumSet 提供了许多工厂方法以便于初始化,如下:

Table 10: EnumSet 类的常用方法
方法名称 描述
allOf(Class<E> element type) 创建一个包含指定枚举类型中所有枚举成员的 EnumSet 对象
complementOf(EnumSet<E> s) 创建一个与指定 EnumSet 对象 s 相同的枚举类型 EnumSet 对象,并包含所有 s 中未包含的枚举成员
copyOf(EnumSet<E> s) 创建一个与指定 EnumSet 对象 s 相同的枚举类型 EnumSet 对象,并与 s 包含相同的枚举成员
noneOf(<Class E> elementType) 创建指定枚举类型的空 EnumSet 对象
of(E first, e...rest) 创建包含指定枚举成员的 EnumSet 对象
range(E from, E to) 创建一个 EnumSet 对象,该对象包含了 from 到 to 之间的所有枚举成员

EnumSet 作为 Set 接口实现,它支持对包含的枚举常量的遍历。

1: for (Operation op:EnumSet.range(Operation.PLUS, Operation.MULTIPLY)) {
2:     doSomeThing(op);
3: }

Date: 2020-09-29 Tue 19:05

Author: Jack Liu

Created: 2020-10-03 Sat 11:24

Validate