Java集合类总结

集合类和接口之间的关系图，能够比较清楚的展示各个类和接口之间的关系（其中：点框为接口（...） 短横线框为抽象类（---） 实线为类）

上图可以看到:集合可以分成两部分来学习。一个是以Collection为顶层接口，这种集合是单值元素<value>。一个是以Map为顶层接口，这种结合是<key,value>形式。

List和Set

Collection接口下面直接继承的有抽象类 AbstractCollection和两个接口：List、Set

相同点：

 1、提供大致相同的操作数据集合的方法，例如：add()、remove()、congtains()、size()等

不同点：

1、List元素可重复、元素有序（和添加顺序一致）、元素可为空
2、Set元素不可重复、元素无序、元素可为空

思考:可空和不可为空的限定条件是什么？

 

List子类：ArrayList、LinkedList、Vector

ArrayList底层数据结构是数组，LinkedList底层数据结构是链表。Vecotor和ArrayList差不多，但是线程安全，这也就意味着它速率比ArrayList慢。

数组和链表的数据结构特点：

数组：下标访问，所以访问速度比较快，TC为O(1),插入的时候需要移动数据元素，插入慢。TC为O(n)

链表：插入速度快T(1)。只需要改变指针指向。访问慢O(n)，需要从头开始一个一个查找。

Set子类：HashSet、TreeSet

HashSet基于HashMap的key实现，元素不重复。TreeSet实现了SortedSet，基于TreeSet的key实现，意味着有序，当然也是不重复。

HashSet唯一性保证：

基于HashMap的key实现，当通过hash()方法计算出要插入的Entry[]数组的位置后，通过equals()方法来进行比较，equals()方法比较的是两个对象的引用是否相等，如果不相等，则插入，如果相等，则把这个值覆盖上一个。

TreeSet有序性保证：

如果简单类型，由于他们继承了Comparable，直接比较，如果为自定义对象，则需要显示实现Comparable，实现comparableTo()方法，方法内规则自己定义。

Map之HashMap和TreeMap

HashMap key和value值允许为空，key相同时，前者会覆盖后者，保持最新。

Comparable和Comparator

可以看到在TreeMap里面有两套比较的方法，分别使用了Comparable和Comparator。if...else分别使用两种方式。所以对于集合排序，二者都可以使用。

