1. 集合框架介绍
我 们知道，计算机的优势在于处理大量的数据，在编程开发中，为处理大量的数据，必须具备相应的存储结构，数组可以用来存储并处理大量类型相同的数 据，但是会发现数组在应用中的限制：数组长度一旦确定，就无法更改；除非采用建立新数组，再将原数组内容拷贝过来；数组中只能存放指 定类型的数据，操作不方便。在实际开发中，为了操作方便，JDK中提供了List集合。
List集合与数组的用途非常相似，都是用来存储大量数据的，不同处有两点：
1. 数组长度在使用前必须确定，一旦确定不能改变。而List集合长度可变，无需定义。
2. 数组中必须存放同一类型的数据，List集合中可以存放不同类型的数据。
List集合是Java集合框架中的一种，另外两种集合Set和Map会在下面介绍。List集合在JDK中被封装称为接口，针对List接口，有若干种实现，常用的有三个子类，即ArrayList、Vector和LinkedList。这三个类的功能与用法相同，但内部实现方式不同。下面以ArrayList为例介绍集合的常用操作，Vector和LinkedList的使用方法与ArrayList类似。
数组与List集合的常规操作类似，下面通过代码对比两者的用法：
代码演示：数组的基本操作
|
public class ArrayDemo { public static void main(String[] args) { String[] array = new String[3]; for (int i = 0; i < 3; i++) { array[i] = "Hello"; } String a = array[0]; } } |
代码演示：List集合的基本操作
|
import java.util.ArrayList; ① public class ListDemo { public static void main(String[] args) { ArrayList list = new ArrayList(); ② for (int i = 0; i < 3; i++) { list.add("Hello"); ③ } String a = (String)list.get(0); ④ } } |
代码解析：
① 集合框架在java.util包中，使用前必须使用import语句引入对应的类。
② List集合的定义时不需要指定大小，也不用指定集合中保存的数据类型。
③ 向List集合中添加数据时不需要制定下标，List集合会自动生成下标。
④ 获取List集合的元素时使用get方法并传入下标，然后强制类型转换为实际类型。
代码演示：使用集合记录学员姓名
|
public static void main(String[] args) { System.out.println("请输入班级学员姓名，输入OVER结束"); java.util.Scanner scanner = new java.util.Scanner(System.in); ArrayList list = new ArrayList(); do { String name = scanner.next(); if (name.equalsIgnoreCase("OVER")) break; list.add(name); } while (true); System.out.println(list); ① } |
代码解析：
① List集合重写了toString方法，可以将集合中的元素依次输出。
2. List集合的常用方法
下表列出了List集合的常用方法：
|
返回类型 |
方法名称 |
说明 |
|
boolean |
add(Object obj) |
加入元素，返回是否添加成功 |
|
boolean |
clear() |
清除集合中的元素 |
|
boolean |
contains(Object obj) |
查找集合中是否存在传入的元素 |
|
Object |
get(int index) |
获取指定位置的元素 |
|
boolean |
isEmpty() |
判断集合是否为空 |
|
Object |
remove(int index) |
删除制定位置的元素，并返回该元素 |
|
int |
size() |
获取集合大小 |
|
Object[] |
toArray() |
将集合转换成一个数组 |
表： List集合的常用方法
下面通过实例演示各个方法的用途：
代码演示：List集合的常用方法
|
import java.util.ArrayList; public class Demo { public static java.util.Scanner scanner = new java.util.Scanner(System.in); public static void main(String[] args) { ArrayList listA = new ArrayList(); ArrayList listB = new ArrayList(); System.out.println("请输入A班学员姓名，输入OVER结束"); inputName(listA); System.out.println("请输入B班学员姓名，输入OVER结束"); inputName(listB); //合并集合listA与listB listA.addAll(listB); System.out.println("请输入要查找的学员姓名"); String name = scanner.next(); int pos = listA.indexOf(name); if (pos==-1) { System.out.println("没有找到"); } else { System.out.println("找到了，位置是:" + pos); } System.out.println("请输入要删除的学员姓名"); String delName = scanner.next(); if (listA.remove(delName)) { System.out.println("删除成功！"); } else { System.out.println("没有该学员"); } } public static void inputName(ArrayList list) { do { String name = scanner.next(); if (name.equalsIgnoreCase("OVER")) break; list.add(name); } while (true); } } |
3. 使用List集合保存对象
使用List集合保存对象时，主要注意以下几点：
1. 集合中保存的是对象的引用，观察以下代码：
代码演示：使用集合保存对象
|
import java.util.ArrayList; class Student { String name; int age; public Student(String name, int age) { this.name = name; this.age = age; } public String toString() { return name + "/" + age; } } public class Demo { public static void main(String[] args) { ArrayList list = new ArrayList(); Student stu = new Student("Tom" , 10); for (int i = 0; i < 3; i++) { stu.age = 10 + i; list.add(stu); } System.out.println(list); } } |
上面代码的原意是在集合中保存三个Student对象，age分别为10、11、12，但实际输出的age值均为12。这是因为list集合中保存的是stu对象的引用，而在循环中stu的引用并没有变化，所以循环结束后集合中的三个元素都指向stu对象，age的值自然也是最后的12。将代码“Student stu = new Student("Tom" , 10);”放入循环内可以解决这一问题。
2. 使用remove、contains、indexOf等方法时，应该重写类的equals方法，观察以下代码：
代码演示：未重写equals方法的代码
|
//省略了Student类的定义 public class Demo { public static void main(String[] args) { ArrayList list = new ArrayList(); list.add(new Student("Tom" , 11)); list.add(new Student("Jerry" , 22)); list.add(new Student("Alice" , 33)); System.out.println(list.contains(new Student("Tom" , 11))); System.out.println(list.indexOf(new Student("Jerry" , 22))); System.out.println(list.remove(new Student("Alice" , 33))?"成功":"无此项"); } } |
在上例中，我们希望判断学员Tom是否存在，查找学员Jerry，删除学员Alice，但是输出的结果却是不存在，找不到，删不掉。这是因为List集合会调用元素的equals方法来判断对象是否相等，而Student类没有重写equals方法，默认是按引用地址比较，而每个学员对象的地址又不相同，所以出现这个现象。通过给Student类添加equals方法可以解决这个问题：
代码演示：重写equals方法后的Student类
|
class Student { String name; int age; public Student(String name, int age) { this.name = name; this.age = age; } public boolean equals(Object obj) { if (obj == null) return false; if (!(obj instanceof Student)) return false; Student stu = (Student) obj; return stu.name.equals(this.name) && stu.age == this.age; } } |
4. 三种List集合的比较
我们说过，ArrayList、Vector与LinkedList的使用方法相同，内部实现方式不同。而内部实现方式的不同又决定了三种集合的适用范围，了解三种集合的内部实现，才能正确的选择使用类型。
1.ArrayList与Vector比较
ArrayList与Vector的内部实现类似，Vector设计为线程安全，ArrayList设计为非线程安全。为了保证线程安全，Vector在性能方面稍逊于ArrayList，目前我们编写的都是单线程应用程序，应选择使用ArrayList。
2.ArrayList与LinkedList
ArrayList与LinkedList均设计为非线程安全，ArrayList内部采用数组实现（与Vector相同），LinkedList内部采用链表结构实现。
ArrayList采用数组保存元素，意味着当大量添加元素，数组空间不足时，依然需要通过新建数组、内存复制的方式来增加容量，效率较低；而当进行对数组进行插入、删除操作时，又会进行循环移位操作，效率也较低；只有进行按下标查询时（get方法），使用数组效率很高。
LinkedList采用链表保存元素，在添加元素时只需要进行一次简单的内存分配即可，效率较高；进行插入、删除操作时，只需对链表中相邻的元素进行修改即可，效率也很高；但进行按下标查询时，需要对链表进行遍历，效率较低。下图演示了链表结构的特性：
图： 链表结构，每个元素引用后面的元素
图： 向链表中插入元素，只需修改两处引用
图： 删除链表中的元素，也只需要修改两处引用
可以总结出ArrayList在进行数据的新增、插入、删除时效率较低，按下标对数据进行查找时效率较高；LinkedList正好相反。一般来说ArrayList保存经常进行查询操作的集合，LinkedList适用于保存经常进行修改操作的集合。
5. 章节概述
1. List集合与数组的区别。
2. List集合实际上包含了3个常用的集合类，即ArrayList、Vector和LinkedList。
3. List集合的常用操作。
4. ArrayList采用数组保存元素，意味着当大量添加元素，数组空间不足时，依然需要通过新建数组、内存复制的方式来增加容量，效率较低；而当进行对数组进行插入、删除操作时，又会进行循环移位操作，效率也较低；只有进行按下标查询时（get方法），使用数组效率很高。
5. ArrayList与Vector的内部实现类似，Vector设计为线程安全，ArrayList设计为非线程安全。为了保证线程安全，Vector在性能方面稍逊于ArrayList，目前我们编写的都是单线程应用程序，应选择使用ArrayList。
6. ArrayList与LinkedList均设计为非线程安全，ArrayList内部采用数组实现（与Vector相同），LinkedList内部采用链表结构实现。
7. LinkedList采用链表保存元素，在添加元素时只需要进行一次简单的内存分配即可，效率较高；进行插入、删除操作时，只需对链表中相邻的元素进行修改即可，效率也很高；但进行按下标查询时，需要对链表进行遍历，效率较低。
1. Map集合
在上面讲的List集合中，可用通过List集合提供的各种方法来对其中的元素进行操作，从而可以方便用户操作，但是如果要从List集合中获取一个特定的对象，操作是比较繁琐的。
在类Person中有cardId和name两个属性，分别代表编号和姓名，创建两个Person对象并存储到ArrayList集合中 ，如果要从集合中获取指定的对象，则必须要通过迭代整个集合来获得，如下所示：
代码演示：Person类
|
public class Person { String cardId; String name; public Person(String cardId, String name) { this.cardId = cardId; this.name = name; } } |
代码演示：从ArrayList中获取特定的对象
|
public class ArrayListTest { public static void main(String[] args) { Person personA = new Person("001", "Tom"); Person personB = new Person("002", "Jack"); ArrayList list = new ArrayList(); list.add(personA); list.add(personB); for (int i = 0; i < list.size(); i++) { Person person = (Person) list.get(i); if (person.cardId.equals("002")) { System.out.println(person.name); } } } } |
从上面的示例中，我们看到从list集合中获取一个对象的繁琐，有没有简单的方法呢？在JDK中专门提供了Map集合来存储上面这种一对一映射关系的对象。
Map集合用于保存具有映射关系的数据，即以键值对（key->value）的方式来存储数据。因此在Map集合内部有两个集合，一个集合用于保存Map中的key（键），一个集合用于保存Map中的value（值），其中key和value可以是任意数据类型数据。
图： Map集合
Map集合中的常用类有Hashtable和HashMap，两个类的功能和用法相似，下面以HashMap为例介绍Map集合的用法。
代码演示：Map集合使用
|
public class MapTest { public static void main(String[] args) { HashMap map = new HashMap(); ① map.put("001", "Tom"); ② map.put("002", "Jack"); String name = (String) map.get("002"); ③ System.out.println(name); } } |
代码解析：
① 创建HashMap对象。
② 利用HashMap中的put方法将键值对形式的对象进行存储，put方法中的第一个参数为映射关系中key的值，put方法的第二个参数为映射关系中value的值。
③ 利用HashMap的get方法获取key对应的value，然后强制类型转换为实际类型。get中的参数为key，返回值为key对应的value。
下表列出了HashMap中常用的方法：
|
返回类型 |
方法名称 |
作用 |
|
Object |
put(Object key,Object value) |
加入元素，返回与此key关联的原有的value，不存在则返回null |
|
void |
clear() |
从集合中移除所有的元素 |
|
boolean |
containsKey(Object key) |
根据key从集合中判断key是否存在 |
|
boolean |
containsValue(Object value) |
根据value从集合中判断value是否存在 |
|
Object |
get(Object key) |
根据key返回key对应的值 |
|
Set |
keySet() |
返回Map集合中包含的键集合 |
|
Object |
remove(Object key) |
从集合中删除key对应的元素，返回与key对应的原有value，不存在则返回null |
|
int |
size() |
返回集合中的元素的数量 |
表： HashMap常用方法
Map集合的综合示例：
代码演示：Map集合综合演示
|
import java.util.HashMap; import java.util.Scanner; public class TestMap { public static void main(String[] args) { HashMap map = new HashMap(); Scanner scanner = new Scanner(System.in); for (int i = 0; i < 5; i++) { System.out.println("请输入身份证号："); String id = scanner.next(); System.out.println("请输入姓名："); String name = scanner.next(); map.put(id, name); ① } int size = map.size(); ② System.out.println("数据输入完毕！共" + size + "条数据！ ---------------------------------"); String answer = "no"; do { System.out.println("请输入你要查找的用户的身份证号："); String id = scanner.next(); if (map.containsKey(id)) { ③ String name = (String) map.get(id); ④ System.out.println("您查找的用户姓名为：" + name); } else { System.out.println("您查找的用户不存在！"); } System.out.println("您还要继续查找吗？(yes/no)"); answer = scanner.next(); } while ("yes".equalsIgnoreCase(answer)); System.out.println("请输入要删除的用户的身份证号："); String id = scanner.next(); if (map.containsKey(id)) { String name = (String) map.remove(id); ⑤ System.out.println("用户" + name + "删除成功！"); } else { System.out.println("您要删除的用户不存在！"); } System.out.println("要格式化系统吗？(yes/no)"); String format = scanner.next(); if ("yes".equalsIgnoreCase(format)) { map.clear(); ⑥ System.out.println("系统格式化完毕！当前系统中数据为" + map.size() + "条"); } System.out.println("程序运行结束！"); } } |
代码解析：
① 使用put方法将身份证号和姓名存入Map集合中。
② 使用size方法获得集合中的映射关系条数。
③ 使用containsKey方法判断集合是否存在与key对应的映射关系。
④ 使用get方法获得身份证号对应的姓名。
⑤ 使用remove方法删除身份证号对应的用户，返回身份证号对应的姓名。
⑥ 使用clear方法删除Map集合中所有的映射关系。
来看下面的一个示例：
代码演示：Map集合中重复key
|
import java.util.HashMap; public class DemoMap { public static void main(String[] args) { HashMap map = new HashMap(); map.put("001", "小美"); map.put("002", "阿聪"); ① map.put("002", "小莉"); ② String name = (String) map.get("002"); System.out.println(name); } } |
注意①和②处的代码，在向集合中添加值的时候，使用了重复的key，但是value不同，在下面获得key“002”的value为多少呢？程序运行的结果是“小莉”。从结果可以中可以知道，Map集合中的key不能是重复的，如果重复，那么后面添加的映射关系会覆盖前面的映射关系。导致这样情况的出现主要是因为Map集合中的key的维护是依靠Set集合（马上会学习到）完成的。
HashMap和Hashtable的操作是相同的，他们的区别如下：
? Hashtable是线程安全的，HashMap是非线程安全的。所有HashMap比Hashtable的性能更高。
? Hashtable不允许使用使用null值作为key或value，但是HashMap是可以的。
2. Set集合
Set集合和List集合的很多的用法是相同的。但是Set集合中的元素是无序的，元素也是不能重复的。Set集合中常用类为HashSet。
HashSet类中常用的方法如下：
|
返回类型 |
方法名称 |
作用 |
|
boolean |
add(Object obj) |
加入元素 |
|
void |
clear() |
移除Set集合中所有元素 |
|
boolean |
contains(Object obj) |
判断Set集合中是否包含指定元素 |
|
boolean |
isEmpty() |
判断Set集合是否为空 |
|
Iterator |
iterator() |
返回Set集合中对元素迭代的迭代器 |
|
boolean |
remove(Object obj) |
从集合中删除元素 |
|
Int |
size() |
返回集合中的元素数量 |
表： HashSet类常用方法
通过上面的表，可以清楚的看到Set集合的用法和List集合是相似的，但是需要注意Set集合的迭代和List集合是不同的，List的集合的迭代可以通过for循环获得索引来进行，但是Set集合的迭代必须要通过迭代器进行。
代码演示：Set集合的迭代
|
import java.util.HashSet; import java.util.Iterator; public class SetIterator { public static void main(String[] args) { HashSet set = new HashSet(); set.add("a"); set.add("b"); set.add("c"); Iterator iter = set.iterator(); ① while (iter.hasNext()) { ② String str = (String) iter.next(); ③ System.out.println(str); } } } |
代码解析：
① 通过Set集合的iterator()方法获得该集合的迭代器，迭代器是Iterator类的实例。
② 根据迭代器的hasNext()方法判断集合中是否还有元素，如果有就返回true。
③ 根据迭代器的next()方法获得集合中的元素，并强制类型转换为目标类型。
从上面例子的运行结果，可以看出Set中的元素是无序的。通过Set集合的迭代再来学习Map集合的迭代。
代码演示：Map集合的迭代
|
import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; public class MapIter { public static void main(String[] args) { HashMap map = new HashMap(); map.put("001", "小美"); map.put("002", "阿聪"); map.put("003", "小黑"); HashSet keys = (HashSet) map.keySet(); ① Iterator iter = keys.iterator(); while (iter.hasNext()) { String key = (String) iter.next(); ② String value = (String) map.get(key); ③ System.out.println(key + ":" + value); } } } |
代码解析：
① 调用Map集合的keySet方法获得Map集合中的key的集合。
② 获得key。
③ 根据key获得对应的value。
下面通过一个示例演示Set集合中不允许元素重复的特性：
代码演示：向Set集合中添加重复元素
|
import java.util.HashSet; import java.util.Iterator; public class Demo2 { public static void main(String[] args) { HashSet set = new HashSet(); set.add("a"); set.add("a"); set.add("c"); System.out.println("集合长度为：" + set.size()); Iterator iter = set.iterator(); while (iter.hasNext()) { String str = (String) iter.next(); System.out.println(str); } } } |
上面的代码输出集合的长度为2，而且集合中的元素只有一个a和c，从结果中可以看出Set集合中的元素是不能重复的。带着这个结论再来看下面的示例：
代码演示：向Set集合中添加重复元素
|
import java.util.HashSet; import java.util.Iterator; public class Demo3 { public static void main(String[] args) { Person personA = new Person("001", "Tom"); Person personB = new Person("001", "Tom"); HashSet set = new HashSet(); set.add(personA); set.add(personB); System.out.println("集合中元素个数：" + set.size()); Iterator iter = set.iterator(); while (iter.hasNext()) { Person p = (Person) iter.next(); System.out.println(p.cardId + ":" + p.name); } } } |
程序的运行结果如下：
|
集合中元素个数：2 001:Tom 001:Tom |
发现程序的运行结果是有“问题”的，因为Set集合中是不允许存放重复的元素的，但是两个Person对象的属性值是完全相同的，怎么还都能存放进去呢？要找到问题的答案，需要了解下Set集合的存放原理。
图： Set集合存储
从上图中可以看到，Set集合中的元素的无序性，但是Set集合是怎么判断每个元素的存放的位置呢？在向Set集合中存放元素时，Set集合根据元素的hashCode()方法来获取一个int类型的数据，然后根据这个数据来计算元素在集合中的位置。但是在存储元素时会出现两个元素的hashCode()方法返回值相同的情况，比如上图的对象C和D就出现了这种情况，导致计算出元素在集合中的位置相同，这种情况称之为“冲突”。如果发生了冲突，Set集合会根据发生冲突元素之间调用equals()方法进行比较，如果equals()返回值为true，说明两个元素为相同的元素，这样会导致添加操作无效。如果equals()返回值为false，说明两个元素不相同，这样Set集合会将该元素进行偏移存储。“冲突”发生的频率越高，Set集合的性能就越低，要尽可能的避免冲突的发生， 就要在类中重写hashCode()方法，并且要尽可能的保证hashCode()方法返回值是唯一的。在重写hashCode()方法时有个技巧，就是让对象中的数值属性和一个素数相乘，并将积相加，对于对象类型，调用其hashCode()方法即可。
对于hashCode()和equals()两个方法有这样的规律，hashCode()方法返回值相同时，equals()方法比较并不一定相等，但是equals()方法比较相等，hashCode()方法返回值是相同的。
代码演示：实现Person对象的equals和hashCode方法
|
public class Person { String cardId; String name; public Person(String cardId, String name) { this.cardId = cardId; this.name = name; } public int hashCode() { return cardId.hashCode() + name.hashCode(); } public boolean equals(Object obj) { if (obj == null){ return false; } if(obj instanceof Person){ Person other = (Person) obj; if (cardId == null) { if (other.cardId != null){ return false; } } else if (!cardId.equals(other.cardId)){ return false; } if (name == null) { if (other.name != null){ return false; } } else if (!name.equals(other.name)){ return false; } }else{ return false; } return true; } } |
再次运行Demo3的代码，运行结果如下：
|
集合中元素个数：1 001:Tom |
3. 本章总结
1. Map集合用于保存具有映射关系的数据，即以键值对（key->value）的方式来存储数据。因此在Map集合内部有两个集合，一个集合用于保存Map中的key（键），一个集合用于保存Map中的value（值），其中key和value可以是任意数据类型数据。
2. Set集合的特点。
3. Set集合的使用及迭代。
4. Map集合的迭代。