Java基础（六）——集合

一、概述

1、介绍

　　为什么出现集合？
　　答：面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，对对象进行存储，集合就是存储对象最常用的一种方式。
　　数组和集合类同是容器，有何不同？
　　答：数组虽然也可以存储对象，但长度是固定的，集合长度是可变的。数组中可以存储基本数据类型，集合中只能存储对象（引用类型，基本类型的包装类型）。
　　为什么会出现这么多的容器呢？
　　答：因为每一个容器对数据的存储方式都有不同。这个存储方式称之为：数据结构。
　　什么是迭代器呢？
　　答：其实就是集合的取出元素的方式。

2、集合框架

　　简图：

　　Collection：

　　Map：

二、Collection<E>(jdk1.2)

　　集合中存储的都是对象的引用（地址）。

1、常用方法

　　add(Object obj)：添加。
　　addAll(Collection coll)：添加。
　　int size()：获取有效元素的个数。
　　void clear()：清空集合。
　　boolean isEmpty()：是否是空集合。
　　boolean contains(Object obj)：是否包含某个元素，通过元素的equals方法来判断是否是同一个对象。
　　boolean containsAll(Collection c)：也是调用元素的equals方法来比较的。两个集合的元素挨个比较。

　　boolean remove(Object obj) ：删除，通过元素的equals方法判断是否是要删除的那个元素。只会删除找到的第一个元素。
　　boolean removeAll(Collection coll)：删除，取当前集合的差集。
　　boolean retainAll(Collection c)：取交集，把交集的结果存在当前集合中，不影响c。
　　boolean equals(Object obj)：集合是否相等。
　　Object[] toArray()：转成对象数组。
　　hashCode()：获取集合对象的哈希值。
　　iterator()：返回迭代器对象，用于集合遍历。

　　代码示例：基本方法

 1 public class Main {
 2     public static void main(String[] args) {
 3         Collection<Object> coll = new ArrayList<>();
 4
 5         coll.add("AA");
 6         coll.add("BB");
 7         coll.add(123); // 自动装箱
 8         coll.add(new Date());
 9
10         System.out.println(coll.size());  // 4
11
12         Collection<Object> coll1 = new ArrayList<>();
13         coll1.add(456);
14         coll1.add("CC");
15         coll1.add(123);
16
17         coll.addAll(coll1);
18         System.out.println(coll);
19
20         coll.clear(); // 清空集合元素
21
22         System.out.println(coll.isEmpty()); // true
23     }
24 }

　　代码示例：初始化类

 1 // 预先定义的实体类
 2 public class Person {
 3
 4     private String name;
 5     private int age;
 6
 7     // 无参构造器
 8     // 有参构造器
 9     // getter & setter
10     // toString()
11
12     @Override
13     public boolean equals(Object o) {
14         System.out.println("Person equals()....");
15         if (this == o) return true;
16         if (o == null || getClass() != o.getClass()) return false;
17         Person person = (Person) o;
18         return age == person.age &&
19                 Objects.equals(name, person.name);
20     }
21
22     @Override
23     public int hashCode() {
24         return Objects.hash(name, age);
25     }
26 }
27
28 // 初始化的集合.下面的代码示例,集合都是这个.
29 public Collection<Object> init() {
30     Collection<Object> coll = new ArrayList<>();
31
32     coll.add(123);
33     coll.add(456);
34     coll.add(new Person("Jerry", 20));
35     coll.add("Tom");
36     coll.add(false);
37
38     return coll;
39 }

 1 public void method1() {
 2     System.out.println(coll.hashCode());
 3
 4     // 判断当前集合中是否包含obj
 5     // 想要按 Person 对象的属性来比较，需要复写 equals(Object o)
 6     // false --> true
 7     System.out.println(coll.contains(new Person("Jerry", 20)));
 8
 9     // 当且仅当形参中的所有元素都存在于当前集合中.true
10     // true
11     System.out.println(coll.containsAll(Arrays.asList(123, 456)));
12
13     coll.remove(1234);
14     coll.remove(new Person("Jerry", 20));
15     // 差集：A - B
16     coll.removeAll(Arrays.asList(123, 4567));
17
18     System.out.println(coll);
19
20     // 两个集合完全相同,包括顺序相同(这个又具体子类决定)
21     // System.out.println(coll.equals(coll1));
22
23     // 交集
24     coll.retainAll(Arrays.asList(123, 666));
25     System.out.println(coll);
26 }
27
28 // 结果
29 -1200490100
30 Person equals()....
31 Person equals()....
32 Person equals()....
33 true
34 true
35 Person equals()....
36 Person equals()....
37 Person equals()....
38 [456, Tom, false]
39 []