Comparator<? super K> cpr = comparator;
        if (cpr != null) {
            do {
                parent = t;
                cmp = cpr.compare(key, t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        else {
            if (key == null)
                throw new NullPointerException();
            @SuppressWarnings("unchecked")
                Comparable<? super K> k = (Comparable<? super K>) key;
            do {
                parent = t;
                cmp = k.compareTo(t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }

Comparable是在集合内部定义的方法的排序，像Integer,String等都会实现Comparable接口，所以天生具有可比较的属性。

Comparator是在集合外部定义的方法，如果排序规则不能满足需要，可以显示实现该接口，然后重写方法定义规则，当然重写Comparable也是可以的。

使用Comparator是策略模式，就是不改变策略本身，而是通过一个策略对象来改变他的行为。（策略模式需要复习）

比较两个对象的值，使用两种接口的实现方式如下：

Comparable

int result = person1.comparTo(person2)

Comparator

PersonComparator   comparator=   new   PersonComparator();
comparator.compare(person1,person2);

Collections

Collections是一个类，区别于Collection接口。Collections提供了几个操作集合对象的方法，同时提供了几个静态共有常量。

常量如下：

 这些常量可以在参数判断时使用。例如：

Map getMap(String key){
        if(StringUtil.isEmpty(key)){
            return Collections.EMPTY_MAP;
        }
... ...
}

几个比较常用的方法：sort()、addAll()、isEmpty()等，重点看sort()方法

public static <T extends Comparable<? super T>> void sort(List<T> list) {
        list.sort(null);
}

sort()方法主要用来对List排序，因为Set无序。

这里主要看对于ArrayList的排序。因为它比较常用。

public void sort(Comparator<? super E> c) {
        final int expectedModCount = modCount;
        Arrays.sort((E[]) elementData, 0, size, c);
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        modCount++;
    }

这里面调用了Arrays.sort（）方法，点进去看到函数是这样的：

public static <T> void sort(T[] a, int fromIndex, int toIndex,
                                Comparator<? super T> c) {
        if (c == null) {
            sort(a, fromIndex, toIndex);
        } else {
            rangeCheck(a.length, fromIndex, toIndex);
            if (LegacyMergeSort.userRequested)
                legacyMergeSort(a, fromIndex, toIndex, c);
            else
                TimSort.sort(a, fromIndex, toIndex, c, null, 0, 0);
        }
    }

这里看到，如果是LegacyMergeSort.userRequested

static final class LegacyMergeSort {
        private static final boolean userRequested =
            java.security.AccessController.doPrivileged(
                new sun.security.action.GetBooleanAction(
                    "java.util.Arrays.useLegacyMergeSort")).booleanValue();
    }

这里理解为是一个配置，通过传参数来设置使用传统的归并排序。否则的话，使用TimSort排序，这个是归并排序的优化版，也就是说，默认使用TimSort排序。

归并排序：大致思路就是先把待排序数组依次分解，然后递归两两组合排序，直至整个数组有序。时间复杂度O(N*logN).

下面两个图就比较直观反映了数据处理过程

Collection是个接口，然后JDK提供了Collections类来对接口通用方法进行操作。类似的还有Arrays工具类。以后自己在设计接口的时候也可以考虑此种方式。

源码-HashMap

HashMap源码关键点：

• 数组+链表（JDK1.7及以前）
• 数组+红黑树（JDK1.8）
• 一个元素的添加过程
• 线程不安全的解释

1、数组+链表（JDK1.7及以前）

 这里画一个图，有点不恰当的是Entry[]里面应该存放链表的第一个元素。这里直接画到了外面。

Entry数组结构如下：

static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        int hash;
}

2、数组+红黑树（JDK1.8）

3、一个元素的添加过程

HashMap的特点是key不能重复，key-value值均可为空，如果key为null,hash值返回0。有一个地方需要注意的是：key相等和key通过hash之后相等的区别。也就是说，如果key1=key2，那么通过hash之后的值也相等，插入同一个Entry数组对应的下标中。然后会通过equals()方法判断二者是否相等，如果相等，则后者覆盖前者保持最新。如果不相等，则把该元素插入到Entry元素根节点位置，原节点往后移动作为该节点的下一个节点或者子节点（对于树）。

4、线程不安全的地方

(1)put操作

当有A、B两个线程Hash之后同时到达Entry数组的下表 i 时，就有可能出现问题。先来看一下一个线程hash之后的插入操作，其实就是一个链表的插入过程。

详细步骤：

        1.oldValue = Entity[4];

        2.Entity[4] = newValue;

        3.newValue.next = oldValue;

那么在多线程操作情况下，可能线程1在“2”步执行完成后，还没执行“3”步时，线程2执行了containsKey方法，这时就取不到"oldValue"。再过几毫秒去看，又有"oldValue"了。

(2)resize操作

一个线程在hash找下标，一个在扩容，出现问题。

源码-ConcurrentHashMap

ConcurrentHashMap源码关键点：

• 它是线程安全的，如何保证
• 分段锁相比Hashtable整个Synchronized方法的优势
• 分段锁的时候，size()方法的处理

ConcurrentHashMap和Hashtble的key和value值都是不能为空的，源码中put操作时首行有为空判断

if (key == null || value == null) throw new NullPointerException();

Hashtable是线程安全的，保证线程安全的方法是在每个方法上面加上Synchronize。

synchronized int size();
synchronized boolean isEmpty();
... ...

相比Hashtable，ConcurrentHashMap采用了分段锁（Segment）来保证线程安全性。每个段相当于是一个小的Hashtable。但同时会存在多个Segment(默认16)，这样，每个段之间的操作是真正的并发而彼此之间不受影响。

 从上图可以看到：一个ConcurrentHashMap包含多个segment，每个segment都是一把锁，对应一段table（这个table就是HashMap的结构，由HashBucket【hash桶】和HashEntry组成）。各个segment之间是彼此独立的。每个Segment均继承了可重复锁ReetrantLock

static final class Segment<K,V> extends ReentrantLock implements Serializable

Segment下面包含很多歌HashEntry列表数组。对于一个key,需要经过三次hash操作，才能最终定位这个元素的位置。三次hash分别是：

1、对于一个key，先进行一次hash操作，得到hash值h1，即h1=hash1(key);

2、将得到的h1的高几位进行第二次hash，得到hash值h2，即h2=hash2(h1高几位)，通过h2能确定该元素放在哪个Segment中；

3、将得到的h1进行hash，得到hash值h3，即h3=hash3（h1）,通过h3能够确定该元素放置在哪个HashEntry。

CoucurrentHashMap中主要实体类就三个：ConcurrentHashMap(整个Hash表)，Segment(片段)，HashEntry(节点)

不变（Immutable）和易变（Volatile）

ConcurrentHashMap允许多个读操作并发进行，读操作不需要加锁。如果使用传统的技术，如HashMap中的实现，如果允许可以在hash链的中间添加或删除元素，读操作将得到不一致的数据。ConcurrentHashMap实现技术是保证HashEntry几乎是不可变的。HashEntry代表每个hash链中的一个节点，结构如下：

static final class HashEntry<K,V> {  
     final K key;  
     final int hash;  
     volatile V value;  
     volatile HashEntry<K,V> next;  
 }

在JDK1.6中，HashEntry中的next指针也定义为final，并且每次插入将添加新节点作为链的头节点，每次删除节点时，会将删除节点之前（这里指时间的前后，不是指位置）的所有节点拷贝一份组成一个新的链，而将当前节点的上一个节点的next指针指向当前节点的下一个节点，从而在删除之后有两条链存在，因而可以保证即使在同一条链中，有一个线程正在删除，而另一个线程正在遍历，他们都能工作良好，因为遍历的线程能继续使用原有的链。因而这是一种更加细粒度的happens-before关系，即如果遍历线程在删除线程结果后开始，则它能看到删除后的变化，如果它发生在删除线程正在执行中间，则它会使用原有的链，而不会等到删除线程结束执行后再执行，也就是说，这种情况下遍历线程看不到删除线程的影响。而HashMap中的Entry只有key是final的

static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        int hash;
}

不变模式是多线程安全里最简单的一种保障方式。因为你拿他没有办法，想改变它也没有机会。

不变模式主要通过final关键字来限定。Final域使得确保初始化安全性成为可能。

下面主要通过对ConcurrentHashMap的初始化、put操作、get操作、size操作和containsValue操作进行分析和学习。

 

初始化

构造函数的源码如下：

public ConcurrentHashMap(int initialCapacity,
                             float loadFactor, int concurrencyLevel) {
        if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
            throw new IllegalArgumentException();
        if (concurrencyLevel > MAX_SEGMENTS)
            concurrencyLevel = MAX_SEGMENTS;
        // Find power-of-two sizes best matching argumentsint sshift = 0;
        int ssize = 1;
        while (ssize < concurrencyLevel) {
            ++sshift;
            ssize <<= 1;
        }
        this.segmentShift = 32 - sshift;
        this.segmentMask = ssize - 1;
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        int c = initialCapacity / ssize;
        if (c * ssize < initialCapacity)
            ++c;
        int cap = MIN_SEGMENT_TABLE_CAPACITY;
        while (cap < c)
            cap <<= 1;
        // create segments and segments[0]
        Segment<K,V> s0 =
            new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
                             (HashEntry<K,V>[])new HashEntry[cap]);
        Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
        UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]this.segments = ss;
    }

传入的参数有initialCapacity（初始容量）,loadFactor（负载因子）,concurrencyLevel（并发级别）三个参数。

1、initialCapacity指的是ConcurrentHashMap中每条链中的Entry的数量。默认值static final int DEFAULT_INITIAL_CAPACITY = 16;

2、loadFactor表示负载因子，当ConcurrentHashMap中元素大于loadFactor*最大容量时需要扩容。（最大容量=每条链的entry格式*Entry的数组长度）

3、concurrencyLevel（并发级别）用来确定Segment的个数，Segment的个数是大于等于concurrencyLevel的第一个2的n次方的数。比如，如果concurrencyLevel为12,13,14，则segment的数目就为16（2的四次方）。默认值static final int DEFAULT_CONCURRENCY_LEVEL = 16。理想情况下ConcurrentHashMap的真正的并发访问量能够达到concurrencyLevel（这种情况就是访问的数据恰好分别落在不同的Segment中，而这些线程能够无竞争的自由访问）

 

put操作

put操作的源码如下：

public V put(K key, V value) {
      Segment<K,V> s;
      if (value == null)
          throw new NullPointerException();
      int hash = hash(key);
      int j = (hash >>> segmentShift) & segmentMask;
      if ((s = (Segment<K,V>)UNSAFE.getObject          // nonvolatile; recheck
           (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment
          s = ensureSegment(j);
      return s.put(key, hash, value, false);
  }

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
            HashEntry<K,V> node = tryLock() ? null :
                scanAndLockForPut(key, hash, value);
            V oldValue;
            try {
                HashEntry<K,V>[] tab = table;
                int index = (tab.length - 1) & hash;
                HashEntry<K,V> first = entryAt(tab, index);
                for (HashEntry<K,V> e = first;;) {
                    if (e != null) {
                        K k;
                        if ((k = e.key) == key ||
                            (e.hash == hash && key.equals(k))) {
                            oldValue = e.value;
                            if (!onlyIfAbsent) {
                                e.value = value;
                                ++modCount;
                            }
                            break;
                        }
                        e = e.next;
                    }
                    else {
                        if (node != null)
                            node.setNext(first);
                        else
                            node = new HashEntry<K,V>(hash, key, value, first);
                        int c = count + 1;
                        if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                            rehash(node);
                        elsesetEntryAt(tab, index, node);
                        ++modCount;
                        count = c;
                        oldValue = null;
                        break;
                    }
                }
            } finally {
                unlock();
            }
            return oldValue;
        }

put操作需要加锁。

 

get操作

get操作不需要加锁（如果value为null，会调用readValueUnderLock，只有这个步骤会加锁），通过volatile和final来确保数据安全。

 

size()操作

size()操作与put和get操作的最大区别在于，size操作需要遍历所有的Segment才能算出整个Map的大小，而put和get只关系一个Segment。假设我们当前遍历的Segment为SA，那么在遍历SA过程中其他的Segment比如SB可能会被修改，于是这一次运算出来的size值可能并不是Map当前的真正大小。一个比较简单的办法就是计算Map大小的时候所有的Segment都LOCK住，不能更新（包括put，removed等）数据，计算完之后再UNLOCK。这是普通人所能想到的方案，但是牛逼的作者还有一个更好的Idea:先给3次机会，不lock所有的segment,遍历所有segment,累加各个segment的大小得到整个Map大小，如果某相邻的两次计算获取的所有Segment的更新次数（每个Segment都有一个modCount变量，这个变量在Segment中的Entry被修改时会加1，通过这个值可以得到每个Segment的更新操作的次数）是一样的，说明计算过程中没有更新操作（至少从查看Map的大小方向来看没有变化），则直接返回这个值。如果这三次不加锁的计算过程中Map的更新次数有变化，则之后的计算先对所有的Segment加锁，再遍历所有Segment计算Map的大小，最后再解锁所有的Segment。源代码如下：

public int size() {
        // Try a few times to get accurate count. On failure due to// continuous async changes in table, resort to locking.final Segment<K,V>[] segments = this.segments;
        int size;
        boolean overflow; // true if size overflows 32 bitslong sum;         // sum of modCountslong last = 0L;   // previous sumint retries = -1; // first iteration isn't retrytry {
            for (;;) {
                if (retries++ == RETRIES_BEFORE_LOCK) {
                    for (int j = 0; j < segments.length; ++j)
                        ensureSegment(j).lock(); // force creation
                }
                sum = 0L;
                size = 0;
                overflow = false;
                for (int j = 0; j < segments.length; ++j) {
                    Segment<K,V> seg = segmentAt(segments, j);
                    if (seg != null) {
                        sum += seg.modCount;
                        int c = seg.count;
                        if (c < 0 || (size += c) < 0)
                            overflow = true;
                    }
                }
                if (sum == last)
                    break;
                last = sum;
            }
        } finally {
            if (retries > RETRIES_BEFORE_LOCK) {
                for (int j = 0; j < segments.length; ++j)
                    segmentAt(segments, j).unlock();
            }
        }
        return overflow ? Integer.MAX_VALUE : size;
    }

举个栗子：

一个Map中有四个Segment,标记为S1,S2,S3,S4。现在我们要获取Map的size。计算过程是这样的：

• 第一次计算，不对S1,S2,S3,S4加锁，遍历所有的Segment,假设每个Segment的大小分别为1,2,3,4，更新操作次数分为别2,2,3,1,则这次计算可以得到Map的总大小为1+2+3+4=10，总共更新次数为8；
• 第二次计算，不对S1,S2,S3,S4加锁，遍历所有的Segment,假设这次每个Segemnt的大小变成了2，2,3,4，更新次数分别为3,2,3,1，因为两次计算得到的Map更新次数不一致（第一次是8，第二次是9），则可以断定这段时间Map数据被更新。
• 第三次计算，不对S1,S2，S3,S4加锁，遍历所有的Segment，假设每个Segment的更新操作次数还是3,2,3，1，则因为第二次计算和第三次计算得到的Map更新次数是一致的，就能说明第二次计算和第三次计算这段时间内Map数据没有被更新，此时可以直接返回第三次计算得到的Map大小。

最坏的情况：第三次计算得到的数据更新次数和第二次计算也不一样，则只能先对所有的Segment加锁再计算最后解锁。

containsValue

containsValue操作采用了和size操作一样的想法。