java基础之集合

本文部分转载之http://blog.csdn.net/zhangerqing/article/details/8122075

集合类简介
数组是很常用的一种的数据结构，我们用它可以满足很多的功能，但是，有时我们会遇到如下这样的问题：
1、 我们需要该容器的长度是不确定的。
2、 我们需要它能自动排序。
3、 我们需要存储以键值对方式存在的数据。
如果遇到上述的情况，数组是很难满足需求的，接下来本章将介绍另一种与数组类似的数据结构——集合类，集合类在Java中有很重要的意义，保存临时数据，管理对象，泛型，Web框架等，很多都大量用到了集合类。

集合类框架如下图所示

下面的表格也许可以更直接的表现出他们之间的区别和联系：

接口	简述	实现	操作特性	成员要求
Set	成员不能重复	HashSet	外部无序地遍历成员	成员可为任意Object子类的对象，但如果覆盖了equals方法，同时注意修改hashCode方法。
		TreeSet	外部有序地遍历成员；附加实现了SortedSet, 支持子集等要求顺序的操作	成员要求实现caparable接口，或者使用 Comparator构造TreeSet。成员一般为同一类型。
		LinkedHashSet	外部按成员的插入顺序遍历成员	成员与HashSet成员类似
List	提供基于索引的对成员的随机访问	ArrayList	提供快速的基于索引的成员访问，对尾部成员的增加和删除支持较好	成员可为任意Object子类的对象
		LinkedList	对列表中任何位置的成员的增加和删除支持较好，但对基于索引的成员访问支持性能较差	成员可为任意Object子类的对象
Map	保存键值对成员，基于键找值操作，compareTo或compare方法对键排序	HashMap	能满足用户对Map的通用需求	键成员可为任意Object子类的对象，但如果覆盖了equals方法，同时注意修改hashCode方法。
		TreeMap	支持对键有序地遍历，使用时建议先用HashMap增加和删除成员，最后从HashMap生成TreeMap；附加实现了SortedMap接口，支持子Map等要求顺序的操作	键成员要求实现caparable接口，或者使用Comparator构造TreeMap。键成员一般为同一类型。
		LinkedHashMap	保留键的插入顺序，用equals 方法检查键和值的相等性	成员可为任意Object子类的对象，但如果覆盖了equals方法，同时注意修改hashCode方法。
		IdentityHashMap	使用== 来检查键和值的相等性。	成员使用的是严格相等
		WeakHashMap	其行为依赖于垃圾回收线程，没有绝对理由则少用

（上图来源于网友的总结，已不知是哪位的原创，恕不贴出地址，如原作者看到请联系我，必将贴出链接！）

实现Collection接口的类，如Set和List，他们都是单值元素（其实Set内部也是采用的是Map来实现的，只是键值一样，从表面理解，就是单值），不像实现Map接口的类一样，里面存放的是key-value(键值对)形式的数据。这方面就造成他们很多的不同点，如遍历方式，前者只能采用迭代或者循环来取出值，但是后者可以使用键来获得值得值。

比较（性能，功能方面）
这一块主要就是对我们平时接触的这些集合类做一个简单的总结，一方面有助于自己整理思路，再者面试的时候，面试官总喜欢问一些他们之间的区别，凡是Java面试，几乎都要问到集合类的东西，问的形式有两种：一、总体介绍下集合类有哪些。这个问题只要把我上文中的图介绍一下就行了。二、比较一下XXX和XXXX。当然了，肯定包括相同点和不同的地方。这个稍微麻烦一点，需要我们彻底理解了，才能回答的比较准确。以下是我对常被比较的一些类的分析：
1、HashMap和HashTable
      相同点：二者都实现了Map接口，因此具有一系列Map接口提供的方法。
      不同点：
            1、HashMap继承了AbstractMap，而HashTable继承了Dictionary。
            2、HashMap非线程安全，HashTable线程安全，到处都是synchronized关键字。
            3、因为HashMap没有同步，所以处理起来效率较高。
            4、HashMap键、值都允许为null，HashTable键、值都不允许有null。
            5、HashTable使用Enumeration，HashMap使用Iterator。
      这些就是一些比较突出的不同点，实际上他们在实现的过程中会有很多的不同，如初始化的大小、计算hash值的方式等等。毕竟这两个类包含了很多方法，有很重要的功能，所以其他不同点，请感兴趣的读者自己去看源码，去研究。笔者推荐使用HashMap，因为她提供了比HashTable更多的方法，以及较高的效率，如果大家需要在多线程环境中使用，那么用Collections类来做一下同步即可。