　　结果分析：
　　①判定一个集合中是否包含某个对象，contains(Object o)方法，会调用equals(Object o)去比较，所以需要复写equals(Object o)方法。
　　②对象Person是第3个被加入到集合中的，比较的时候需要一个一个比较，所以equals()方法被调用了3次。
　　③remove(Object o)时同样equals()方法被调用了3次。

　　代码示例：集合 <--> 数组

1 public void method2() {
2     // 集合 --> 数组
3     final Object[] objects = coll.toArray();
4     final Object[] array = coll.toArray(new Object[0]);
5
6     // 数组 --> 集合
7     final List<String> strings = Arrays.asList("A", "B", "C");
8     final List<Integer> integers = Arrays.asList(123, 456);
9 }

2、Iterator<E>（迭代器）

　　GOF给迭代器模式的定义为：提供一种方法访问一个容器（container）对象中各个元素，而又不需暴露该对象的内部细节。迭代器模式，就是为容器而生。类似于"公交车上的售票员"、"火车上的乘务员"、"空姐"。
　　一种集合的取出元素的方式。定义在集合的内部，用于直接访问集合内 部的元素，是一个内部类。集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。Iterator主要用于遍历Collection，不包括map。
　　用foreach遍历Collection，底层还是使用的迭代器。迭代器原理：

　　JDK8源码：

　　代码示例：迭代器的使用

 1 // 注意：这里是迭代器里的remove，不是集合里面的。
 2 public void method3() {
 3     Iterator<Object> iterator = coll.iterator();
 4     while (iterator.hasNext()) {
 5         // next():①指针下移 ②将下移以后集合位置上的元素返回
 6         System.out.println(iterator.next());
 7     }
 8
 9     // 返回一个全新的迭代器
10     iterator = coll.iterator();
11     while (iterator.hasNext()) {
12         // iterator.remove(); 报错IllegalStateException
13         final Object next = iterator.next();
14
15         if ("Tom".equals(next)) {
16             iterator.remove();
17             // iterator.remove(); 报错IllegalStateException
18         }
19     }
20 }

3、List<E>、Queue<E>、Set<E>（重点）

　　List<E>元素是有序的，可重复，因为该集合体系有索引。实现类：
　　ArrayList：底层使用的数组数据结构。特点：查询速度很快，但是增删稍慢（会移动后面的元素）。初始长度10，50%延长。线程不同步的。jdk1.2
　　LinkedList：底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步的。
　　Vector：底层使用的数组数据结构。初始长度10，100%延长。线程同步的。后被ArrayList替代了。jdk1.0

　　Queue<E>有序的，可重复。实现类：
　　Deque<E>（接口）：
　　LinkedList：底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步的。

　　Set<E>元素是无序的，不重复。没有索引。实现类：
　　HashSet：底层使用的HashMap（数组+链表）数据结构。无序的，不可重复，线程不同步。可以存储null值。
　　TreeSet：底层使用的TreeMap（排序二叉树，红黑树）数据结构。可以对set集合中的元素按指定属性进行排序。有序的。查询速度比List快。

三、List<E>

1、ArrayList<E>

