Java集合框架的使用

基本概述

Java中的集合框架与数组类似，都是用于存储多个同一类型数据的容器。

但是对于数组的使用，会因为数组本身的特性会导致一些使用限制，例如：

数组要求在构造时，就必须确定数组的长度。所以如果想要存放的数据个数不确定，数组就无法使用。

于是促使了集合框架的诞生，与数组相比，集合框架最大特点在于：

• 集合框架下的容器类只能存放对象类型数据；而数组支持对基本类型数据的存放。
  
• 任何集合框架下的容器类，其长度都是可变的。所以不必担心其长度的指定问题。
• 集合框架下的不同容器了底层采用了不同的数据结构实现，而因不同的数据结构也有自身各自的特性与优劣。
  

常用容器类关系图

网上找的一张图，基本描述了Java集合框架中最常用部分的构成关系：

集合框架的分类

1、Collection体系：以单值的形式存储对象数据的容器体系。

  1.1、List容器：允许重复元素的存储。(最常用的为ArrayList以及LinkedList；另外在JDK1.2集合框架出现之前，该类型使用的容器为Vector)

• ArrayList  ：线程不同步、底层的数据结构是数组结构、元素存储顺序有序、访问元素速度相对较快，存取或删除元素等操作速度较慢
  
• LinkedList ：线程不同步、底层的数据结构是链表结构、元素存储顺序有序、访问元素速度相对较慢，存取或删除元素等操作速度快
• Vector     ：线程同步、  底层的数据结构是数组结构、元素存储顺序有序、访问，存取，删除元素的操作都很慢。

  1.2、Set容器：不允许重复元素的存储，该容器中存储的对象都是唯一的。(最常用的为HashSet与TreeSet)

• HashSet  ：线程不同步、底层的数据结构为哈希表结构、无序
• TreeSet  ：线程不同步、底层的数据结构为二叉树结构、会按自然排序方式或指定排序方式对元素进行排序

2、Map体系：以“键值对”的形式存储数据的容器体系。即是将键映射到值的对象；一个映射不能包含重复的键；每个键最多只能映射到一个值。

• HashMap   ：线程不同步、底层数据结构是哈希表结构、无序、允许NUll作为键或值
• Hashtable ：线程同步  、底层数据结构是哈希表结构、无序、不允许NUll作为键或值
• TreeMap   ：线程不同步、底层数据结构是二叉树结构、可以按照自然或指定排序方式对映射中的键进行排序

面试中常常会问到HashMap和HashTable的不同，由此就可以做出回答：

1、HashTable与Vector一样，在JDK1.2之前就存在，是基于陈旧的Dictionary类实现的。

   HashMap是JDK1.2之后，经集合框架出现之后，基于Map接口实现的。

2、HashTable是线程同步的，而HashMap默认并没有实现线程同步。

   也就是说，如果存在多线程并发操作同一个HashMap容器对象时，需要自己加上同步。

3、HashTable中存放的数据允许将null作为键或值，而HashMap则不支持。

List接口的常用操作

List接口是Collection的子接口，这就意味着：除开Collection接口提供的方法列表之外，它又根据自身特性新增了一些额外的方法。

所谓数据存放的容器，所涉及的操作自然离不开“增删改查”。那就不妨来看一下关于List体系下，常用的操作方法。

List接口的常用方法列表

1.添加操作

• void add(index,element);    //在列表的指定位置插入元素
• void add(index,collection); //将指定collection中的所有元素都插入到列表中的指定位置

2.删除操作

• Object remove(index):       //移除列表中指定位置的元素

3.修改操作

• Object set(index,element);  //修改(替换)列表指定位置的元素的值

4.获取操作

• Object get(index);          //获取列表指定位置的元素的值
• int indexOf(object);        //获取对象在列表中的位置,如果不包含该对象，则返回-1
• int lastIndexOf(object);    //获取对象在列表中最后一次出现的位置，如果不包含该对象，则返回-1
• List subList(from,to);      //从指定起始位置from(包括)到指定结束位置to(不包括)截取列表

可以看到与其父接口Collection提供的方法列表相比，List接口新增的方法有一个显著的特性：可以操作角标。

ArrayList的基本应用