2、Set接口和List接口
  相同点：都实现了Collection接口
  不同点：
       1、Set接口不保证维护元素的顺序，而且元素不能重复。List接口维护元素的顺序，而且元素可以重复。
       2、关于Set元素如何保证元素不重复，将在下面的博文中给出。
3、ArrayList和LinkList
     相同点：都实现了Collection接口
     不同点：ArrayList基于数组，具有较高的查询速度，而LinkedList基于双向循环列表，具有较快的添加或者删除的速度，二者的区别，其实就是数组和列表的区别。
4、SortedSet和SortedMap
     二者都提供了排序的功能。 来看一个小例子：
    SortedMap<String, Integer> map = new TreeMap<>();
    map.put("zgg", 1);
    map.put("erqing", 3);
    map.put("niu", 0);
    map.put("abc", 2);
    map.put("aaa", 5);
    Set<String> keySet = map.keySet();
    for (String string : keySet) {
        System.out.print(map.get(string) + " ");
    }
    // 5 2 3 0 1  按照key排序了
    从结果看得出：SortedMap具有自动排序功能
5、TreeMap和HashMap
     HashMap具有较高的速度(查询)，TreeMap则提供了按照键进行排序的功能。
6、HashSet和LinkedHashSet
     HashSet，为快速查找而设计的Set。存入HashSet的对象必须实现hashCode()和equals()。
     LinkedHashSet，具有HashSet的查询速度，且内部使用链表维护元素的顺序(插入的次序)，于是在使用迭代器遍历Set时，结果会按元素插入的次序显示。
7、TreeSet和HashSet
     TreeSet: 提供排序功能的Set，底层为树结构 。相比较HashSet其查询速度低，如果只是进行元素的查询，我们一般使用HashSet。
8、ArrayList和Vector
    同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的。
    数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半
9、Collection和Collections
    Collection是一系列单值集合类的父接口，提供了基本的一些方法，而Collections则是一系列算法的集合。里面的属性和方法基本都是static的，也就是说我们不需要实例化，直接可以使用类名来调用。

常见问题

1、Set集合如何保证对象不重复

[java]  view plain  copy

1. Set集合不允许有重复出现的对象，且最终的判断是根据equals()的。其实原理是这样的：  
2. HashSet的add方法  
3. public boolean add(E e) {  
4.     return map.put(e, PRESENT)==null;  
5. }  
6. HashSet添加方法的底层采用HashMap来存放数据，HashMap的put()方法是这样的：  
7. public V put(K key, V value) {  
8.     if (table == EMPTY_TABLE) {  
9.         inflateTable(threshold);  
10.     }  
11.     if (key == null)  
12.         return putForNullKey(value);  
13.     int hash = hash(key); --------1 计算出hashcode  
14.     int i = indexFor(hash, table.length); --------2 计算出这个元素的存储位置  
15.     for (Entry<K,V> e = table[i]; e != null; e = e.next) { --------3   
16.         Object k;  
17.         if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {  
18.             V oldValue = e.value;  
19.             e.value = value;  
20.             e.recordAccess(this);  
21.             return oldValue;  
22.         }  
23.     } ------4  
24.     modCount++;  
25.     addEntry(hash, key, value, i);  
26.     return null;  
27. }  
28. 解释说明：当向HashMap中添加元素的时候，首先计算元素的hashcode值，然后根据1处的代码计算出Hashcode的值，再根据2处的代码计算出这个元素的存储位置，如果这个位置为空，就将元素添加进去；如果不为空，则看3-4的代码，遍历索引为i的链上的元素，如果key重复，则替换并返回oldValue值。  

2、集合类排序问题

[html]  view plain  copy

1. 一种情况是集合类本身自带排序功能，如前面说过的TreeSet、SortedSet、SortedMap等，另一种就是本身不带排序功能，我们通过为需要排序的类实现Comparable或者Comparator接口来实现。  
2. Comparable和Comparator都是用来实现集合中元素的比较、排序的。  
3. Comparable是在集合内部定义的方法实现的排序，位于java.lang下。  
4. Comparator是在集合外部实现的排序，位于java.util下。  
5. Comparable是一个对象本身就已经支持自比较所需要实现的接口，如String、Integer自己就实现了Comparable接口，可完成比较大小操作。自定义类要在加入list容器中后能够排序，也可以实现Comparable接口，在用Collections类的sort方法排序时若不指定Comparator，那就以自然顺序排序。所谓自然顺序就是实现Comparable接口设定的排序方式。  
6. Comparator是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足要求时，可写一个比较器来完成两个对象之间大小的比较。Comparator体现了一种策略模式(strategy design pattern)，就是不改变对象自身，而用一个策略对象(strategy object)来改变它的行为。  
7. 总而言之Comparable是自已完成比较，Comparator是外部程序实现比较。  