　　代码示例：迭代器的使用

 1 // 其他常用方法不演示
 2 public class Main {
 3     public static void main(String[] args) {
 4         List<String> list = new ArrayList<>();
 5         list.add("A");
 6         list.add("B");
 7         list.add("C");
 8         list.add("D");
 9
10         final Iterator<String> iterator = list.iterator();
11         while (iterator.hasNext()) {
12             System.out.print(iterator.next());
13         }
14     }
15 }
16
17 // 结果
18 // A B C D

2、Vector<E>

　　枚举就是Vector特有的取出方式，和迭代器很像，其实是一样的，由于名称过长，后被迭代器取代了。

 1 public static void main(String[] args) {
 2     Vector<String> vector = new Vector<>();
 3
 4     vector.add("A");
 5     vector.add("B");
 6
 7     // 返回此向量的组件的枚举.
 8     final Enumeration<String> elements = vector.elements();
 9
10     while (elements.hasMoreElements()) {
11         System.out.println(elements.nextElement());
12     }
13 }
14
15 // 结果
16 // A B

3、Stack<E>（栈）

 1 // 先进后出
 2 public class Main {
 3     public static void main(String[] args) {
 4         Stack<String> stack = new Stack<>();
 5
 6         // 压栈
 7         stack.push("A");
 8         stack.push("B");
 9         stack.push("C");
10
11         while (!stack.empty()) {
12             // 从栈顶弹出一个.会删除元素
13             System.out.println(stack.pop());
14         }
15
16         // 从栈顶弹出一个.不会删除元素
17         // stack.peek();
18     }
19 }
20
21 // 结果
22 C B A

四、Queue<E>

1、Queue<E>（队列）

 1 // 先进先出
 2 public class Main {
 3     public static void main(String[] args) {
 4         Queue<Integer> queue = new LinkedList<>();
 5
 6         // 添加.入队
 7         queue.offer(1);
 8         queue.offer(10);
 9         queue.offer(5);
10         queue.offer(9);
11         System.out.println(queue);
12
13         // 出队
14         final Integer poll = queue.poll();
15         System.out.println(poll);
16         System.out.println(queue);
17
18         // 获取.队头
19         final Integer peek = queue.peek();
20         System.out.println(peek);
21         System.out.println(queue);
22     }
23 }
24
25 // 结果
26 [1, 10, 5, 9]
27 1
28 [10, 5, 9]
29 10
30 [10, 5, 9]

2、Deque<E>（双端队列）

3、LinkedList<E>（双向链表）

　　对于频繁的插入或删除元素的操作，建议使用LinkedList类，效率较高。

　　特有方法
　　addFirst()：在第一个位置添加元素。
　　addLast()
　　getFirst()：获取第一个元素，但不删除元素。若没有，出现异常。
　　getLast()
　　removeFirst()：获取元素，但是删除元素。若没有，出现异常。
　　removeLast()

　　在jdk1.6以后出现了替代方法。
　　offerFirst()：在第一个位置添加元素。
　　offerLast()
　　peekFirst()：获取元素，但不删除元素。若没有，返回null。
　　peekLast()
　　pollFirst()：获取元素，但是删除元素。若没有，返回null。
　　pollLast()

五、Set<E>

1、介绍

　　Set<E>元素是不重复。没有索引。实现类：
　　HashSet：底层使用的HashMap（数组+链表）数据结构。无序的，不可重复，线程不安全。可以存储null值。
　　LinkedHashSet：底层使用的 LinkedHashMap。无序的，不可重复。
　　TreeSet：底层使用的TreeMap（排序二叉树，红黑树）数据结构。可以对set集合中的元素按指定属性进行排序。有序的。查询速度比List快。

　　以HashSet为例理解无序、不重复：
　　无序的：不等于随机性（并不是说打印的顺序没有按照添加的顺序），是指的存储的数据在底层数组中并非按照数组索引的顺序依次添加，而是根据数据的哈希值确定的索引位置。
　　不重复：调用对象equals()方法保证相同元素只添加一次。
　　要求：向Set（主要指：HashSet、LinkedHashSet）中添加的数据，其所在的类一定要重写hashCode()和equals()。重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码。