[java] view plain copy

1. package com.tsr.j2seoverstudy.collection;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5.   
6. public class ArrayListTest {  
7.     public static void main(String[] args) {  
8.         //ArrayList容器对象的创建  
9.         ArrayList<Integer> arrayList = new ArrayList<Integer>();  
10.         List<Integer> listTemp = new ArrayList<Integer>();  
11.           
12.         //添加数据的操作  
13.         //添加单个元素  
14.         arrayList.add(1);  
15.         arrayList.add(2);  
16.         listTemp.add(3);  
17.         listTemp.add(4);  
18.         //一次性添加另一个容器内的所有元素  
19.         arrayList.addAll(listTemp);  
20.         //在指定位置添加元素  
21.         arrayList.add(0, 5);  
22.         //打印一次数据  
23.         printList(arrayList);  
24.         System.out.println();  
25.           
26.         //删除数据  
27.         System.out.println("删除的元素为:"+arrayList.remove(2));  
28.         System.out.println("删除元素值为5的元素是否成功:"+arrayList.remove(new Integer(5)));  
29.         printList(arrayList);  
30.         System.out.println();  
31.           
32.         //修改数据  
33.         System.out.println("修改下标为1的元素值为6，修改前的值是："+arrayList.set(1, 6));  
34.         printList(arrayList);  
35.         System.out.println();  
36.           
37.         //获取元素总个数  
38.         System.out.println("size:"+arrayList.size());  
39.         //元素截取  
40.         listTemp = arrayList.subList(0, 2);  
41.         System.out.print("listTemp:");  
42.         printList(listTemp);  
43.     }  
44.       
45.     static void printList(List<Integer> list){  
46.         for (Integer integer : list) {  
47.             System.out.print(integer + "\t");  
48.         }  
49.     }  
50. }  
51.   
52. /* 
53.  输出结果为： 
54.  5  1   2   3   4    
55.   删除的元素为:2 
56.   删除元素值为5的元素是否成功:true 
57.  1  3   4    
58.  修改下标为1的元素值为6，修改前的值是：3 
59.  1  6   4    
60.  size:3 
61.  listTemp:1 6    
62. */  

LinkedList的基本使用

与ArrayList不同，LinkedList内部采用链表结构所实现，它每一个节点（Node）都包含两方面的内容： 
节点本身的数据（data）以及下一个节点的信息（nextNode）。

之所以LinkedList对于数据的增加，删除动作的速度更快，正是源于其内部的链表结构。

由于ArrayList内部采用数组结构，所以一旦你在某个位置添加或删除一个数据，之后的所有元素都不得不跟着进行一次位移。

而对于LinkedList则只需要更改nextNode的相关信息就可以实现了，这是LinkedList的优势。

而也正是基于链表结构的特性，LinkedList还新增了一些自身特有的方法。

其中最常用的是:addFirst(E e),addLast(E e),getFirst(),getLast(),removeFirst(),removeLast()等方法。

对于LinkedList中元素的基本操作方法，与ArrayList并无多大区别。

所以这里主要看一下对于LinkedList的链表特性和新增方法的使用方式。

根据这些特性，我们可以通过封装LinkedList来实现我们自己的容器类。

并且，可以完成队列，或是栈的不同存储方式的实现。

而在面试中，也可能遇到类似问题：请分别自定义实现一个采用队列和栈存储方式的容器类。

那么，队列意味着数据先进先出，而栈则意味着数据先进后出的特性，正好可以通过LinkedList来实现：

[java] view plain copy