[java]  view plain  copy

1. a. Comparator 和 Comparable 相同的地方  
2. 他们都是java的一个接口, 并且是用来对自定义的class比较大小的,  
3. 什么是自定义class: 如 public class Person{ String name; int age }.  
4. 当我们有这么一个personList,里面包含了person1, person2, persion3....., 我们用Collections.sort( personList ),   
5. 是得不到预期的结果的. 这时肯定有人要问, 那为什么可以排序一个字符串list呢:  
6. 如 StringList{"hello1" , "hello3" , "hello2"}, Collections.sort( stringList ) 能够得到正确的排序, 那是因为   
7. String 这个对象已经帮我们实现了 Comparable接口 , 所以我们的 Person 如果想排序, 也要实现一个比较器。  
8.   
9. b. Comparator 和 Comparable 的区别  
10.   
11. Comparable  
12. Comparable 定义在 Person类的内部:  
13. public class Persion implements Comparable {..比较Person的大小..},  
14.  因为已经实现了比较器,那么我们的Person现在是一个可以比较大小的对象了,它的比较功能和String完全一样,可以随时随地的拿来  
15. 比较大小,因为Person现在自身就是有大小之分的。Collections.sort(personList)可以得到正确的结果。  
16. Comparator  
17. Comparator 是定义在Person的外部的, 此时我们的Person类的结构不需要有任何变化,如  
18. public class Person{ String name; int age },  
19. 然后我们另外定义一个比较器:  
20. public PersonComparator implements Comparator() {..比较Person的大小..},  
21. 在PersonComparator里面实现了怎么比较两个Person的大小. 所以,用这种方法,当我们要对一个 personList进行排序的时候,   
22. 我们除了了要传递personList过去, 还需要把PersonComparator传递过去,因为怎么比较Person的大小是在PersonComparator  
23. 里面实现的, 如:  
24. Collections.sort( personList , new PersonComparator() ).  
25.   
26. c. Comparator 和 Comparable 的实例  
27.   
28. Comparable:  
29. 实现Comparable接口要覆盖compareTo方法, 在compareTo方法里面实现比较：  
30. public class Person implements Comparable {  
31.      String name;  
32.      int age  
33.      public int compareTo(Person another) {  
34.           int i = 0;  
35.           i = name.compareTo(another.name); // 使用字符串的比较  
36.           if(i == 0) { // 如果名字一样,比较年龄, 返回比较年龄结果  
37.                return age - another.age;  
38.           } else {  
39.                return i; // 名字不一样, 返回比较名字的结果.  
40.           }  
41.      }  
42. }  
43.    这时我们可以直接用 Collections.sort( personList ) 对其排序了.  
44.   
45. Comparator:  
46.   
47. 实现Comparator需要覆盖 compare 方法：  
48. public class Person{  
49.      String name;  
50.      int age  
51. }  
52.   
53. class PersonComparator implements Comparator {   
54.      public int compare(Person one, Person another) {  
55.           int i = 0;  
56.           i = one.name.compareTo(another.name); // 使用字符串的比较  
57.           if(i == 0) { // 如果名字一样,比较年龄,返回比较年龄结果  
58.                return one.age - another.age;  
59.           } else {  
60.                return i; // 名字不一样, 返回比较名字的结果.  
61.           }  
62.      }  
63. }  
64.    Collections.sort( personList , new PersonComparator()) 可以对其排序  
65.   
66.  d:总结  
67. 两种方法各有优劣, 用Comparable 简单, 只要实现Comparable 接口的对象直接就成为一个可以比较的对象,  
68. 但是需要修改源代码, 用Comparator 的好处是不需要修改源代码, 而是另外实现一个比较器, 当某个自定义  
69. 的对象需要作比较的时候,把比较器和对象一起传递过去就可以比大小了, 并且在Comparator 里面用户可以自  
70. 己实现复杂的可以通用的逻辑,使其可以匹配一些比较简单的对象,那样就可以节省很多重复劳动了。  

3、使用for循环删除元素陷阱

[java]  view plain  copy

1. List<String> list2 = new LinkedList<>();  
2.         list2.add("1");  
3.         list2.add("21");  
4.         list2.add("31");  
5.         for (int i = 0; i < list2.size(); i++) {  
6.             list2.remove(i);  
7.         }  
8.         for (String s : list2) {  
9.             System.out.println("s = [" + s + "]");  
10.         }  
11.         //s = [21] 每次删除完后，i减少1分部分析下这个程序，当地一步remove完后，集合内还剩2个元素，此时i为1，而list.size()的值为2，从0开始的话，i为1时，正好指向第二个元素，也就是说当remove完A后，直接就跳到C，将B漏了。  
12.         for (String s : list2) {  
13.             if("1".equals(s)){  
14.                 list2.remove(s);//推荐使用  
15.             }  
16.         }  