　　重写 hashCode() 方法的基本原则：
　　（1）程序运行时，同一个对象多次调用 hashCode() 方法应该返回相同的值。
　　（2）当两个对象的 equals() 方法比较返回 true 时，这两个对象的 hashCode() 方法的返回值也应相等。
　　（3）对象中用作 equals() 方法比较的 Field，都应该用来计算 hashCode 值。

　　重写 equals() 方法的基本原则：
　　当一个类有自己特有的"逻辑相等"概念，需要重写equals()的时候，总是要重写hashCode()，根据一个类的equals方法（改写后），两个截然不同的实例有可能在逻辑上是相等的，但是，根据Object.hashCode()方法，它们仅仅是两个对象。因此，违反了"相等的对象必须具有相等的散列码"。
　　结论：复写equals方法的时候一般都需要同时复写hashCode方法。通常参与计算hashCode的对象的属性也应该参与到equals()中进行计算。

2、HashSet<E>

　　HashSet 按 Hash 算法来存储集合中的元素，因此具有很好的存取、查找和删除性能。
　　底层数据结构：看JDK8的源码，HashSet底层是一个HashMap。而HashMap底层是数组+链表（7），数组+链表+红黑树（8）。
　　元素添加过程：由于HashSet底层就是HashMap，所以它的原理只需要了解HashMap即可。

 1 // API使用
 2 public class Main {
 3     public static void main(String[] args) {
 4         Set<String> set1 = new HashSet<>();
 5         Set<String> set2 = new HashSet<>();
 6
 7         set1.add("a");
 8         set1.add("b");
 9         set1.add("c");
10
11         set2.add("c");
12         set2.add("d");
13         set2.add("e");
14
15         // 取交集
16         set1.retainAll(set2);
17         System.out.println(set1); // [c]
18         // 取并集
19         // set1.addAll(set2);
20         // System.out.println(set1); // [a, b, c, d, e]
21         // 取差集
22         // set1.removeAll(set2);
23         // System.out.println(set1); // [a, b]
24     }
25 }

3、LinkedHashSet<E>

　　作为HashSet的子类，LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置（依然是无序的）， 但它同时使用双向链表维护元素的添加次序，这使得元素看起来是以插入顺序保存的。也可以按照添加的顺序遍历。
　　对于频繁的遍历操作，LinkedHashSet效率高于HashSet。LinkedHashSet插入性能略低于 HashSet。
　　代码示例：

 1 public class Main {
 2     public static void main(String[] args) {
 3         Set set = new LinkedHashSet();
 4         set.add("AA");
 5         set.add(456);
 6         set.add(456);
 7
 8         set.add(new User("刘德华", 60));
 9
10         Iterator iterator = set.iterator();
11         while (iterator.hasNext()) {
12             System.out.println(iterator.next());
13         }
14     }
15 }
16
17 // 结果:按照添加的顺序遍历.
18 AA
19 456
20 User{name='刘德华', age=60}
21
22 // 若Set set = new HashSet();则遍历不按照添加的顺序

　　底层结构：

4、TreeSet<E>