1. package com.tsr.j2seoverstudy.collection;  
2.   
3. import java.util.LinkedList;  
4. /* 
5.  * 输出结果为： 
6.  * 队列:  s1  s2  s3  s4   
7.  * 栈：   s4  s3  s2  s1   
8.  */  
9. public class QueueAndStack {  
10.     public static void main(String[] args) {  
11.         MyQueue q = new MyQueue();  
12.         q.add("s1");  
13.         q.add("s2");  
14.         q.add("s3");  
15.         q.add("s4");  
16.         System.out.print("队列:"+"\t");  
17.         while (!q.isEmpty()) {  
18.             System.out.print(q.get()+"\t");  
19.         }  
20.         System.out.println();  
21.         System.out.print("栈："+"\t");  
22.         MyStack s = new MyStack();  
23.         s.push("s1");  
24.         s.push("s2");  
25.         s.push("s3");  
26.         s.push("s4");  
27.         while (!s.isEmpty()) {  
28.             System.out.print(s.pop()+"\t");  
29.         }  
30.     }  
31. }  
32.   
33. //我的队列  
34. class MyQueue {  
35.   
36.     private LinkedList linklist;  
37.   
38.     MyQueue() {  
39.         this.linklist = new LinkedList();  
40.     }  
41.   
42.     public void add(Object obj) {  
43.         linklist.addFirst(obj);  
44.     }  
45.   
46.     public Object get() {  
47.         return linklist.removeLast();  
48.     }  
49.   
50.     public boolean isEmpty() {  
51.         return linklist.isEmpty();  
52.     }  
53. }  
54.   
55. //我的栈  
56. class MyStack {  
57.     private LinkedList linklist;  
58.   
59.     MyStack() {  
60.         this.linklist = new LinkedList();  
61.     }  
62.   
63.     public void push(Object obj) {  
64.         linklist.addFirst(obj);  
65.     }  
66.   
67.     public Object pop() {  
68.         return linklist.removeFirst();  
69.     }  
70.   
71.     public boolean isEmpty() {  
72.         return linklist.isEmpty();  
73.     }  
74. }  

简而言之，如果不涉及到底层实现的“数据结构”的具体研究，而只是针对于容器自身的使用。

那么了解了不同容器之间的特点就应放在首位。因为了解了不同容器之间的差别，基本上也就对集合框架有一个不错的掌握了。

正如ArrayList和LinkedList，它们对于操作数据提供的方法使用都是没有太大区别的。因为它们都是基于List接口而实现的。

而针对于它们的使用，则是根据实际需求，来选择更适合的容器类。例如说：可以考虑你的数据是否需要频繁的增删操作？

如果需要，则选择LinkedList。否则就可以选择ArrayList，因为其访问元素的速度更快。

Set接口的常用操作

与同样隶属于Colleciton体系下的List接口不同的是，实现Set接口的容器类有着保证存放元素唯一性的特性。

Set接口的实现子类当中，最为常用的容器类分别是HashSet和TreeSet。

HashSet的基本使用

顾名思义，HashSet内部采用的是哈希表结构。而该容器也正是基于此特性来保证元素唯一的。

HashSet容器会通过存放的元素的类型中的hashCode方法和equals方法判断元素是否相同。

首先经hashCode方法判断，如果通过hashCode()方法返回的哈希值不同，则证明不是重复元素，直接存储到哈希表中。

而如果判断得到的元素的hashCode值相同，则接着调用对象的equal方法判断元素是否重复。

来看一个例子：

[java] view plain copy

1. package com.tsr.j2seoverstudy.collection;  
2.   
3. import java.util.HashSet;  
4. import java.util.Set;  
5.   
6. /* 
7.  * 输出结果为： 
8.  * name:张三..age:19 
9.  * name:张三..age:19 
10.  * name:李四..age:20 
11.  */  
12. public class HashSetDemo {  
13.     public static void main(String[] args) {  
14.         HashSet<Student> set = new HashSet<Student>();  
15.         set.add(new Student("张三", 19));  
16.         set.add(new Student("李四", 20));  
17.         set.add(new Student("张三", 19));  
18.           
19.         printSet(set);  
20.     }  
21.   
22.     static void printSet(Set<Student> set) {  
23.         for (Student student : set) {  
24.             System.out.println(student);  
25.         }  
26.     }  
27. }  
28.   
29. class Student {  
30.     private String name;  
31.     private int age;  
32.   
33.     Student(String name, int age) {  
34.         this.name = name;  
35.         this.age = age;  
36.     }  
37.   
38.     @Override  
39.     public String toString() {  
40.         return new StringBuilder().append("name:").append(name)  
41.                 .append("..age:").append(age).toString();  
42.     }  
43.   
44. }  

从程序的输出结果中注意到Set中存放了两个姓名同为“张三”，年龄同为19岁的学生。