4、Java集合的遍历 （一下转载之https://www.cnblogs.com/leskang/p/6031282.html）

集合类的通用遍历方式, 用迭代器迭代:

Iterator it = list.iterator();

while(it.hasNext()) {

　　Object obj = it.next();

}

Map遍历方式：

1、通过获取所有的key按照key来遍历

//Set<Integer> set = map.keySet(); //得到所有key的集合
for (Integer in : map.keySet()) {
    String str = map.get(in);//得到每个key多对用value的值
}

2、通过Map.entrySet使用iterator遍历key和value

Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();
while (it.hasNext()) {
     Map.Entry<Integer, String> entry = it.next();
       System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}

3、通过Map.entrySet遍历key和value，推荐，尤其是容量大时

for (Map.Entry<Integer, String> entry : map.entrySet()) {
    //Map.entry<Integer,String> 映射项（键-值对）  有几个方法：用上面的名字entry
    //entry.getKey() ;entry.getValue(); entry.setValue();
    //map.entrySet()  返回此映射中包含的映射关系的 Set视图。
    System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}

4、通过Map.values()遍历所有的value，但不能遍历key

for (String v : map.values()) {
    System.out.println("value= " + v);
}

List遍历方式：

第一种：

for(Iterator iterator = list.iterator();iterator.hasNext();){                    
    int i = (Integer) iterator.next();                   
    System.out.println(i);               
}

第二种：

Iterator iterator = list.iterator();
while(iterator.hasNext()){
    int i = (Integer) iterator.next();
    System.out.println(i);
}

第三种：

for (Object object : list) { 
    System.out.println(object); 
}

第四种：

for(int i = 0 ;i<list.size();i++) {  
    int j= (Integer) list.get(i);
    System.out.println(j);  
}

数据元素是怎样在内存中存放的？

  主要有2种存储方式：

1、顺序存储，Random Access（Direct Access）：

        这种方式，相邻的数据元素存放于相邻的内存地址中，整块内存地址是连续的。可以根据元素的位置直接计算出内存地址，直接进行读取。读取一个特定位置元素的平均时间复杂度为O(1)。正常来说，只有基于数组实现的集合，才有这种特性。Java中以ArrayList为代表。

2、链式存储，Sequential Access：

        这种方式，每一个数据元素，在内存中都不要求处于相邻的位置，每个数据元素包含它下一个元素的内存地址。不可以根据元素的位置直接计算出内存地址，只能按顺序读取元素。读取一个特定位置元素的平均时间复杂度为O(n)。主要以链表为代表。Java中以LinkedList为代表。

 

每个遍历方法的实现原理是什么？

  1、传统的for循环遍历，基于计数器的：

        遍历者自己在集合外部维护一个计数器，然后依次读取每一个位置的元素，当读取到最后一个元素后，停止。主要就是需要按元素的位置来读取元素。

2、迭代器遍历，Iterator：

        每一个具体实现的数据集合，一般都需要提供相应的Iterator。相比于传统for循环，Iterator取缔了显式的遍历计数器。所以基于顺序存储集合的Iterator可以直接按位置访问数据。而基于链式存储集合的Iterator，正常的实现，都是需要保存当前遍历的位置。然后根据当前位置来向前或者向后移动指针。

3、foreach循环遍历：

        根据反编译的字节码可以发现，foreach内部也是采用了Iterator的方式实现，只不过Java编译器帮我们生成了这些代码。

各遍历方式对于不同的存储方式，性能如何？

1、传统的for循环遍历，基于计数器的：

        因为是基于元素的位置，按位置读取。所以我们可以知道，对于顺序存储，因为读取特定位置元素的平均时间复杂度是O(1)，所以遍历整个集合的平均时间复杂度为O(n)。而对于链式存储，因为读取特定位置元素的平均时间复杂度是O(n)，所以遍历整个集合的平均时间复杂度为O(n2)（n的平方）。

ArrayList按位置读取的代码：直接按元素位置读取。

transient Object[] elementData;

public E get(int index) {
    rangeCheck(index);
    return elementData(index);
}

E elementData(int index) {
    return (E) elementData[index];
}

LinkedList按位置读取的代码：每次都需要从第0个元素开始向后读取。其实它内部也做了小小的优化。

