Java集合类知识

Java 容器

（部分图片来源于cyc作者）

一、概览

容器主要包括 Collection 和 Map 两种，Collection 存储着对象的集合，而 Map 存储着键值对（两个对象）的映射表。

Collection

#### 1. Set

• TreeSet：基于红黑树实现，支持有序性操作，例如根据一个范围查找元素的操作。但是查找效率不如 HashSet，HashSet 查找的时间复杂度为 O(1)，TreeSet 则为 O(logN)。

• HashSet：基于哈希表实现，支持快速查找，但不支持有序性操作。并且失去了元素的插入顺序信息，也就是说使用 Iterator 遍历 HashSet 得到的结果是不确定的。

• LinkedHashSet：具有 HashSet 的查找效率，并且内部使用双向链表维护元素的插入顺序。

2. List

• ArrayList：基于动态数组实现，支持随机访问。

• Vector：和 ArrayList 类似，但它是线程安全的。

• LinkedList：基于双向链表实现，只能顺序访问，但是可以快速地在链表中间插入和删除元素。不仅如此，LinkedList 还可以用作栈、队列和双向队列。

3. Queue

• LinkedList：可以用它来实现双向队列。

• PriorityQueue：基于堆结构实现，可以用它来实现优先队列。

Map

- TreeMap：基于红黑树实现。

• HashMap：基于哈希表实现。

• HashTable：和 HashMap 类似，但它是线程安全的，这意味着同一时刻多个线程同时写入 HashTable 不会导致数据不一致。它是遗留类，不应该去使用它，而是使用 ConcurrentHashMap 来支持线程安全，ConcurrentHashMap 的效率会更高，因为 ConcurrentHashMap 引入了分段锁。

• LinkedHashMap：使用双向链表来维护元素的顺序，顺序为插入顺序或者最近最少使用（LRU）顺序。

二、容器中的设计模式

迭代器模式

Collection 继承了 Iterable 接口，其中的 iterator() 方法能够产生一个 Iterator 对象，通过这个对象就可以迭代遍历 Collection 中的元素。

从 JDK 1.5 之后可以使用 foreach 方法来遍历实现了 Iterable 接口的聚合对象。

List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
for (String item : list) {
   
    System.out.println(item);
}

适配器模式

java.util.Arrays#asList() 可以把数组类型转换为 List 类型。

@SafeVarargs
public static <T> List<T> asList(T... a)

应该注意的是 asList() 的参数为泛型的变长参数，不能使用基本类型数组作为参数，只能使用相应的包装类型数组。

Integer[] arr = {
   1, 2, 3};
List list = Arrays.asList(arr);

也可以使用以下方式调用 asList()：

List list = Arrays.asList(1, 2, 3);

三、ArrayList和Vector（重点）

ArrayList 是基于数组实现的，所以支持快速随机访问。RandomAccess 接口标识着该类支持快速随机访问。数组的默认大小为 10。

 //默认容量是10
 private static final int DEFAULT_CAPACITY = 10;

 //说明调用的是有参构造器，初始容量就是自己传的initialCapacity的值
 private static final Object[] EMPTY_ELEMENTDATA = {
   };

 //说明调的是无参构造器，默认容量是10(第1次添加元素时初始化容量为10)
 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {
   };

 transient Object[] elementData; // 实际存放元素的地方,transient该关键字声明数组默认不会被序列化。

**添加元素并且是否需要扩容：**

添加元素时使用 ensureCapacityInternal() 方法来保证容量足够，如果不够时，需要使用 grow() 方法进行扩容，新容量的大小为 oldCapacity + (oldCapacity >> 1)，即 oldCapacity+oldCapacity/2。其中 oldCapacity >> 1 需要取整，所以新容量大约是旧容量的 1.5 倍左右。（oldCapacity 为偶数就是 1.5 倍，为奇数就是1.5倍-0.5）

扩容操作需要调用 Arrays.copyOf() 把原数组整个复制到新数组中，这个操作代价很高，因此最好在创建 ArrayList 对象时就指定大概的容量大小，减少扩容操作的次数。

		 //添加
        public boolean add(E e) {
   
            ensureCapacityInternal(size + 1);  // Increments modCount!!
            elementData[size++] = e;
            return true;
        }

        private void ensureCapacityInternal(int minCapacity) {
   
            ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
        }

        private static int calculateCapacity(Object[] elementData, int minCapacity) {
   
            if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
   
                return Math.max(DEFAULT_CAPACITY, minCapacity); //如果是通过无参方式构造的 就直接把默认值（10）返回
            }
            return minCapacity; //否则就返回minCapacity
        }

        private void ensureExplicitCapacity(int minCapacity) {
   
            modCount++;  //modCount 用来记录 ArrayList 结构发生变化的次数。结构发生变化是指添加或者删除至少一个元素的所有操作，在进行序列化或者迭代等操作时，需要比较操作前后 modCount 是否改变，如果改变了需要抛出 ConcurrentModificationException。并发修改异常，而Vector是线程安全的 就不需要modCount
            if (minCapacity - elementData.length > 0)
                grow(minCapacity);
        }

         //开始进行扩容
        private void grow(int minCapacity) {
   
            int oldCapacity = elementData.length;//数组原长度
            int newCapacity = oldCapacity + (oldCapacity >> 1); //新长度=10+5=15 右移操作就是除2
            if (newCapacity - minCapacity < 0)  //如果新长度比需要的最小长度还小的话
                newCapacity = minCapacity;   //就把最小长度给新长度
            if (newCapacity - MAX_ARRAY_SIZE > 0) //MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; 如果新长度比int最大值还大
                newCapacity = hugeCapacity(minCapacity);
            // minCapacity is usually close to size, so this is a win:
            elementData = Arrays.copyOf(elementData, newCapacity);
        }
*/

删除元素:

需要调用 System.arraycopy() 将 index+1 后面的元素都复制到 index 位置上，该操作的时间复杂度为 O(N)，可以看到 ArrayList 删除元素的代价是非常高的。

public E remove(int index) {
   
    rangeCheck(index);
    modCount++;
    E oldValue = elementData(index);
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    elementData[--size] = null; // clear to let GC do its work
    return oldValue;
}

ArrayList它里面的clone()方法是深拷贝

假设B复制了A，修改A的时候，看B是否发生变化：
浅拷贝只是增加了一个指针指向已存在的内存地址
深拷贝是增加了一个指针并且申请了一个新的内存，使这个增加的指针指向这个新的内存，跟原对象是相互独立的

ArrayList的subList方法:subList方法只是保存了下标，新集合和原集合共用一个引用:

ArrayList<String> list = new ArrayList<>();
        list.add("e");
        list.add("1");
        list.add("2");
        list.add("3");
        List<String> strings = list.subList(0, 3);
        list.set(0,"6666");
        System.out.println(strings .get(0));//打印 6666  说明subList方法只是保存了下标，新集合和原集合共用一个引用

Arrays.asList方法：

Integer[] arr = {
   1, 2, 3};
//注意asList() 的参数不能使用基本类型数组作为参数，只能使用相应的包装类型数组。
//因为引用类型的数组，a=[]  基本类型数组:a= [long[] 会把他变成二维数组.
List list1 = Arrays.asList(arr);
S