这可能与我们最初的设想偏离甚远，不是说Set容器类保证元素唯一性吗？为何出现重复。

这正是因为自定义的Student中并没有对hashCode于equals方法进行覆写。

所以HashSet容器在通过equals方法判断元素是否重复的时候，采用的原本Object当中“obj1==obj2”的方式。

==用于比较对象的时候，是比较内存中的地址，所以自然得到的结果是两个对象不是相同的。

所以说，在使用HashSet容器存储自定义对象的时候。请一定记得按照自己的需求，重新覆写hashCode与equals方法。

修改后的Student类如下：

[java] view plain copy

1. class Student {  
2.     private String name;  
3.     private int age;  
4.   
5.     Student(String name, int age) {  
6.         this.name = name;  
7.         this.age = age;  
8.     }  
9.   
10.     @Override  
11.     public String toString() {  
12.         return new StringBuilder().append("name:").append(name)  
13.                 .append("..age:").append(age).toString();  
14.     }  
15.   
16.     @Override  
17.     public int hashCode() {  
18.         final int prime = 31;  
19.         int result = 1;  
20.         result = prime * result + age;  
21.         result = prime * result + ((name == null) ? 0 : name.hashCode());  
22.         return result;  
23.     }  
24.   
25.     @Override  
26.     public boolean equals(Object obj) {  
27.         if (this == obj)  
28.             return true;  
29.         if (obj == null)  
30.             return false;  
31.         if (getClass() != obj.getClass())  
32.             return false;  
33.         Student other = (Student) obj;  
34.         if (age != other.age)  
35.             return false;  
36.         if (name == null) {  
37.             if (other.name != null)  
38.                 return false;  
39.         } else if (!name.equals(other.name))  
40.             return false;  
41.         return true;  
42.     }  
43. }  

TreeSet的基本使用

与HashSet一样，从命名我们就可以猜到：TreeSet内部的结构采用的是二叉树结构。

所谓的二叉树数据结构是指：每个结点最多有两个子树的有序树，子树有左右之分，次序不能颠倒。

TreeSet容器通过底层的二叉树保证数据唯一性的原理基本可以分析为：

当向TreeSet容器内添加进第一个元素，二叉树就在最顶端有了一个结点。

当插入第二个元素时，TreeSet就会用这第二个元素与该结点的元素进行比较。

假定该次插入的元素比上一个元素的结点小，就会被放在顶端节点的左子树上。而如果较大，则放在右子树上。

以此类推，当所有的元素完成存储，所有左边子树上的元素值都较小，右边则较大。

而比较结果为相同的元素则无法进入到该数据结构中。从而保证了数据的唯一性。

那么，同样以上面的需求为例，我们这次利用TreeSet写一个测试类：

[java] view plain copy

1. package com.tsr.j2seoverstudy.collection;  
2.   
3. import java.util.Set;  
4. import java.util.TreeSet;  
5.   
6. public class TreeSetDemo {    
7.     public static void main(String[] args) {    
8.         TreeSet<Student> set = new TreeSet<Student>();    
9.         set.add(new Student("张三", 19));  
10.         set.add(new Student("李四", 20));  
11.         set.add(new Student("张三", 19));  
12.           
13.         printSet(set);       
14.     }    
15.       
16.     static void printSet(Set<Student> set) {  
17.         for (Student student : set) {  
18.             System.out.println(student);  
19.         }  
20.     }  
21. }  

当我们再次运行程序，得到的信息是这样的：

没错，通过该异常打印信息我们能够读到的是：自定义的Student类不能转换为Comparable。

也就是说我们定义的该类不具备比较性。我们已经说过了，二叉树结果会针对元素进行比较。

根据结果决定其是否进入该结构，或者应当排在左边子树还是右边子树。那么，自然就应该有一个比较的方式。

而TreeSet容器对元素进行比较的方式有两种：

• 让存储的元素所属类实现Comparable接口，并覆写compareTo()方法。
• 新建比较器类，实现Comparatorj接口，并覆写compare()方法。将比较器对象作为TreeSet的构造器的参数传递给TreeSet对象
  

假设我们选用第一种方式对Student类进行修改：

[java] view plain copy