transient int size = 0;
transient Node<E> first;
transient Node<E> last;

public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

Node<E> node(int index) {
    if (index < (size >> 1)) {   //查询位置在链表前半部分，从链表头开始查找
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {                     //查询位置在链表后半部分，从链表尾开始查找
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
} 

  2、迭代器遍历，Iterator：

        那么对于RandomAccess类型的集合来说，没有太多意义，反而因为一些额外的操作，还会增加额外的运行时间。但是对于Sequential Access的集合来说，就有很重大的意义了，因为Iterator内部维护了当前遍历的位置，所以每次遍历，读取下一个位置并不需要从集合的第一个元素开始查找，只要把指针向后移一位就行了，这样一来，遍历整个集合的时间复杂度就降低为O(n)；

（这里只用LinkedList做例子）LinkedList的迭代器，内部实现，就是维护当前遍历的位置，然后操作指针移动就可以了：

代码：

public E next() {
    checkForComodification();
    if (!hasNext())
        throw new NoSuchElementException();

    lastReturned = next;
    next = next.next;
    nextIndex++;
    return lastReturned.item;
}

public E previous() {
    checkForComodification();
    if (!hasPrevious())
        throw new NoSuchElementException();

    lastReturned = next = (next == null) ? last : next.prev;
    nextIndex--;
    return lastReturned.item;
}

3、foreach循环遍历：

        分析Java字节码可知，foreach内部实现原理，也是通过Iterator实现的，只不过这个Iterator是Java编译器帮我们生成的，所以我们不需要再手动去编写。但是因为每次都要做类型转换检查，所以花费的时间比Iterator略长。时间复杂度和Iterator一样。

Iterator和foreach字节码如下：

//使用Iterator的字节码：
    Code:
       0: new           #16                 // class java/util/ArrayList
       3: dup
       4: invokespecial #18                 // Method java/util/ArrayList."<init>":()V
       7: astore_1
       8: aload_1
       9: invokeinterface #19,  1           // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;
      14: astore_2
      15: goto          25
      18: aload_2
      19: invokeinterface #25,  1           // InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
      24: pop
      25: aload_2
      26: invokeinterface #31,  1           // InterfaceMethod java/util/Iterator.hasNext:()Z
      31: ifne          18
      34: return
//使用foreach的字节码：
    Code:
       0: new           #16                 // class java/util/ArrayList
       3: dup
       4: invokespecial #18                 // Method java/util/ArrayList."<init>":()V
       7: astore_1
       8: aload_1
       9: invokeinterface #19,  1           // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;
      14: astore_3
      15: goto          28
      18: aload_3
      19: invokeinterface #25,  1           // InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
      24: checkcast     #31                 // class loop/Model
      27: astore_2
      28: aload_3
      29: invokeinterface #33,  1           // InterfaceMethod java/util/Iterator.hasNext:()Z
      34: ifne          18
      37: return

各遍历方式的适用于什么场合？

1、传统的for循环遍历，基于计数器的：

        顺序存储：读取性能比较高。适用于遍历顺序存储集合。

        链式存储：时间复杂度太大，不适用于遍历链式存储的集合。

2、迭代器遍历，Iterator：

        顺序存储：如果不是太在意时间，推荐选择此方式，毕竟代码更加简洁，也防止了Off-By-One的问题。

        链式存储：意义就重大了，平均时间复杂度降为O(n)，还是挺诱人的，所以推荐此种遍历方式。

3、foreach循环遍历：

        foreach只是让代码更加简洁了，但是他有一些缺点，就是遍历过程中不能操作数据集合（删除等），所以有些场合不使用。而且它本身就是基于Iterator实现的，但是由于类型转换的问题，所以会比直接使用Iterator慢一点，但是还好，时间复杂度都是一样的。所以怎么选择，参考上面两种方式，做一个折中的选择。

Java的最佳实践是什么？

Java数据集合框架中，提供了一个RandomAccess接口，该接口没有方法，只是一个标记。通常被List接口的实现使用，用来标记该List的实现是否支持Random Access。

一个数据集合实现了该接口，就意味着它支持Random Access，按位置读取元素的平均时间复杂度为O(1)。比如ArrayList。

而没有实现该接口的，就表示不支持Random Access。比如LinkedList。

所以看来JDK开发者也是注意到这个问题的，那么推荐的做法就是，如果想要遍历一个List，那么先判断是否支持Random Access，也就是 list instanceof RandomAccess。

比如：

if (list instanceof RandomAccess) {
    //使用传统的for循环遍历。
} else {
    //使用Iterator或者foreach。
}