【Java基础】Java集合、泛型和枚举
时间：2022-12-29 10:00:00
目录
一、Java集合概念
1.集合中的接口
2.接口实现类
二、Java Collection接口
三、Java Collection类：sort()升级排序，reverse()降序排序，copy()复制、fill()填充
1.正向排序
2.逆向排序
3.复制
4.填充
四、Java List集合：ArrayList类、LinkList类、ArrayList类和LinkList类的区别
1.ArrayList 类
2.LinkList类
五、Java Map集合详解
六、Java Set集合详解：HashSet类、TreeSet 类
1.HashSet 类
2.TreeSet 类
七、Java枚举（enum）详解：Java声明枚举的类型和类型（enum）类、EnumMap 与 EnumSet
1.声明枚举
2.枚举类
3.添加枚举的方法
4.EnumMap 与 EnumSet
八、Java泛型详解：Java泛型集合、泛型类、泛型方法、泛型使用
1.泛型集合
2.泛型类
3.泛型方法
4.泛型高级用法
总结
一、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 |
返回一个 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如上述代码，循环录入 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 dest,List 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如上述代码，首先创建了两个 List 对象 srcList 和 destList，并向 destList 集合中添加了 5 个元素，向 srcList 集合中添加了 3 个元素，然后调用 Collections 类中 copy() 方法将 srcList 集合中的全部元素复制到 destList 集合中。由于 destList 集合中含有 5 个元素，故最后两个元素不会被覆盖。
运行该程序，具体的执行结果如下所示。
原有商品如下：
苏打水
木糖醇
方便面
火腿肠
冰红茶
输入替换的商品名称：
第 1 个商品：
燕麦片
第 2 个商品：
八宝粥
第 3 个商品：
软面包
当前商品有：
燕麦片 八宝粥 软面包 火腿肠 冰红茶
4.填充
Collections 类的 fill() 静态方法可以对指定集合的所有元素进行填充操作。fill() 方法的定义如下:
void fill(List 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如上述代码，首先循环录入 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(Collectionc)：构造一个包含指定 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 |
返回一个新的集合，新集合中包含 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该示例中的 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 products=new LinkedList(); //创建集合对象
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 如上述代码，首先创建了 5 个 String 对象，分别为 p1、p2、p3、p4 和 p5。同时将 pl、 p2、p3 和 p4 对象使用 add() 方法添加到 LinkedList 集合中，使用 addLast() 方法将 p5 对象添加到 LinkedList 集合中。分别调用 LinkedList 类中的 getFirst() 方法和 getLast()方法获取第一个和最后一个商品名称。最后使用 removeLast() 方法将最后一个商品信息删除，并将剩余商品信息打印出来。
LinkedList
运行程序，执行结果如下：
*************** 商品信息 ***************
目前商品有：
六角螺母 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(Collectionc)：构造一个包含指定 Collection 集合元素的新 Set 集合。其中，“< >”中的 extends 表示 HashSet 的父类，即指明该 Set 集合中存放的集合元素类型。c 表示其中的元素将被存放在此 Set 集合中。
下面的代码演示了创建两种不同形式的 HashSet 对象。
1. HashSet hs=new HashSet(); //调用无参的构造函数创建HashSet对象
2. HashSet hss=new HashSet(); //创建泛型的 HashSet 集合对象
例 1
编写一个 Java 程序，使用 HashSet 创建一个 Set 集合，并向该集合中添加 5 本图书名称。具体实现代码如下：
1. public static void main(String[] args)
2. {
3. HashSet bookSet=new HashSet(); //创建一个空的 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 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 集合中添加两个相同的元素，则后添加的会覆盖前面添加的元素，即在