1. package com.tsr.j2seoverstudy.collection;  
2.   
3. import java.util.TreeSet;  
4. import java.util.Set;  
5.   
6. /* 
7.  * 输出结果为： 
8.  * name:张三..age:19 
9.  * name:张三..age:19 
10.  * name:李四..age:20 
11.  */  
12. public class HashSetDemo {  
13.     public static void main(String[] args) {  
14.         TreeSet<Student> set = new TreeSet<Student>();  
15.         set.add(new Student("张三", 19));  
16.         set.add(new Student("李四", 20));  
17.         set.add(new Student("张三", 19));  
18.           
19.         printSet(set);  
20.     }  
21.   
22.     static void printSet(Set<Student> set) {  
23.         for (Student student : set) {  
24.             System.out.println(student);  
25.         }  
26.     }  
27. }  
28.   
29. class Student implements Comparable<Student>{  
30.     private String name;  
31.     private int age;  
32.   
33.     Student(String name, int age) {  
34.         this.name = name;  
35.         this.age = age;  
36.     }  
37.   
38.     @Override  
39.     public String toString() {  
40.         return new StringBuilder().append("name:").append(name)  
41.                 .append("..age:").append(age).toString();  
42.     }  
43.   
44.     @Override  
45.     public int hashCode() {  
46.         final int prime = 31;  
47.         int result = 1;  
48.         result = prime * result + age;  
49.         result = prime * result + ((name == null) ? 0 : name.hashCode());  
50.         return result;  
51.     }  
52.   
53.     @Override  
54.     public boolean equals(Object obj) {  
55.         if (this == obj)  
56.             return true;  
57.         if (obj == null)  
58.             return false;  
59.         if (getClass() != obj.getClass())  
60.             return false;  
61.         Student other = (Student) obj;  
62.         if (age != other.age)  
63.             return false;  
64.         if (name == null) {  
65.             if (other.name != null)  
66.                 return false;  
67.         } else if (!name.equals(other.name))  
68.             return false;  
69.         return true;  
70.     }  
71.   
72.     @Override  
73.     public int compareTo(Student s) {  
74.         int temp = this.age - s.age;    
75.         return temp == 0 ? this.name.compareTo(s.name) : temp;    
76.     }  
77. }  

我们实现的compareTo方法的含义在于：先通过年龄进行比较，如果两个对象的年龄相同，则再通过姓名进行比较。

注：compareTo方法返回的是一个int型的值，该值代表的含义是：负数代表小于，0代表对象相等，正数代表大于。

而此时运行main方法得到的输出结果为：

name:张三..age:19
name:李四..age:20

可以发现相对于HashSet来说，TreeSet除了保持了元素的唯一性之外。

还可以按照我们定义的比较方法，来保证元素的顺序。

例如上面例子中实现的compareTo方法正是：让元素按照年龄从小到大的顺序排序；

如果年龄相同，则按照姓名字母从小到大的顺序排序。

Map接口的常用操作

我们已经说过，Map体系与Collection体系最大的不同之处就在于：不再采用单值，而是采用键值对的方式存储元素。

也就是说，除开存储对象本身之外，还给每个对象关联了一张“身份证”，这张“身份证”就是所谓的“键”。

那么，对应的其对于元素的操作方法，自然也就有了不同。Map接口常用的方法为：

添加：

• V put(K key,V value); //将指定的值与此映射中的指定键关联，如果此映射以前包含一个该键的映射关系，则用该指定值覆盖旧值。返回前一个和key关联的值，如果没有返则回null.
• void putAll(Map<? extends K,? extend V> m)//从指定映射中将所有映射关系复制到此映射中.

删除：

• V remove(Object key); //如果存在一个键的映射关系，则将其从此映射中移除
• void clear(); //从此映射中移除所有映射关系

判断：

• boolean containsKey(Object key);  //判断是否存在对应的键的映射关系。如果包含，则返回 true
  
• boolean containsValue(Object value); //判断是否该map内是否有一个或多个键映射到该指定值，如果有，则返回true.
• boolean isEmpty(); //如果此映射未包含任何键-值映射关系，则返回 true

获取：

