目录
三、Java Collection类：sort()升序排序、reverse()降序排序、copy()复制、fill()填充
四、Java List集合：ArrayList类、LinkList类、ArrayList类和LinkList类的区别
六、Java Set集合详解：HashSet类、TreeSet 类
七、Java枚举（enum）详解：Java声明枚举类型、枚举（enum）类、EnumMap 与 EnumSet
八、Java泛型详解：Java泛型集合、泛型类、泛型方法、泛型的使用
一、Java集合类的概念
Java的所有集合类都位于 java.util 包，其中提供了一个表示和操作对象集合的统一构架，包含大量集合接口，以及这些接口的实现类和操作它们的算法。
一个集合是一个对象，但它表示一组对象，Java 集合中实际存放的是对象的引用值，不能存放基本数据类型值。
1.集合中的接口
集合框架是一个类库的集合，包含实现集合的接口。接口是集合的抽象数据类型，提供对集合中所表示的内容进行单独操作的可能。
- Collection 接口：该接口是最基本的集合接口，一个 Collection 代表一个元素。
- List 接口：该接口实现了 Collection 接口。List 是有序集合，允许有相同的元素。使用 List 能够精确地控制每个元素插入的位置，用户能够使用索引（元素在 List 中的位置，类似于数组下标）来访问 List 中的元素，与数组类似。
- Set 接口：该接口也实现了 Collection 接口。它不能包含重复的元素，SortedSet 是按升序排列的 Set 集合。
- Map 接口：包含键值对，Map 不能包含重复的键。SortedMap 是一个按升序排列的 Map 集合。
集合框架中的接口结构如图 1 所示。
图1 集合框架中的接口结构图
2.接口实现类
Java 平台提供了许多数据集接口的实现类。例如实现 Set 接口的常用类有 HashSet 和 TreeSet，它们都可以容纳所有类型的对象，但是不能保证序列顺序永久不变。
实现 List 接口的常用类有 ArrayList 和 LinkedList，它们也可以容纳所有类型的对象包括 null，并且都保证元素的存储位置。
实现 Map 映射的类是 HashMap，可实现一个键到值的映射。
- HashSet：为优化査询速度而设计的 Set。它是基于 HashMap 实现的，HashSet 底层使用 HashMap 来保存所有元素，实现比较简单。
- TreeSet：该类不仅实现了 Set 接口，还实现了 java.util.SortedSet 接口，该实现类是一个有序的 Set，这样就能从 Set 里面提取一个有序序列。
- ArrayList：一个用数组实现的 List，能进行快速的随机访问，效率高而且实现了可变大小的数组。
- LinkedList：对顺序访问进行了优化，但随机访问的速度相对较慢。此外它还有 addFirst()、addLast()、getFirst()、getLast()、removeFirst() 和 removeLast() 等方法，能把它当成栈（Stack）或队列（Queue）来用。
集合框架接口中实现类 的结构如图 2 所示。
图2 集合框架中的实现类结构图
二、Java Collection接口
Collection 接口是 List 接口和 Set 接口的父接口，通常情况下不被直接使用。Collection 接口定义了一些通用的方法，通过这些方法可以实现对集合的基本操作。因为 List 接口和 Set 接口继承自 Collection 接口，所以也可以调用这些方法。
本节将介绍 Collection 接口中常用的方法，如表 1 所示。
| 方法名称 | 说明 |
|---|---|
| boolean add(E e) | 向集合中添加一个元素，E 是元素的数据类型 |
| boolean addAll(Collection c) | 向集合中添加集合 c 中的所有元素 |
| void clear() | 删除集合中的所有元素 |
| boolean contains(Object o) | 判断集合中是否存在指定元素 |
| boolean containsAll(Collection c) | 判断集合中是否包含集合 c 中的所有元素 |
| boolean isEmpty() | 判断集合是否为空 |
| Iterator<E>iterator() | 返回一个 Iterator 对象，用于遍历集合中的元素 |
| boolean remove(Object o) | 从集合中删除一个指定元素 |
| boolean removeAll(Collection c) | 从集合中删除所有在集合 c 中出现的元素 |
| boolean retainAll(Collection c) | 仅仅保留集合中所有在集合 c 中出现的元素 |
| int size() | 返回集合中元素的个数 |
| Object[] toArray() | 返回包含此集合中所有元素的数组 |
例 1
经过前面的介绍，我们知道 Collection 是非常重要的一个接口，在表 1 中列出了其常用方法。本案例将编写一个简单的程序，演示如何使用 Collection 接口向集合中添加方法。具体实现代码如下：
1. public static void main(Strmg[] args)
2. {
3. ArrayList list1=new ArrayList(); //创建集合 iist1
4. ArrayList list2=new ArrayList(); //创建集合 Iist2
5. list1.add("one"); //向 list1 添加一个元素
6. list1.add("two"); //向 list1 添加一个元素
7. list2.addAll(list1); //将 list1 的所有元素添加到 list2
8. list2.add("three"); //向 list2 添加一个元素
9. System.out.println("list2 集合中的元素如下：");
10. Iterator it1=list2.iterator();
11. while(it1.hasNext())
12. {
13. System.out.print(it1.next()+"、");
14. }
15. }
由于 Collection 是接口，不能对其实例化，所以上述代码中使用了 Collection 接口的 ArrayList 实现类来调用 Collection 的方法。add() 方法可以向 Collection 中添加一个元素，而调用 addAll() 方法可以将指定 Collection 中的所有元素添加到另一个 Collection 中。
代码创建了两个集合 list1 和 list2，然后调用 add() 方法向 list1 中添加了两个元素，再调用 addAll() 方法将这两个元素添加到 list2 中。接下来又向 list2 中添加了一个元素，最后输出 list2 集合中的所有元素，结果如下：
list2 集合中的元素如下：
one、two、three、
例 2
创建一个案例，演示 Collection 集合中 size()、remove() 和 removeAll() 方法的应用。具体代码如下：
1. public static void main(String[] args)
2. {
3. ArrayList list1=new ArrayList(); //创建集合 list1
4. ArrayList list2=new ArrayList(); //创建集合 list2
5. list1.add("one");
6. list1.add("two");
7. list1.add("three");
8. System.out.println("list1 集合中的元素数量："+list1.size()); //输出list1中的元素数量
9. list2.add("two");
10. list2.add("four");
11. list2.add("six");
12. System.out.println("list2 集合中的元素数量："+list2.size()); //输出list2中的元素数量
13. list2.remove(2); //删除第 3 个元素
14. System.out.println("\nremoveAll() 方法之后 list2 集合中的元素数量："+list2.size());
15. System.out.println("list2 集合中的元素如下：");
16. Iterator it1=list2.iterator();
17. while(it1.hasNext())
18. {
19. System.out.print(it1.next()+"、");
20. }
21. list1.removeAll(list2);
22. System.out.println("\nremoveAll() 方法之后 list1 集合中的元素数量："+list1.size());
23. System.out.println("list1 集合中的元素如下：");
24. Iterator it2=list1.iterator();
25. while(it2.hasNext())
26. {
27. System.out.print(it2.next()+"、");
28. }
29. }
list2 集合在调用 remove(2) 方法删除第 3 个元素之后剩下了 two 和 four。list1.removeAll(list2) 语句会从 list1 中将 list1 和 list2 中相同的元素删除，即删除 two 元素。最后输出结果如下：
list1 集合中的元素数量：3
Iist2 集合中的元素数量：3
remove() 方法之后 list2 集合中的元素数量：2
list2 集合中的元素如下：
two、four、
removeAH() 方法之后 list1 集合中的元素数量：2
list1 集合中的元素如下：
one、 three、
注意：retainAll() 方法的作用与 removeAll() 方法相反，即保留两个集合中相同的元素，其他全部删除。
三、Java Collection类：sort()升序排序、reverse()降序排序、copy()复制、fill()填充
Collections 类提供了许多操作集合的静态方法，借助这些静态方法可以实现集合元素的排序、填充和复制等操作。下面介绍 Collections 类中操作集合的常用方法。
1.正向排序
使用 Collections 类的静态方法 sort() 可以对集合中的元素进行升序排序。这要求列表中的所有元素都必须实现 Comparable 接口，而且所有元素都必须是使用指定比较器可相互比较的。
sort() 方法主要有如下两种重载形式。
- void sort(List list)：根据元素的自然顺序对集合中的元素进行升序排序。
- void sort(List list,Comparator comparator)：按 comparator 参数指定的排序方式对集合中的元素进行排序。
例 1
编写一个程序，对用户输入的 5 个商品价格进行排序后输出。这里要求使用 Collections 类中 sort() 方法按从低到局的顺序对其进行排序，最后将排序后的成绩输出。
具体实现代码如下：
1. import java.util.ArrayList;
2. import java.util.Collections;
3. import java.util.List;
4. import java.util.Scanner;
5. public class Test10
6. {
7. public static void main(String[] args)
8. {
9. Scanner input=new Scanner(System.in);
10. List prices=new ArrayList();
11. for(int i=0;i<5;i++)
12. {
13. System.out.println("请输入第 "+(i+1)+" 个商品的价格：");
14. int p=input.nextInt();
15. prices.add(Integer.valueOf(p)); //将录入的价格保存到List集合中
16. }
17. Collections.sort(prices); //调用sort()方法对集合进行排序
18. System.out.println("价格从低到高的排列为：");
19. for(int i=0;i<prices.size();i++)
20. {
21. System.out.print(prices.get(i)+"\t");
22. }
23. }
24. }
如上述代码，循环录入 5 个价格，并将每个价格都存储到已定义好的 List 集合 prices 中，然后使用 Collections 类的 sort() 方法对该集合元素进行升序排序。最后使用 for 循环遍历 users 集合，输出该集合中的元素。
该程序的执行结果如下所示。
请输入第 1 个商品的价格：
85
请输入第 2 个商品的价格：
48
请输入第 3 个商品的价格：
66
请输入第 4 个商品的价格：
80
请输入第 5 个商品的价格：
18
价格从低到高的排列为：
18 48 66 80 85
2.逆向排序
与 sort() 方法的作用相反，调用 reverse() 静态方法可以对指定集合元素进行逆向排序。
该方法的定义如下：
void reverse(List list) //对集合中的元素进行反转排序例 2
循环录入 5 个商品的名称，并按录入时间的先后顺序进行降序排序，即后录入的先输出。
下面编写程序，使用 Collections 类的 reverse() 方法对保存到 List 集合中的 5 个商品名称进行反转排序，并输出排序后的商品信息。具体的实现代码如下：
1. import java.util.ArrayList;
2. import java.util.Coliections;
3. import java.util.List;
4. import java.util.Scanner;
5. public class Test11
6. {
7. public static void main(String[] args)
8. {
9. Scanner input=new Scanner(System.in);
10. List students=new ArrayList();
11. System.out.println("******** 商品信息 ********");
12. for(int i=0;i<5;i++)
13. {
14. System.out.println("请输入第 "+(i+1)+" 个商品的名称：");
15. String name=input.next();
16. students.add(name); //将录入的商品名称存到List集合中
17. }
18. Collections.reverse(students); //调用reverse()方法对集合元素进行反转排序
19. System.out.println("按录入时间的先后顺序进行降序排列为：");
20. for(int i=0;i<5;i++)
21. {
22. System.out.print(students.get(i)+"\t");
23. }
24. }
25. }
如上述代码，首先循环录入 5 个商品的名称，并将这些名称保存到 List 集合中，然后调用 Collections 类中的 reverse() 方法对该集合元素进行反转排序。最后使用 for 循环将排序后的集合元素输出。
执行该程序，输出结果如下所示。
******** 商品信息 ********
请输入第 1 个商品的名称：
果粒橙
请输入第 2 个商品的名称：
冰红茶
请输入第 3 个商品的名称：
矿泉水
请输入第 4 个商品的名称：
软面包
请输入第 5 个商品的名称：
巧克力
按录入时间的先后顺序进行降序排列为：
巧克力 软面包 矿泉水 冰红茶 果粒橙
3.复制
Collections 类的 copy() 静态方法用于将指定集合中的所有元素复制到另一个集合中。执行 copy() 方法后，目标集合中每个已复制元素的索引将等同于源集合中该元素的索引。
copy() 方法的语法格式如下：
void copy(List <? super T> dest,List<? extends T> src)其中，dest 表示目标集合对象，src 表示源集合对象。
注意：目标集合的长度至少和源集合的长度相同，如果目标集合的长度更长，则不影响目标集合中的其余元素。如果目标集合长度不够而无法包含整个源集合元素，程序将抛出 IndexOutOfBoundsException 异常。
例 3
在一个集合中保存了 5 个商品名称，现在要使用 Collections 类中的 copy() 方法将其中的 3 个替换掉。具体实现的代码如下：
1. public class Test12
2. {
3. public static void main(String[] args)
4. {
5. Scanner input=new Scanner(System.in);
6. List srcList=new ArrayList();
7. List destList=new ArrayList();
8. destList.add("苏打水");
9. destList.add("木糖醇");
10. destList.add("方便面");
11. destList.add("火腿肠");
12. destList.add("冰红茶");
13. System.out.println("原有商品如下：");
14. for(int i=0;i<destList.size();i++)
15. {
16. System.out.println(destList.get(i));
17. }
18. System.out.println("输入替换的商品名称：");
19. for(int i=0;i<3;i++)
20. {
21. System.out.println("第 "+(i+1)+" 个商品：");
22. String name=input.next();
23. srcList.add(name);
24. }
25. //调用copy()方法将当前商品信息复制到原有商品信息集合中
26. Collections.copy(destList,srcList);
27. System.out.println("当前商品有：");
28. for(int i=0;i<destList.size();i++)
29. {
30. System.out.print(destList.get(i)+"\t");
31. }
32. }
33. }
如上述代码，首先创建了两个 List 对象 srcList 和 destList，并向 destList 集合中添加了 5 个元素，向 srcList 集合中添加了 3 个元素，然后调用 Collections 类中 copy() 方法将 srcList 集合中的全部元素复制到 destList 集合中。由于 destList 集合中含有 5 个元素，故最后两个元素不会被覆盖。
运行该程序，具体的执行结果如下所示。
原有商品如下：
苏打水
木糖醇
方便面
火腿肠
冰红茶
输入替换的商品名称：
第 1 个商品：
燕麦片
第 2 个商品：
八宝粥
第 3 个商品：
软面包
当前商品有：
燕麦片 八宝粥 软面包 火腿肠 冰红茶
4.填充
Collections 类的 fill() 静态方法可以对指定集合的所有元素进行填充操作。fill() 方法的定义如下:
void fill(List<? super T> list,T obj) //使用指定元素替换指定列表中的所有元素其中，list 表示要替换的集合对象，obj 表示用来替换指定集合的元素值。
例 4
编写一个程序，要求用户输入 3 个商品名称，然后使用 Collections 类中的 fill() 方法对商品信息进行重置操作，即将所有名称都更改为“未填写”。具体的实现代码如下：
1. import java.util.ArrayList;
2. import java.util.Collections;
3. import java.util.List;
4. import java.util.Scanner;
5. public class Test13
6. {
7. public static void main(String[] args)
8. {
9. Scanner input=new Scanner(System.in);
10. List products=new ArrayList();
11. System.out.println("******** 商品信息 ********");
12. for(int i=0;i<3;i++)
13. {
14. System.out.println("请输入第 "+(i+1)+" 个商品的名称：");
15. String name=input.next();
16. products.add(name); //将用户录入的商品名称保存到List集合中
17. }
18. System.out.println("重置商品信息，将所有名称都更改为'未填写'");
19. Collections.fill(products,"未填写");
20. System.out.println("重置后的商品信息为：");
21. for(int i=0;i<products.size();i++)
22. {
23. System.out.print(products.get(i)+"\t");
24. }
25. }
26. }
如上述代码，首先循环录入 3 个商品名称，并将这些商品信息存储到 List 集合中，然后调用 Collections 类中的 fill() 方法将该集合中的所有元素值替换为“未填写”。最后使用 for 循环将替换后的集合元素输出。
运行该程序，执行结果如下所示。
******** 商品信息 ********
请输入第 1 个商品的名称：
苏打水
请输入第 2 个商品的名称：
矿泉水
请输入第 3 个商品的名称：
冰红茶
重置商品信息，将所有名称都更改为'未填写'
重置后的商品信息为：
未填写 未填写 未填写
四、Java List集合：ArrayList类、LinkList类、ArrayList类和LinkList类的区别
List 接口实现了 Collection 接口，它主要有两个实现类：ArrayList 类和 LinkedList 类。在 List 集合中允许出现重复元素。与 Set 集合不同的是，在 List 集合中的元素是有序的，可以根据索引位置来检索 List 集合中的元素，第一个添加到 List 集合中的元素的索引为 0，第二个为 1，依此类推。
1.ArrayList 类
ArrayList 类提供了快速的基于索引的成员访问方式，对尾部成员的增加和删除支持较好。使用 ArrayList 创建的集合，允许对集合中的元素进行快速的随机访问，不过，向 ArrayList 中插入与删除元素的速度相对较慢。该类的常用构造方法有如下两种重载形式。
- ArrayList()：构造一个初始容量为 10 的空列表。
- ArrayList(Collection<?extends E>c)：构造一个包含指定 Collection 的元素的列表，这些元素是按照该 Collection 的迭代器返回它们的顺序排列的。
ArrayList 类除了包含 Collection 接口中的所有方法之外，还包括 List 接口中提供的如表 1 所示的方法。
| 方法名称 | 说明 |
| E get(int index) | 获取此集合中指定索引位置的元素，E 为集合中元素的数据类型 |
| int index(Object o) | 返回此集合中第一次出现指定元素的索引，如果此集合不包含该元 素，则返回 -1 |
| int lastIndexOf(Obj ect o) | 返回此集合中最后一次出现指定元素的索引，如果此集合不包含该 元素，则返回 -1 |
| E set(int index, E element) | 将此集合中指定索引位置的元素修改为 element 参数指定的对象。 此方法返回此集合中指定索引位置的原元素 |
| List<E> subList(int fromlndex, int tolndex) | 返回一个新的集合，新集合中包含 fromlndex 和 tolndex 索引之间 的所有元素。包含 fromlndex 处的元素，不包含 tolndex 索引处的 元素 |
例 1
使用 ArrayList 类向集合中添加三个商品信息，包括商品编号、名称和价格，然后遍历集合输出这些商品信息。
(1) 创建一个商品类 Product，在该类中定义 3 个属性和 toString() 方法，分别实现 setter/getter 方法。代码的实现如下：
1. public class Product
2. {
3. //商品类
4. private int id; //商品编号
5. private String name; //名称
6. private float price; //价格
7. public Product(int id,String name,float price)
8. {
9. this.name=name;
10. this.id=id;
11. this.price=price;
12. }
13. //这里是上面3个属性的setter/getter方法，这里省略
14. public String toString()
15. {
16. return"商品编号："+id+"，名称:"+name+"，价格："+price;
17. }
18. }
(2) 创建一个测试类，调用 Product 类的构造函数实例化三个对象，并将 Product 对象保存至 ArrayList 集合中。最后遍历该集合，输出商品信息。测试类的代码实现如下：
1. import Java.util.ArrayList;
2. import java.util.List;
3. public class Test03
4. {
5. public static void main(String[] args)
6. {
7. Product pd1=new Product(4,"木糖醇",10);
8. Product pd2=new Product(5,"洗发水",12);
9. Product pd3=new Product(3,"热水壶",49);
10. List list=new ArrayList(); //创建集合
11. list.add(pd1);
12. list.add(pd2);
13. list.add(pd3);
14. System.out.println("*************** 商品信息 ***************");
15. for(int i=0;i<list.size();i++)
16. {
17. //循环遍历集合，输出集合元素
18. Product product=(Product)list.get(i);
19. System.out.println(product);
20. }
21. }
22. }
该示例中的 ArrayList 集合中存放的是自定义类 Product 的对象，这与存储的 String 类的对象是相同的。与 Set 不同的是，List 集合中存在 get() 方法，该方法可以通过索引来获取所对应的值，获取的值为 Object 类，因此需要将该值转换为 Product 类，从而获取商品信息。
该程序的运行结果如下所示。
*************** 商品信息 ***************
商品编号：4，名称:木糖醇，价格：10.0
商品编号：5，名称:洗发水，价格：12.0
商品编号：3，名称:热水壶，价格：49.0
例 2
在使用 List 集合时需要注意区分 indexOf() 方法和 lastIndexOf() 方法。前者是获得指定对象的最小索引位置，而后者是获得指定对象的最大索引位置。前提条件是指定的对象在 List 集合中有重复的对象，否则这两个方法获取的索引值相同。
下面的案例代码演示了 indexOf() 方法和 lastIndexOf() 方法的区别。
1. public static void main(String[] args)
2. {
3. List list=new ArrayList();
4. list.add("One");
5. list.add("|");
6. list.add("Two");
7. list.add("|");
8. list.add("Three");
9. list.add("|");
10. list.add("Four");
11. System.out.println("list 集合中的元素数量："+list.size());
12. System.out.println("list 集合中的元素如下：");
13. Iterator it=list.iterator();
14. while(it.hasNext())
15. {
16. System.out.print(it.next()+"、");
17. }
18. System.out.println("\n在 list 集合中'丨'第一次出现的位置是："+list.indexOf("|"));
19. System.out.println("在 list 集合中'丨'最后一次出现的位置是："+list.lastIndexOf("|"));
20. }
上述代码创建一个 List 集合 list，然后添加了 7 个元素，由于索引从 0 开始，所以最后一个元素的索引为 6。输出结果如下：
list 集合中的元素数量：7
list 集合中的元素如下：
One、|、Two、|、Three、|、Four、
在 list 集合中'|'第一次出现的位置是：1
在 list 集合中'|'最后一次出现的位置是：5
例 3
使用 subList() 方法截取 List 集合中部分元素时要注意，新的集合中包含起始索引位置的元素，但是不包含结束索引位置的元素。例如，subList(1,4) 方法实际截取的是索引 1 到索引 3 的元素，并组成新的 List 集合。
下面的案例代码演示了 subList() 方法的具体用法。
1. public static void main(String[] args)
2. {
3. List list=new ArrayList();
4. list.add("One");
5. list.add("Two");
6. list.add("Three");
7. list.add("Four");
8. list.add("Five");
9. list.add("Six");
10. list.add("Seven");
11. System.out.println("list 集合中的元素数量："+list.size());
12. System.out.println("list 集合中的元素如下：");
13. Iterator it=list.iterator();
14. while(it.hasNext())
15. {
16. System.out.print(it.next()+"、");
17. }
18. List sublist=new ArrayList();
19. sublist=list.subList(2,5); //从list集合中截取索引2~5的元素，保存到sublist集合中
20. System.out.println("\nsublist 集合中元素数量："+sublist.size());
21. System.out.println("sublist 集合中的元素如下：");
22. it=sublist.iterator();
23. while(it.hasNext())
24. {
25. System.out.print(it.next()+"、");
26. }
27. }
输出结果如下：
list 集合中的元素数量：7
list 集合中的元素如下：
One、Two、Three、Four、Five、Six、Seven、
sublist 集合中元素数量：3
sublist 集合中的元素如下：
Three、Four、Five、
2.LinkList类
LinkedList 类采用链表结构保存对象，这种结构的优点是便于向集合中插入或者删除元素。需要频繁向集合中插入和删除元素时，使用 LinkedList 类比 ArrayList 类效果高，但是 LinkedList 类随机访问元素的速度则相对较慢。这里的随机访问是指检索集合中特定索引位置的元素。
LinkedList 类除了包含 Connection 接口和 List 接口中的所有方法之外，还特别提供了表 2 所示的方法。
| 方法名称 | 说明 |
| void addFirst(E e) | 将指定元素添加到此集合的开头 |
| void addLast(E e) | 将指定元素添加到此集合的末尾 |
| E getFirst() | 返回此集合的第一个元素 |
| E getLast() | 返回此集合的最后一个元素 |
| E removeFirst() | 删除此集合中的第一个元素 |
| E removeLast() | 删除此集合中的最后一个元素 |
例 4
在仓库管理系统中要记录入库的商品名称，并且需要输出第一个录入的商品名称和最后—个商品名称。下面使用 LinkedList 集合来完成这些功能，实现代码如下：
1. public static void main(String[] args)
2. {
3. LinkedList<String> products=new LinkedList<String>(); //创建集合对象
4. String p1=new String("六角螺母");
5. String p2=new String("10A 电缆线");
6. String p3=new String("5M 卷尺");
7. String p4=new String("4CM 原木方板");
8. products.add(p1); //将 pi 对象添加到 LinkedList 集合中
9. products.add(p2); //将 p2 对象添加到 LinkedList 集合中
10. products.add(p3); //将 p3 对象添加到 LinkedList 集合中
11. products.add(p4); //将 p4 对象添加到 LinkedList 集合中
12. String p5=new String("标准文件夹小柜");
13. products.addLast(p5); //向集合的末尾添加p5对象
14. System.out.print("*************** 商品信息 ***************");
15. System.out.println("\n目前商品有：");
16. for(int i=0;i<products.size();i++)
17. {
18. System.out.print(products.get(i)+"\t");
19. }
20. System.out.println("\n第一个商品的名称为："+products.getFirst());
21. System.out.println("最后一个商品的名称为："+products.getLast());
22. products.removeLast(); //删除最后一个元素
23. System.out.println("删除最后的元素，目前商品有：");
24. for(int i=0;i<products.size();i++)
25. {
26. System.out.print(products.get(i)+"\t");
27. }
28. }
如上述代码，首先创建了 5 个 String 对象，分别为 p1、p2、p3、p4 和 p5。同时将 pl、 p2、p3 和 p4 对象使用 add() 方法添加到 LinkedList 集合中，使用 addLast() 方法将 p5 对象添加到 LinkedList 集合中。分别调用 LinkedList 类中的 getFirst() 方法和 getLast()方法获取第一个和最后一个商品名称。最后使用 removeLast() 方法将最后一个商品信息删除，并将剩余商品信息打印出来。
LinkedList<String> 中的 <String> 是 Java 中的泛型，用于指定集合中元素的数据类型，例如这里指定元素类型为 String，则该集合中不能添加非 String 类型的元素。
运行程序，执行结果如下：
*************** 商品信息 ***************
目前商品有：
六角螺母 10A 电缆线 5M 卷尺 4CM 原木方板 标准文件夹小柜
第一个商品的名称为：六角螺母
最后一个商品的名称为：标准文件夹小柜
删除最后的元素，目前商品有：
六角螺母 10A 电缆线 5M 卷尺 4CM 原木方板
五、Java Map集合详解
Map 是一种键-值对（key-value）集合，Map 集合中的每一个元素都包含一个键对象和一个值对象。其中，键对象不允许重复，而值对象可以重复，并且值对象还可以是 Map 类型的，就像数组中的元素还可以是数组一样。
Map 接口主要有两个实现类：HashMap 类和 TreeMap 类。其中，HashMap 类按哈希算法来存取键对象，而 TreeMap 类可以对键对象进行排序。
Map 接口中提供的常用方法如表 1 所示。
| 方法名称 | 说明 |
| V get(Object key) | 返回 Map 集合中指定键对象所对应的值。V 表示值的数据类型 |
| V put(K key, V value) | 向 Map 集合中添加键-值对，返回 key 以前对应的 value，如果没有， 则返回 null |
| V remove(Object key) | 从 Map 集合中删除 key 对应的键-值对，返回 key 对应的 value，如 果没有，则返回null |
| Set entrySet() | 返回 Map 集合中所有键-值对的 Set 集合，此 Set 集合中元素的数据 类型为 Map.Entry |
| Set keySet() | 返回 Map 集合中所有键对象的 Set 集合 |
例 1
每名学生都有属于自己的唯一编号，即学号。在毕业时需要将该学生的信息从系统中移除。
下面编写 Java 程序，使用 HashMap 来存储学生信息，其键为学生学号，值为姓名。毕业时，需要用户输入学生的学号，并根据学号进行删除操作。具体的实现代码如下：
1. import java.util.HashMap;
2. import java.util.Iterator;
3. import java.util.Scanner;
4. public class Test09
5. {
6. public static void main(String[] args)
7. {
8. HashMap users=new HashMap();
9. users.put("11","张浩太"); //将学生信息键值对存储到Map中
10. users.put("22","刘思诚");
11. users.put("33","王强文");
12. users.put("44","李国量");
13. users.put("55","王路路");
14. System.out.println("******** 学生列表 ********");
15. Iterator it=users.keySet().iterator();
16. while(it.hasNext())
17. {
18. //遍历 Map
19. Object key=it.next();
20. Object val=users.get(key);
21. System.out.println("学号："+key+"，姓名:"+val);
22. }
23. Scanner input=new Scanner(System.in);
24. System.out.println("请输入要删除的学号：");
25. int num=input.nextInt();
26. if(users.containsKey(String.valueOf(num)))
27. { //判断是否包含指定键
28. users.remove(String.valueOf(num)); //如果包含就删除
29. }
30. else
31. {
32. System.out.println("该学生不存在！");
33. }
34. System.out.println("******** 学生列表 ********");
35. it=users.keySet().iterator();
36. while(it.hasNext())
37. {
38. Object key=it.next();
39. Object val=users.get(key);
40. System.out.println("学号："+key+"，姓名："+val);
41. }
42. }
43. }
在该程序中，两次使用 while 循环遍历 HashMap 集合。当有学生毕业时，用户需要输入该学生的学号，根据学号使用 HashMap 类的 remove() 方法将对应的元素删除。程序运行结果如下所示。
******** 学生列表 ********
学号：44，姓名:李国量
学号：55，姓名:王路路
学号：22，姓名:刘思诚
学号：33，姓名:王强文
学号：11，姓名:张浩太
请输入要删除的学号：
22
******** 学生列表 ********
学号：44，姓名：李国量
学号：55，姓名：王路路
学号：33，姓名：王强文
学号：11，姓名：张浩太
******** 学生列表 ********
学号：44，姓名:李国量
学号：55，姓名:王路路
学号：22，姓名:刘思诚
学号：33，姓名:王强文
学号：11，姓名:张浩太
请输入要删除的学号：
44
******** 学生列表 ********
学号：55，姓名：王路路
学号：22，姓名：刘思诚
学号：33，姓名：王强文
学号：11，姓名：张浩太
注意：TreeMap 类的使用方法与 HashMap 类相同，唯一不同的是 TreeMap 类可以对键对象进行排序，这里不再赘述。
六、Java Set集合详解：HashSet类、TreeSet 类
Set 集合也实现了 Collection 接口，它主要有两个实现类：HashSet 类和 TreeSet类。Set 集合中的对象不按特定的方式排序，只是简单地把对象加入集合，集合中不能包含重复的对象，并且最多只允许包含一个 null 元素。
1.HashSet 类
HashSet 类是按照哈希算法来存储集合中的元素，使用哈希算法可以提高集合元素的存储速度，当向 Set 集合中添加一个元素时，HashSet 会调用该元素的 hashCode() 方法，获取其哈希码，然后根据这个哈希码计算出该元素在集合中的存储位置。
在 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 集合对象
例 1
编写一个 Java 程序，使用 HashSet 创建一个 Set 集合，并向该集合中添加 5 本图书名称。具体实现代码如下：
1. public static void main(String[] args)
2. {
3. HashSet<String> bookSet=new HashSet<String>(); //创建一个空的 Set 集合
4. String book1=new String("如何成为 Java 编程高手");
5. String book2=new String("Java 程序设计一百例");
6. String book3=new String("从零学 Java 语言");
7. String book4=new String("论 java 的快速开发");
8. bookSet.add(book1); //将 bookl 存储到 Set 集合中
9. bookSet.add(book2); //将 book2 存储到 Set 集合中
10. bookSet.add(book3); //将 book3 存储到 Set 集合中
11. bookSet.add(book4); //将 book4 存储到 Set 集合中
12. System.out.println("新进图书有：");
13. Iterater<String> it=bookSet.iterator();
14. while(it.hasNext())
15. {
16. System.out.println("《"+(String)it.next()+"》"); //输出 Set 集合中的元素
17. }
18. System.out.println("共采购 "+bookSet.size()+" 本图书！");
19. }
如上述代码，首先使用 HashSet 类的构造方法创建了一个 Set 集合，接着创建了 4 个 String 类型的对象，并将这些对象存储到 Set 集合中。使用 HashSet 类中的 iterator() 方法获取一个 Iterator 对象，并调用其 hasNext() 方法遍历集合元素，再将使用 next() 方法读取的元素强制转换为 String 类型。最后调用 HashSet 类中的 size() 方法获取集合元素个数。
运行该程序，输出的结果如下：
新进图书有：
《如何成为 Java 编程高手》
《从零学 Java 语言》
《Java 程序设计一百例》
《论 java 的快速开发》
共采购 4 本图书!
注意：在该示例中，如果再向 bookSet 集合中添加一个名称为“Java 程序设计一百例”的 String 对象，则输出的结果与上述执行结果相同。也就是说，如果向 Set 集合中添加两个相同的元素，则后添加的会覆盖前面添加的元素，即在 Set 集合中不会出现相同的元素。
2.TreeSet 类
TreeSet 类同时实现了 Set 接口和 SortedSet 接口。SortedSet 接口是 Set 接口的子接口，可以实现对集合进行自然排序，因此使用 TreeSet 类实现的 Set 接口默认情况下是自然排序的，这里的自然排序指的是升序排序。
TreeSet 只能对实现了 Comparable 接口的类对象进行排序，因为 Comparable 接口中有一个 compareTo(Object o) 方法用于比较两个对象的大小。例如 a.compareTo(b)，如果 a 和 b 相等，则该方法返回 0；如果 a 大于 b，则该方法返回大于 0 的值；如果 a 小于 b，则该方法返回小于 0 的值。
表 1 列举了 JDK 类库中实现 Comparable 接口的类，以及这些类对象的比较方式。
| 类 | 比较方式 |
|---|---|
| 包装类（BigDecimal、Biglnteger、 Byte、Double、 Float、Integer、Long 及 Short) |
按数字大小比较 |
| Character | 按字符的 Unicode 值的数字大小比较 |
| String | 按字符串中字符的 Unicode 值的数字大小比较 |
TreeSet 类除了实现 Collection 接口的所有方法之外，还提供了如表 2 所示的方法。
| 方法名称 | 说明 |
|---|---|
| E first() | 返回此集合中的第一个元素。其中，E 表示集合中元素的数据 类型 |
| E last() | 返回此集合中的最后一个元素 |
| E poolFirst() | 获取并移除此集合中的第一个元素 |
| E poolLast() | 获取并移除此集合中的最后一个元素 |
| SortedSet<E> subSet(E fromElement,E toElement) | 返回一个新的集合，新集合包含原集合中 fromElement 对象与 toElement 对象之间的所有对象。包含 fromElemen t对象，不包含 toElement 对象 |
| SortedSet<E> headSet<E toElement〉 | 返回一个新的集合，新集合包含原集合中 toElement 对象之前的所有对象。 不包含 toElement 对象 |
| SortedSet<E> tailSet(E fromElement) | 返回一个新的集合，新集合包含原集合中 fromElement 对象之后的所有对 象。包含 fromElement 对象 |
例 2
本次有 5 名学生参加考试，当老师录入每名学生的成绩后，程序将按照从低到高的排列顺序显示学生成绩。此外，老师可以查询本次考试是否有满分的学生存在，不及格的成绩有哪些，90 分以上成绩的学生有几名。
下面使用TreeSet类来创建Set集合，完成学生成绩查询功能。具体的代码如下：
1. import java.util.Iterator;
2. import java.util.Scanner;
3. import java.util.SortedSet;
4. import java.util.TreeSet;
5. public class Test08
6. {
7. public static void main(String[] args)
8. {
9. TreeSet<Double> scores=new TreeSet<Double>(); //创建 TreeSet 集合
10. Scanner input=new Scanner(System.in);
11. System.out.println("------------学生成绩管理系统-------------");
12. for(int i=0;i<5;i++)
13. {
14. System.out.println("第"+(j+1)+"个学生成绩：");
15. double score=input.nextDouble();
16. //将学生成绩转换为Double类型，添加到TreeSet集合中
17. scores.add(Double.valueOf(score));
18. }
19. Iterator<Double> it=scores.iterator(); //创建 Iterator 对象
20. System.out.println("学生成绩从低到高的排序为：");
21. while(it.hasNext())
22. {
23. System.out.print(it.next()+"\t");
24. }
25. System.out.println("\n请输入要查询的成绩：");
26. double searchScore=input.nextDouble();
27. if(scores.contains(searchScore))
28. {
29. System.out.println("成绩为： "+searchScore+" 的学生存在！");
30. }
31. else
32. {
33. System.out.println("成绩为： "+searchScore+" 的学生不存在！");
34. }
35. //查询不及格的学生成绩
36. SortedSet<Double> score1=scores.headSet(60.0);
37. System.out.println("\n不及格的成绩有：");
38. for(int i=0;i<score1.toArray().length;i++)
39. {
40. System.out.print(score1.toArray()[i]+"\t");
41. }
42. //查询90分以上的学生成绩
43. SortedSet<Double> score2=scores.tailSet(90.0);
44. System.out.println("\n90 分以上的成绩有：");
45. for(int i=0;i<score2.toArray().length;i++)
46. {
47. System.out.print(score2.toArray()[i]+"\t");
48. }
49. }
50. }
如上述代码，首先创建一个 TreeSet 集合对象 scores，并向该集合中添加 5 个 Double 对象。接着使用 while 循环遍历 scores 集合对象，输出该对象中的元素，然后调用 TreeSet 类中的 contains() 方法获取该集合中是否存在指定的元素。最后分别调用 TreeSet 类中的 headSet() 方法和 tailSet() 方法获取不及格的成绩和 90 分以上的成绩。
运行该程序，执行结果如下所示。
------------学生成绩管理系统-------------
第1个学生成绩：
53
第2个学生成绩：
48
第3个学生成绩：
85
第4个学生成绩：
98
第5个学生成绩：
68
学生成绩从低到高的排序为：
48.0 53.0 68.0 85.0 98.0
请输入要查询的成绩：
90
成绩为： 90.0 的学生不存在！
不及格的成绩有：
48.0 53.0
90 分以上的成绩有：
98.0
注意：在使用自然排序时只能向 TreeSet 集合中添加相同数据类型的对象，否则会抛出 ClassCastException 异常。如果向 TreeSet 集合中添加了一个 Double 类型的对象，则后面只能添加 Double 对象，不能再添加其他类型的对象，例如 String 对象等。
七、Java枚举（enum）详解：Java声明枚举类型、枚举（enum）类、EnumMap 与 EnumSet
枚举是一个被命名的整型常数的集合，用于声明一组带标识符的常数。枚举在曰常生活中很常见，例如一个人的性别只能是“男”或者“女”，一周的星期只能是 7 天中的一个等。类似这种当一个变量有几种固定可能的取值时，就可以将它定义为枚举类型。
在 JDK 1.5 之前没有枚举类型，那时候一般用接口常量来替代。而使用 Java 枚举类型 enum 可以更贴近地表示这种常量。
1.声明枚举
声明枚举时必须使用 enum 关键字，然后定义枚举的名称、可访问性、基础类型和成员等。枚举声明的语法如下：
enum-modifiers enum enumname:enum-base
{
enum-body,
}
其中，enum-modifiers 表示枚举的修饰符主要包括 public、private 和 internal；enumname 表示声明的枚举名称；enum-base 表示基础类型；enum-body 表示枚举的成员，它是枚举类型的命名常数。
任意两个枚举成员不能具有相同的名称，且它的常数值必须在该枚举的基础类型的范围之内，多个枚举成员之间使用逗号分隔。
提示：如果没有显式地声明基础类型的枚举，那么意味着它所对应的基础类型是 int。
例 1
下面代码定义了一个表示性别的枚举类型 SexEnum 和一个表示颜色的枚举类型 Color。
1. public enum SexEnum
2. {
3. male,female;
4. }
5. public enum Color
6. {
7. RED,BLUE,GREEN,BLACK;
8. }
之后便可以通过枚举类型名直接引用常量，如 SexEnum.male、Color.RED。
使用枚举还可以使 switch 语句的可读性更强，例如以下示例代码：
1. enum Signal
2. {
3. //定义一个枚举类型
4. GREEN,YELLOW,RED
5. }
6. public class TrafficLight
7. {
8. Signal color=Signal.RED;
9. public void change()
10. {
11. switch(color)
12. {
13. case RED:
14. color=Signal.GREEN;
15. break;
16. case YELLOW:
17. color=Signal.RED;
18. break;
19. case GREEN:
20. color=Signal.YELLOW;
21. break;
22. }
23. }
24. }
2.枚举类
Java 中的每一个枚举都继承自 java.lang.Enum 类。当定义一个枚举类型时，每一个枚举类型成员都可以看作是 Enum 类的实例，这些枚举成员默认都被 final、public, static 修饰，当使用枚举类型成员时，直接使用枚举名称调用成员即可。
所有枚举实例都可以调用 Enum 类的方法，常用方法如表 1 所示。
| 方法名称 | 描述 |
| values() | 以数组形式返回枚举类型的所有成员 |
| valueOf() | 将普通字符串转换为枚举实例 |
| compareTo() | 比较两个枚举成员在定义时的顺序 |
| ordinal() | 获取枚举成员的索引位置 |
例 2
通过调用枚举类型实例的 values() 方法可以将枚举的所有成员以数组形式返回，也可以通过该方法获取枚举类型的成员。
下面的示例创建一个包含 3 个成员的枚举类型 Signal，然后调用 values() 方法输出这些成员。
1. enum Signal
2. {
3. //定义一个枚举类型
4. GREEN,YELLOW,RED;
5. }
6. public static void main(String[] args)
7. {
8. for(int i=0;i<Signal.values().length;i++)
9. {
10. System.out.println("枚举成员："+Signal.values()[i]);
11. }
12. }
输出结果如下：
枚举成员：GREEN
枚举成员：YELLOW
枚举成员：RED
例 3
创建一个示例，调用valueOf() 方法获取枚举的一个成员，再调用 compareTo() 方法进行比较，并输出结果。具体实现代码如下：
1. public class TestEnum
2. {
3. public enum Sex
4. {
5. //定义一个枚举
6. male,female;
7. }
8. public static void main(String[] args)
9. {
10. compare(Sex.valueOf("male")); //比较
11. }
12. public static void compare(Sex s)
13. {
14. for(int i=0;i<Sex.values().length;i++)
15. {
16. System.out.println(s+"与"+Sex.values()[i]+"的比较结果是："+s.compareTo(Sex.values()[i]));
17. }
18. }
19. }
上述代码中使用 Sex.valueOf("male") 取出枚举成员 male 对应的值，再将该值与其他枚举成员进行比较。最终输出结果如下：
male与male的比较结果是：0
male与female的比较结果是：-1
例 4
通过调用枚举类型实例的 ordinal() 方法可以获取一个成员在枚举中的索引位置。下面的示例创建一个包含 3 个成员的枚举类型 Signal，然后调用 ordinal() 方法输出成员及对应索引位置。
具体实现代码如下：
1. public class TestEnum1
2. {
3. enum Signal
4. {
5. //定义一个枚举类型
6. GREEN,YELLOW,RED;
7. }
8. public static void main(String[] args)
9. {
10. for(int i=0;i<Signal.values().length;i++)
11. {
12. System.out.println("索引"+Signal.values()[i].ordinal()+"，值："+Signal.values()[i]);
13. }
14. }
15. }
输出结果如下：
索引0，值：GREEN
索引1，值：YELLOW
索引2，值：RED
3.为枚举添加方法
Java 为枚举类型提供了一些内置的方法，同时枚举常量也可以有自己的方法。此时要注意必须在枚举实例的最后一个成员后添加分号，而且必须先定义枚举实例。
例 5
下面的代码创建了一个枚举类型 WeekDay，而且在该类型中添加了自定义的方法。
1. enum WeekDay
2. {
3. Mon("Monday"),Tue("Tuesday"),Wed("Wednesday"),Thu("Thursday"),Fri("Friday"),Sat("Saturday"),Sun("Sunday");
4. //以上是枚举的成员，必须先定义，而且使用分号结束
5. private final String day;
6. private WeekDay(String day)
7. {
8. this.day=day;
9. }
10. public static void printDay(int i)
11. {
12. switch(i)
13. {
14. case 1:
15. System.out.println(WeekDay.Mon);
16. break;
17. case 2:
18. System.out.println(WeekDay.Tue);
19. break;
20. case 3:
21. System.out.println(WeekDay.Wed);
22. break;
23. case 4:
24. System.out.println(WeekDay.Thu);
25. break;
26. case 5:
27. System.out.println(WeekDay.Fri);
28. break;
29. case 6:
30. System.out.println(WeekDay.Sat);
31. break;
32. case 7:
33. System.out.println(WeekDay.Sun);
34. break;
35. default:
36. System.out.println("wrong number!");
37. }
38. }
39. public String getDay()
40. {
41. return day;
42. }
43. }
上面代码创建了 WeekDay 枚举类型，下面遍历该枚举中的所有成员，并调用 printDay() 方法。示例代码如下：
1. public static void main(String[] args)
2. {
3. for(WeekDay day:WeekDay.values())
4. {
5. System.out.println(day+"====>"+day.getDay());
6. }
7. WeekDay.printDay(5);
8. }
输出结果如下：
Mon====>Monday
Tue====>Tuesday
Wed====>Wednesday
Thu====>Thursday
Fri====>Friday
Sat====>Saturday
Sun====>Sunday
Fri
Java 中的 enum 还可以跟 Class 类一样覆盖基类的方法。下面示例代码创建的 Color 枚举类型覆盖了 toString() 方法。
1. public class Test
2. {
3. public enum Color
4. {
5. RED("红色",1),GREEN("绿色",2),WHITE("白色",3),YELLOW("黄色",4);
6. //成员变量
7. private String name;
8. private int index;
9. //构造方法
10. private Color(String name,int index)
11. {
12. this.name=name;
13. this.index=index;
14. }
15. //覆盖方法
16. @Override
17. public String toString()
18. {
19. return this.index+"-"+this.name;
20. }
21. }
22. public static void main(String[] args)
23. {
24. System.out.println(Color.RED.toString()); //输出：1-红色
25. }
26. }
4.EnumMap 与 EnumSet
为了更好地支持枚举类型，java.util 中添加了两个新类：EnumMap 和 EnumSet。使用它们可以更高效地操作枚举类型。
EnumMap 类
EnumMap 是专门为枚举类型量身定做的 Map 实现。虽然使用其他的 Map（如 HashMap）实现也能完成枚举类型实例到值的映射，但是使用 EnumMap 会更加高效。
HashMap 只能接收同一枚举类型的实例作为键值，并且由于枚举类型实例的数量相对固定并且有限，所以 EnumMap 使用数组来存放与枚举类型对应的值，使得 EnumMap 的效率非常高。
例 6
下面是使用 EnumMap 的一个代码示例。枚举类型 DataBaseType 里存放了现在支持的所有数据库类型。针对不同的数据库，一些数据库相关的方法需要返回不一样的值，例如示例中 getURL() 方法。
1. //定义数据库类型枚举
2. public enum DataBaseType
3. {
4. MYSQUORACLE,DB2,SQLSERVER
5. }
6. //某类中定义的获取数据库URL的方法以及EnumMap的声明
7. private EnumMap<DataBaseType,String>urls=new EnumMap<DataBaseType,String>(DataBaseType.class);
8. public DataBaseInfo()
9. {
10. urls.put(DataBaseType.DB2,"jdbc:db2://localhost:5000/sample");
11. urls.put(DataBaseType.MYSQL,"jdbc:mysql://localhost/mydb");
12. urls.put(DataBaseType.ORACLE,"jdbc:oracle:thin:@localhost:1521:sample");
13. urls.put(DataBaseType.SQLSERVER,"jdbc:microsoft:sqlserver://sql:1433;Database=mydb");
14. }
15. //根据不同的数据库类型，返回对应的URL
16. //@param type DataBaseType 枚举类新实例
17. //@return
18. public String getURL(DataBaseType type)
19. {
20. return this.urls.get(type);
21. }
在实际使用中，EnumMap 对象 urls 往往是由外部负责整个应用初始化的代码来填充的。这里为了演示方便，类自己做了内容填充。
从本例中可以看出，使用 EnumMap 可以很方便地为枚举类型在不同的环境中绑定到不同的值上。本例子中 getURL 绑定到 URL 上，在其他的代码中可能又被绑定到数据库驱动上去。
EnumSet 类
EnumSet 是枚举类型的高性能 Set 实现，它要求放入它的枚举常量必须属于同一枚举类型。EnumSet 提供了许多工厂方法以便于初始化，如表 2 所示。
| 方法名称 | 描述 |
| 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. {
3. doSomeThing(op);
4. }
八、Java泛型详解：Java泛型集合、泛型类、泛型方法、泛型的使用
在 Java 1.5 之前没有泛型，通常需要使用强制类型转换的方式将一种数据类型转换为另一种数据类型，这种转换要求开发者对实际参数的类型具有可预知性。对于强制类型转换错误的情况，编译器可能不会提示错误，但是在运行时会出现异常，这是一个安全隐患。
为了解决这一隐患，从 Java 1.5 开始提供了泛型。泛型可以在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高了代码的重用率。本节将详细介绍 Java 中泛型的使用。
1.泛型集合
泛型本质上是提供类型的“类型参数”，也就是参数化类型。我们可以为类、接口或方法指定一个类型参数，通过这个参数限制操作的数据类型，从而保证类型转换的绝对安全。
例 1
下面将结合泛型与集合编写一个案例实现图书信息输出。
(1) 首先需要创建一个表示图书的实体类 Book，其中包括的图书信息有图书编号、图书名称和价格。Book 类的具体代码如下：
1. public class Book
2. {
3. private int Id; //图书编号
4. private String Name; //图书名称
5. private int Price; //图书价格
6. public Book(int id,String name,int price)
7. { //构造方法
8. this.Id=id;
9. this.Name=name;
10. this.Price=price;
11. }
12. public String toString()
13. { //重写 toString()方法
14. return this.Id+", "+this.Name+"，"+this.Price;
15. }
16. }
(2) 使用 Book 作为类型创建 Map 和 List 两个泛型集合，然后向集合中添加图书元素，最后输出集合中的内容。具体代码如下：
1. import java.util.ArrayList;
2. import java.util.HashMap;
3. import java.util.List;
4. import java.util.Map;
5. public class Test14
6. {
7. public static void main(String[] args)
8. {
9. //创建3个Book对象
10. Book book1=new Book(1,"唐诗三百首",8);
11. Book book2=new Book(2,"小星星",12);
12. Book book3=new Book(3,"成语大全",22);
13. Map<Integer,Book> books=new HashMap<Integer,Book>(); //定义泛型 Map 集合
14. books.put(1001,book1); //将第一个 Book 对象存储到 Map 中
15. books.put(1002,book2); //将第二个 Book 对象存储到 Map 中
16. books.put(1003,book3); //将第三个 Book 对象存储到 Map 中
17. System.out.println("泛型Map存储的图书信息如下：");
18. for(Integer id:books.keySet())
19. {
20. //遍历键
21. System.out.print(id+"——");
22. System.out.println(books.get(id)); //不需要类型转换
23. }
24. List<Book> bookList=new ArrayList<Book>(); //定义泛型的 List 集合
25. bookList.add(book1);
26. bookList.add(book2);
27. bookList.add(book3);
28. System.out.println("泛型List存储的图书信息如下：");
29. for(int i=0;i<bookList.size();i++)
30. {
31. System.out.println(bookList.get(i)); //这里不需要类型转换
32. }
33. }
34. }
在该示例中，代码“Map<Integer,Book> books=new HashMap<Integer,Book>();”创建了一个键类型为 Integer、值类型为 Book 的泛型集合，即指明了该 Map 集合中存放的键必须是 Integer 类型、值必须为 Book 类型，否则编译出错。在获取 Map 集合中的元素时，不需要将"books.get(id);"获取的值强制转换为 Book 类型，程序会隐式转换。在创建 List 集合时，同样使用了泛型，因此在获取集合中的元素时也不需要将“bookList.get(i)”代码强制转换为 Book 类型，程序会隐式转换。
执行结果如下：
泛型Map存储的图书信息如下：
1001——1, 唐诗三百首，8
1003——3, 成语大全，22
1002——2, 小星星，12
泛型List存储的图书信息如下：
1, 唐诗三百首，8
2, 小星星，12
3, 成语大全，22
2.泛型类
除了可以定义泛型集合之外，还可以直接限定泛型类的类型参数。语法格式如下：
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 与类声明中的 datajype1 表示的是同一种数据类型。
例 2
在实例化泛型类时，需要指明泛型类中的类型参数，并赋予泛型类属性相应类型的值。例如，下面的示例代码创建了一个表示学生的泛型类，该类中包括 3 个属性，分别是姓名、年龄和性别。
1. public class Stu<N,A,S>
2. {
3. private N name; //姓名
4. private A age; //年龄
5. private S sex; //性别
6. //创建类的构造函数
7. public Stu(N name,A age,S sex)
8. {
9. this.name=name;
10. this.age=age;
11. this.sex=sex;
12. }
13. //下面是上面3个属性的setter/getter方法
14. public N getName()
15. {
16. return name;
17. }
18. public void setName(N name)
19. {
20. this.name=name;
21. }
22. public A getAge()
23. {
24. return age;
25. }
26. public void setAge(A age)
27. {
28. this.age = age;
29. }
30. public S getSex()
31. {
32. return sex;
33. }
34. public void setSex(S sex)
35. {
36. this.sex=sex;
37. }
38. }
接着创建测试类。在测试类中调用 Stu 类的构造方法实例化 Stu 对象，并给该类中的 3 个属性赋予初始值，最终需要输出学生信息。测试类的代码实现如下：
1. public class Test14
2. {
3. public static void main(String[] args)
4. {
5. Stu<String,Integer,Character> stu=new Stu<String,Integer,Character>("张晓玲",28,'女');
6. String name=stu.getName();
7. Integer age=stu.getAge();
8. Character sex=stu.getSex();
9. System.out.println("学生信息如下：");
10. System.out.println("学生姓名："+name+"，年龄："+age+"，性别："+sex);
11. }
12. }
该程序的运行结果如下：
学生信息如下：
学生姓名：张晓玲，年龄：28，性别：女
在该程序的 Stu 类中，定义了 3 个类型参数，分别使用 N、A 和 S 来代替，同时实现了这 3 个属性的 setter/getter 方法。在主类中，调用 Stu 类的构造函数创建了 Stu 类的对象，同时指定 3 个类型参数，分别为 String、Integer 和 Character。在获取学生姓名、年龄和性别时，不需要类型转换，程序隐式地将 Object 类型的数据转换为相应的数据类型。
3.泛型方法
到目前为止，我们所使用的泛型都是应用于整个类上。泛型同样可以在类中包含参数化的方法，而方法所在的类可以是泛型类，也可以不是泛型类。也就是说，是否拥有泛型方法，与其所在的类是不是泛型没有关系。
泛型方法使得该方法能够独立于类而产生变化。如果使用泛型方法可以取代类泛型化，那么就应该只使用泛型方法。另外，对一个 static 的方法而言，无法访问泛型类的类型参数。因此，如果 static 方法需要使用泛型能力，就必须使其成为泛型方法。
定义泛型方法的语法格式如下：
[访问权限修饰符][static][final]<类型参数列表>返回值类型方法名([形式参数列表])例如：
1. public static List<T> find(Class<T>class,int userId){}
一般来说编写 Java 泛型方法，其返回值类型至少有一个参数类型应该是泛型，而且类型应该是一致的，如果只有返回值类型或参数类型之一使用了泛型，那么这个泛型方法的使用就被限制了。下面就来定义一个泛型方法，具体介绍泛型方法的创建和使用。
例 3
使用泛型方法打印图书信息。定义泛型方法，参数类型使用“T”来代替。在方法的主体中打印出图书信息。代码的实现如下：
1. public class Test16
2. {
3. public static<T> void List(T book)
4. { //定义泛型方法
5. if(book!=null)
6. {
7. System.out.println(book);
8. }
9. }
10. public static void main(String[] args)
11. {
12. Book stu=new Book(1,"细学 Java 编程",28);
13. List(stu); //调用泛型方法
14. }
15. }
该程序中的 Book 类为前面示例中使用到的 Book 类。在该程序中定义了一个名称为 List 的方法，该方法的返回值类型为 void，类型参数使用“T”来代替。在调用该泛型方法时，将一个 Book 对象作为参数传递到该方法中，相当于指明了该泛型方法的参数类型为 Book。
该程序的运行结果如下：
1, 细学 Java 编程，284.泛型的高级用法
泛型的用法非常灵活，除在集合、类和方法中使用外，本节将从三个方面介绍泛型的高级用法，包括限制泛型可用类型、使用类型通配符、继承泛型类和实现泛型接口。
1. 限制泛型可用类型
在 Java 中默认可以使用任何类型来实例化一个泛型类对象。当然也可以对泛型类实例的类型进行限制，语法格式如下：
class 类名称<T extends anyClass>其中，anyClass 指某个接口或类。使用泛型限制后，泛型类的类型必须实现或继承 anyClass 这个接口或类。无论 anyClass 是接口还是类，在进行泛型限制时都必须使用 extends 关键字。
例如，在下面的示例代码中创建了一个 ListClass 类，并对该类的类型限制为只能是实现 List 接口的类。
1. //限制ListClass的泛型类型必须实现List接口
2. public class ListClass<T extends List>
3. {
4. public static void main(String[] args)
5. {
6. //实例化使用ArrayList的泛型类ListClass，正确
7. ListClass<ArrayList> lc1=new ListClass<ArrayList>();
8. //实例化使用LinkedList的泛型类LlstClass，正确
9. ListClass<LinkedList> lc2=new ListClass<LinkedList>();
10. //实例化使用HashMap的泛型类ListClass，错误，因为HasMap没有实现List接口
11. //ListClass<HashMap> lc3=new ListClass<HashMap>();
12. }
13. }
在上述代码中，定义 ListClass 类时设置泛型类型必须实现 List 接口。例如，ArrayList 和 LinkedList 都实现了 List 接口，所以可以实例化 ListClass 类。而 HashMap 没有实现 List 接口，所以在实例化 ListClass 类时会报错。
当没有使用 extends 关键字限制泛型类型时，其实是默认使用 Object 类作为泛型类型。因此，Object 类下的所有子类都可以实例化泛型类对象，如图 1 所示的这两种情况。
2. 使用类型通配符
Java 中的泛型还支持使用类型通配符，它的作用是在创建一个泛型类对象时限制这个泛型类的类型必须实现或继承某个接口或类。
使用泛型类型通配符的语法格式如下：
泛型类名称<? extends List>a=null;其中，“<? extends List>”作为一个整体表示类型未知，当需要使用泛型对象时，可以单独实例化。
例如，下面的示例代码演示了类型通配符的使用。
1. A<? extends List>a=null;
2. a=new A<ArrayList> (); //正确
3. b=new A<LinkedList> (); //正确
4. c=new A<HashMap> (); //错误
在上述代码中，同样由于 HashMap 类没有实现 List 接口，所以在编译时会报错。
3. 继承泛型类和实现泛型接口
定义为泛型的类和接口也可以被继承和实现。例如下面的示例代码演示了如何继承泛型类。
1. public class FatherClass<T1>{}
2. public class SonClass<T1,T2,T3> extents FatherClass<T1>{}
如果要在 SonClass 类继承 FatherClass 类时保留父类的泛型类型，需要在继承时指定，否则直接使用 extends FatherClass 语句进行继承操作，此时 T1、T2 和 T3 都会自动变为 Object，所以一般情况下都将父类的泛型类型保留。
下面的示例代码演示了如何在泛型中实现接口。
1. interface interface1<T1>{}
2. interface SubClass<T1,T2,T3> implements
3. Interface1<T2>{}
总结