　　底层是排序二叉树，所以①必须是相同类型的对象。②必须可排序。自然排序（实现Comparable接口）和定制排序（Comparator）。
　　自然排序中，判断两个对象是否相同的标准为：compareTo()返回0，不是equals()。
　　定制排序中，判断两个对象是否相同的标准为：compare()返回0。不是equals()。
　　若compareTo始终返回0，则add始终只有一个元素。因为后面的都认为与前面的相同，因此没有加入进来。判断两个对象是否相等的标准是compareTo返回值相同。
　　底层数据结构：看JDK8的源码，TreeSet底层是一个TreeMap。采用红黑树的存储结构。有序的。查询速度比List快。
　　元素添加过程：
　　代码示例：让User具有可比性，自然排序：Comparable

 1 public class User implements Comparable<User> {
 2     private String name;
 3     private int age;
 4
 5     // 无参构造器
 6     // 有参构造器
 7     // getter & setter
 8     // toString()
 9     // 可以不复写equals、hashCode
10
11     @Override
12     public int compareTo(User user) {
13         System.out.println(this.name + "-------------" + user.getName());
14
15         if (this.age > user.age) {
16             return 1;
17         }
18         if (this.age < user.age) {
19             return -1;
20         }
21         return 0;
22     }
23 }
24
25 // 测试类
26 public static void main(String[] args) {
27     TreeSet<User> treeSet = new TreeSet<>();
28
29     treeSet.add(new User("java1", 30));
30     treeSet.add(new User("java2", 20));
31     treeSet.add(new User("java3", 31));
32     treeSet.add(new User("java4", 60));
33
34     final Iterator<User> iterator = treeSet.iterator();
35     while (iterator.hasNext()) {
36         final User user = iterator.next();
37         System.out.println(user.getName() + "---------" + user.getAge());
38     }
39 }
40
41 // 结果
42 java1-------------java1 // 第一次
43 java2-------------java1 // 2和1比,2在左边
44 java3-------------java1 // 3和1比,3在右边
45 java4-------------java1 // 4和1比,4在右边
46 java4-------------java3 // 4和3比,4在右边
47 java2---------20
48 java1---------30
49 java3---------31
50 java4---------60

　　结果分析：不难理解打印结果的比较次数。

　　代码示例：指定比较器，定制排序：Comparator

 1 // 比较器
 2 public static void main(String[] args) {
 3     final Comparator<User> comparator = new Comparator<User>() {
 4         // 按照年龄从小到大排列
 5         @Override
 6         public int compare(User o1, User o2) {
 7             return Integer.compare(o1.getAge(), o2.getAge());
 8         }
 9     };
10
11     TreeSet<User> treeSet = new TreeSet<>(comparator);
12
13     treeSet.add(new User("java1", 30));
14     treeSet.add(new User("java2", 20));
15     treeSet.add(new User("java3", 31));
16     treeSet.add(new User("java4", 60));
17     treeSet.add(new User("java5", 60));
18
19     final Iterator<User> iterator = treeSet.iterator();
20     while (iterator.hasNext()) {
21         final User user = iterator.next();
22         System.out.println(user.getName() + "---------" + user.getAge());
23     }
24 }
25
26 // 结果
27 java2---------20
28 java1---------30
29 java3---------31
30 java4---------60

六、Map<K,V>

1、介绍（重点）

　　双列数据，存储key-value对的数据。用作键的对象必须实现hashCode方法和equals方法。实现类：
　　HashMap：底层使用的（数组+链表7+红黑树8）数据结构。特点：可以存入null键null值。线程不同步，效率高。jdk1.2
　　Hashtable：底层使用的（数组+链表）数据结构。特点：不可以存入null键null值。线程同步，效率低。jdk1.0
　　TreeMap：底层使用的（排序二叉树，红黑树）数据结构。实现了SortedMap有序序列接口，特点：可以用于给map集合中的键按指定属性进行排序。线程不同步。
　　WeakHashMap：底层使用的（数组+链表）数据结构。特点：键是"弱键"。

2、HashMap<K,V>

　　HashMap中的Entry对象是无序排列的。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

　　代码示例：三种遍历方式

 1 public class Main {
 2     public static void main(String[] args) {
 3         Map<String, String> map = new HashMap<>();
 4         map.put("A", "1");
 5         map.put("B", "2");
 6         map.put("c", "3");
 7
 8         // 1.获取键集：keySet()
 9         final Set<String> keySet = map.keySet();
10         for (String key : keySet) {
11             System.out.println("keySet()----" + key + "----" + map.get(key));
12         }
13
14         // 2.获取值集：values()
15         final Collection<String> values = map.values();
16         for (String value : values) {
17             System.out.println("values()----" + value);
18         }
19
20         // 3.获取entry集：entrySet()
21         final Set<Map.Entry<String, String>> entries = map.entrySet();
22         for (Map.Entry<String, String> entry : entries) {
23             System.out.println("entrySet()----" + entry.getKey() + "----" + entry.getValue());
24         }
25     }
26 }