• V get(Obejct key);//获取该指定键所映射的值，如果此映射不包含该键的映射关系，则返回null
• Set<K> keySet();  //获取该map内包含的所有键的set视图
• Set<Map.Entry<K,V>> entrySet(); //获取该map内包含的所有映射关系的set视图
• Collection<V> values(); //获取该map内包含的所有值的collection视图。
• int size();             //获取该map内所包含的映射关系的总数，如果该映射包含的元素大于 Integer.MAX_VALUE，则返回 Integer.MAX_VALUE

可以通过一个例子，来简单的看一下对于Map容器的常用操作：

[java] view plain copy

1. public class MapDemo {    
2.     
3.     public static void main(String[] args) {    
4.         Map<String, Integer> map = new HashMap<String, Integer>();    
5.         //存储    
6.         map.put("张三", 19);    
7.         map.put("李四", 18);    
8.         System.out.println(map);    
9.         //获取    
10.         System.out.println("size:"+map.size());    
11.         Set<String> nameSet = map.keySet();    
12.         for (Iterator<String> it = nameSet.iterator(); it.hasNext(); ) {    
13.             System<span style="font-size:12px;">.</span>out.println(map.get(it.next()));    
14.         }    
15.             
16.         Set<Map.Entry<String, Integer>> set = map.entrySet();    
17.         for (Iterator<Map.Entry<String, Integer>> it = set.iterator(); it.hasNext(); ) {    
18.             Entry<String, Integer> entry = it.next();    
19.             String name = entry.getKey();    
20.             Integer age = entry.getValue();    
21.             System.out.println("name:"+name+"..age:"+age);    
22.         }    
23.             
24.         Collection<Integer> values = map.values();    
25.         for (Iterator<Integer> it = values.iterator(); it.hasNext(); ) {    
26.             System.out.println(it.next());    
27.         }    
28.         //删除    
29.         System.out.println("..."+map.remove("张三"));    
30.     }    
31. }    

关于Map容器的使用，可能值得注意的就是：

1.取出数据时，是根据键获取该键映射的值。

2.Map容器本身无法进行迭代，但可以：

  通过keySet()方法获取该容器内所有键的Set视图进行迭代；

  通过entrySet()方法获取该容器内所有映射关系的Set视图进行迭代；

  通过values()方法获取该容器内所有值的Collection视图进行迭代；

3.通过命名，就可以猜想到。与HashSet与TreeSet的使用相同。

  在通过该HashMap与TreeMap的时候，请不要忘记覆写hashcode、equals方法和添加实现比较器接口.

总结

所谓的集合框架，究其根本其实都是对于对象数据的一个存储容器。

之所分离出如此之多的不同容器，原因也是因为根据实际需求提供不同特性的容器。

而之所各个容器类之间具备不同的特性，也正是因为它们底层采用了不同的数据结构实现。

正如前面谈到过的一样，如果你暂时不想或者没有经理去更深一步的了解不同数据结构的具体实现。

那么针对于集合框架中不同容器类的使用，应该掌握的重点就是，它们各自不同的特性。

因为只有掌握了其各自的优劣点，就可以根据实际的需求选择最合适的容器来使用。

前面对于最常用的各种容器的特点都做了一个说明，而对于容器类的选择技巧，其实简单归纳就是：

1、思考你是只需要保存单个的值，还是希望以键值对(字典)的形式保存数据。

   如果存储单值，则选用Collection；如果存储字典，则选用Map。

2、选用Collection体系时，思考你存储的数据是否需要保证唯一性？

   如果需要，则选用Set。如果不需要，则选用List。

2.1、如果选用的是List，则考虑元素是否涉及到频繁的增删操作。

     如果是，则选用LinkedList；如果不是，则选用ArrayList。

2.2、如果选用的是Set，则考虑是否需要指定存储顺序。

     如果是，则选用TreeSet；如果不是，则选用HashSet。

     另外一种情况，如果不需要自定义顺序，而希望让元素按存储的先后顺序排序，则可以直接选用LinkedHashSet。

3、当选用Map体系时，与Set的选择一样。

   如果需要按指定存储顺序，则选用TreeMap。如果不需要则选用HashMap。

   如果想让元素按照存储的先后顺序进行排列，则选用LinkedHashMap。