3、Hashtable<K,V>

4、TreeMap<K,V>

　　向TreeMap中添加key-value，要求key①必须是相同类型的对象。②必须可排序。用于给map集合中的键按指定属性进行排序。
　　代码示例：让User具有可比性，自然排序：Comparable

 1 public class User implements Comparable<User> {
 2     private String name;
 3     private int age;
 4
 5     // 无参构造器
 6     // 有参构造器
 7     // getter & setter
 8     // toString()
 9     // 可以不复写equals、hashCode
10
11     // 年龄从小到大排列
12     @Override
13     public int compareTo(User user) {
14         System.out.println(this.name + "---------" + user.getName());
15         return Integer.compare(this.age, user.age);
16     }
17 }
18
19 // 测试类
20 public static void main(String[] args) {
21     TreeMap<User, Integer> treeMap = new TreeMap<>();
22     User u1 = new User("Tom", 23);
23     User u2 = new User("Jerry", 32);
24     User u3 = new User("Jack", 20);
25     User u4 = new User("Rose", 18);
26
27     treeMap.put(u1, 98);
28     treeMap.put(u2, 89);
29     treeMap.put(u3, 76);
30     treeMap.put(u4, 100);
31
32     for (Map.Entry<User, Integer> entry : treeMap.entrySet()) {
33         System.out.println(entry.getKey() + "---->" + entry.getValue());
34     }
35 }
36
37 // 结果
38 Tom---------Tom
39 Jerry---------Tom
40 Jack---------Tom
41 Rose---------Tom
42 Rose---------Jack
43 User{name='Rose', age=18}---->100
44 User{name='Jack', age=20}---->76
45 User{name='Tom', age=23}---->98
46 User{name='Jerry', age=32}---->89

　　结果分析：按键 User 指定属性 age 排序，不难理解打印结果的比较次数。排序二叉树：

　　代码示例：指定比较器，定制排序：Comparator

 1 // 比较器
 2 public static void main(String[] args) {
 3     TreeMap<User, Integer> treeMap = new TreeMap<>(new Comparator<User>() {
 4         @Override
 5         public int compare(User u1, User u2) {
 6             return Integer.compare(u1.getAge(), u2.getAge());
 7         }
 8     });
 9
10     User u1 = new User("Tom", 23);
11     User u2 = new User("Jerry", 32);
12     User u3 = new User("Jack", 20);
13     User u4 = new User("Rose", 18);
14
15     treeMap.put(u1, 98);
16     treeMap.put(u2, 89);
17     treeMap.put(u3, 76);
18     treeMap.put(u4, 100);
19
20     for (Map.Entry<User, Integer> entry : treeMap.entrySet()) {
21         System.out.println(entry.getKey() + "---->" + entry.getValue());
22     }
23 }
24
25 // 结果.和自然排序的结果一致.
26 User{name='Rose', age=18}---->100
27 User{name='Jack', age=20}---->76
28 User{name='Tom', age=23}---->98
29 User{name='Jerry', age=32}---->89

5、Properties

　　常用来处理配置文件。key和value都是String类型。
　　代码示例：读取属性文件

 1 // jdbc.properties
 2 name=Tom
 3 password=abc123
 4
 5 // 未关闭资源
 6 public static void main(String[] args) throws Exception {
 7     Properties pros = new Properties();
 8
 9     FileInputStream fis = new FileInputStream("jdbc.properties");
10     pros.load(fis);
11
12     String name = pros.getProperty("name");
13     String password = pros.getProperty("password");
14
15     System.out.println("name = " + name + ", password = " + password);
16 }
17
18 // 结果
19 name = Tom, password = abc123

6、ConcurrentHashMap<K,V>

　　请查看JDK源码。