Java集合大整理

此处为整理，更详细的源码分析请查阅 JDK源码分析其他文章。

为了适应csdn的窗口大小，表格严重变形了。。。

	null	值重复	底层实现	扩容	增、删、迭代	包含	备注
HashSet	允许，just 1个	no	HashMap	同HashMap	【add】：调用HashMap的put方法，put的value传入伪值static final Object PRESENT = new Object()，仅仅为了保持映射关系；（所有value都是同一个对象） 【remove】：调map的remove	有contains， 无get	HashMap中的Key是根据对象的hashCode() 和 euqals()来判断是否唯一的。 So：为了保证HashSet中的对象不会出现重复值，在被存放元素的类中必须要重写hashCode()和equals()这两个方法。
TreeSet	No， add-null空指针异常	no	【TreeMap】， 实现了NavigableMap接口, 一种SortedMap	树结构，无扩容一说	add调用TreeMap的put方法，同样有PRESENT； remove方法。	有contains， 无get	默认使用元素的自然顺序对元素进行排序； 可重写compare方法实现对象的自定义排序。
EnumSet	No， add-null空指针异常	no	long（数组）、 位运算	Enum元素固定，无扩容	add：数组赋值； remove：置null	有contains， 无get	判断是否包含null和removenull无异常；remove-null时返回false
EnumMap	No， add-null空指针异常； value可以为null	key不重复	transient数组	Enum元素固定，无扩容	put：数组赋值； remove：置null	containsKey； containsValue。	创建时必须指定key类型； 元素顺序为Enum的顺序； 迭代时不会抛出ConcurrentModificationException； NULL和null的区别。
HashMap	key、value均允许null， 但key仅允许1个null。	key不重复， value可以	位桶+链表/红黑树	size > tab.length*threshold; newCap = oldCap<<1； 新容量：2倍扩容	put、remove； 迭代时remove抛ConcurrentModificationException；注意正确迭代方式	containsKey； containsValue。
LinkedHashMap	同HashMap	同HashMap	HashMap+双向链表	同HashMap	put、remove；	注意get模式； contains调用HashMap的containsKey； containsValue（遍历链表）	像hashMap一样用table储存元素【桶位依旧分散，和HashMap的存放位置相同】，put时直接调用的是HashMap的put方法。
TreeMap	Key不允许null； value允许。	同HashMap
ArrayList	允许null，随意	允许重复	数组	初始容量10， grow1.5倍		contains判断元素存在
LinkedList	同ArrayList	同ArrayList	基于链表的数据结构		remove只移除第一个； 迭代时remove抛ConcurrentModificationException（有特例，元素个数<=2）；	有contains，get
ConcurrentHashMap	key、value均不允许，put-null空指针异常；	同HashMap	HashMap+CAS无锁算法	实际容量>=sizeCtl，则扩容	用foreach迭代，Map定义时必须制定key-value类型，否则cant convert	containsKey、 containsValue
	允许null：HashMap和以其为底层结构的非同步集合；List	ArrayList相关

有序：
    先说明有序的概念：迭代输出和存入顺序一致即为有序（可以理解为先进先出FIFO）（注：Java8支持list逆序迭代，我们讨论有序时忽略这个）
    不要和TreeSet弄混了，TreeSet所谓的“有序”，指的是内部存储结构有特定的存储规则，它默认使用元素的自然顺序对元素进行排序，却打乱了元素的存入顺序。So，严格来讲，TreeSet是无序的。
随机访问：
    即使用[]操作符访问其中的元素。

EnumMap：

Set keySet = enumMap.keySet();
Iterator iteKey = keySet.iterator();
while(iteKey.hasNext()){
    Object object =(Object) iteKey.next();
    System.out.print(object +"="+ enumMap.get(object)+";
");
}
Collection<Object> vals = enumMap.values();
Set<Entry<Season, Object>> entrySet = enumMap.entrySet();

HashMap：

当某个桶中的键值对数量大于8个【9个起】，且桶数量大于等于64，则将底层实现从链表转为红黑树 ；
int threshold; // 新的扩容resize临界值,当实际大小(容量*填充比)大于临界值时，会进行2倍扩容；
key是有可能是null的，并且会在0桶位位置；
tableSizeFor(int cap) { //计算下次需要调整大小的扩容resize临界值；结果为>=cap的最小2的自然数幂（64-》64；65-》128）
 length为2的整数幂保证了length - 1 最后一位（二进制表示）为1，从而保证了索引位置index即（ hash &length-1）的最后一位同时有为0和为1的可能性，保证了散列的均匀性。length为2的幂保证了按位与最后一位的有效性，使哈希表散列更均匀。
resize】时【链表】的变化： 元素位置在【原位置】或【原位置+oldCap】
链表转红黑树后，【仅在扩容resize时】若树变短，会恢复为链表。

LinkedHashMap：
remove后再put，集合结构变化：只要未冲突，table不改变（想想put原理就好理解了）；但链表改变，新元素始终在tail。
显式地指定为access order后【前提】，调用get()方法，导致对应的entry移动到双向链表的最后位置（tail），但是table未没变。
So LinkedHashMap元素有序存放，但并不保证其迭代顺序一直不变
LinkedHashMap的每个bucket都存了这个bucket的before和after，且每个before(after)又存储了自身的前驱后继，直到null。

迭代：
    Iterator<Map.Entry> iterl = map.entrySet().iterator();

    利用ArrayList的【ListIterator】向前迭代：
        ListIterator<Map.Entry> iterpre = new ArrayList<Map.Entry>(map.entrySet()).listIterator(map.size());
        while (iterpre.hasPrevious()) {……}

ArrayList：
int newCapacity = oldCapacity + (oldCapacity >> 1);//1.5倍(15 >> 1=7) 扩容是大约1.5倍扩容，HashMap则是刚好2倍扩容。
add(int index, E element)；将当前处于该位置的元素（如果有的话）和所有后续元素向后移动（其索引加 1）【System.arraycopy】。
trimToSize()去掉预留元素的位置，返回一个新数组，新数组不含null，数组的size和elementData.length相等，以节省空间。此函数可避免size很小但elementData.length很大的情况。
不建议使用contains(Object o)方法，看源码就知道了，调用其内置的indexOf方法，for循环一个个equals，这效率只能呵呵哒了，建议使用hashcode。
remove： 首先判断要remove的元素是null还是非null，然后for循环查找，核心是fastRemove(index)方法。 fastRemove并不返回被移除的元素。  elementData[--size]
= null;因为arraycopy方法是将elementData的index+1处开始的元素往前复制，也就是说最后一个数本该消除，但还在那里，所以需要置空。
subList方法得到的subList将和原来的list互相影响，不管你改哪一个，另一个都会随之改变，而且当父list结构改变时，子list会抛ConcurrentModificationException异常。解决方案：List<String> subListNew = new ArrayList(parentList.subList(1, 3));【类似Arrays.asList()方法】
ConcurrentHashMap：

CAS算法；unsafe.compareAndSwapInt(this, valueOffset, expect, update);  CAS(Compare And Swap)，意思是如果valueOffset位置包含的值与expect值相同，则更新valueOffset位置的值为update，并返回true，否则不更新，返回false。
与Java8的HashMap有相通之处，底层依然由“数组”+链表+红黑树；
底层结构存放的是TreeBin对象，而不是TreeNode对象；
CAS作为知名无锁算法，那ConcurrentHashMap就没用锁了么？当然不是，hash值相同的链表的头结点还是会synchronized上锁。 

private transient volatile int sizeCtl;
sizeCtl是控制标识符，不同的值表示不同的意义。
负数代表正在进行初始化或扩容操作 
-1代表正在初始化 
-N 表示有N-1个线程正在进行扩容操作 
正数或0代表hash表还没有被初始化，这个数值表示初始化或下一次进行扩容的大小，类似于扩容阈值。它的值始终是当前ConcurrentHashMap容量的0.75倍，这与loadfactor是对应的。实际容量>=sizeCtl，则扩容。

 concurrencyLevel：
    能够同时更新ConccurentHashMap且不产生锁竞争的最大线程数，在Java8之前实际上就是ConcurrentHashMap中的分段锁个数，即Segment[]的数组长度。正确地估计很重要，当低估，数据结构将根据额外的竞争，从而导致线程试图写入当前锁定的段时阻塞；相反，如果高估了并发级别，你遇到过大的膨胀，由于段的不必要的数量; 这种膨胀可能会导致性能下降，由于高数缓存未命中。

        在Java8里，仅仅是为了兼容旧版本而保留。唯一的作用就是保证构造map时初始容量不小于concurrencyLevel。
ForwardingNode：

 
  并不是我们传统的包含key-value的节点，只是一个标志节点，并且指向nextTable，提供find方法而已。生命周期：仅存活于扩容操作且bin不为null时，一定会出现在每个bin的首位。

3个原子操作（调用频率很高）

static final <K,V>
Node<K,V> tabAt(Node<K,V>[] tab, int i)
{ // 获取索引i处Node
    return (Node<K,V>)U.getObjectVolatile(tab,
((long)i << ASHIFT)
+ ABASE);
    }
    // 利用CAS算法设置i位置上的Node节点（将c和table[i]比较，相同则插入v）。
    static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
                                        Node<K,V> c,
Node<K,V> v)
{
        return U.compareAndSwapObject(tab,
((long)i << ASHIFT)
+ ABASE, c, v);
    }
    // 设置节点位置的值，仅在上锁区被调用
    static final <K,V> void setTabAt(Node<K,V>[] tab, int i,
Node<K,V> v) {
        U.putObjectVolatile(tab,
((long)i << ASHIFT)
+ ABASE, v);
    }
ConcurrentHashMap无锁多线程扩容，减少扩容时的时间消耗。
transfer扩容操作：单线程构建两倍容量的nextTable；允许多线程复制原table元素到nextTable。
为每个内核均分任务，并保证其不小于16；
若nextTab为null，则初始化其为原table的2倍；
死循环遍历，直到finishing。
节点为空，则插入ForwardingNode；
链表节点（fh>=0），分别插入nextTable的i和i+n的位置；【逆序链表？？】
TreeBin节点（fh<0），判断是否需要untreefi，分别插入nextTable的i和i+n的位置；【逆序树？？】
finishing时，nextTab赋给table，更新sizeCtl为新容量的0.75倍 ，完成扩容。

以上说的都是单线程，多线程又是如何实现的呢？
       遍历到ForwardingNode节点((fh = f.hash) == MOVED)，说明此节点被处理过了，直接跳过。这是控制并发扩容的核心 。由于给节点上了锁，只允许当前线程完成此节点的操作，处理完毕后，将对应值设为ForwardingNode（fwd），其他线程看到forward，直接向后遍历。如此便完成了多线程的复制工作，也解决了线程安全问题。

2、 put相关：

理一下put的流程：
①判空：null直接抛空指针异常；
②hash：计算h=key.hashcode；调用spread计算hash=(h ^(h >>>16))& HASH_BITS；
③遍历table

若table为空，则初始化，仅设置相关参数；
@@@计算当前key存放位置，即table的下标i=(n - 1) & hash；
若待存放位置为null，casTabAt无锁插入；
若是forwarding nodes（检测到正在扩容），则helpTransfer（帮助其扩容）；
else（待插入位置非空且不是forward节点，即碰撞了），将头节点上锁（保证了线程安全）：区分链表节点和树节点，分别插入（遇到hash值与key值都与新节点一致的情况，只需要更新value值即可。否则依次向后遍历，直到链表尾插入这个结点）；
若链表长度>8，则treeifyBin转树（Note：若length<64,直接tryPresize,两倍table.length;不转树）。
④addCount(1L, binCount)。

Note：
1、put操作共计两次hash操作，再利用“与&”操作计算Node的存放位置。

2、ConcurrentHashMap不允许key或value为null。
3、addCount(longx, intcheck)方法：
    ①利用CAS快速更新baseCount的值；
    ②check>=0.则检验是否需要扩容；if sizeCtl<0（正在进行初始化或扩容操作）【nexttable null等情况break；如果有线程正在扩容，则协助扩容】；else if 仅当前线程在扩容，调用协助扩容函数，注其参数nextTable为null。

 以下为引用： 

java提高篇（二十）-----集合大家族：http://demo.netfoucs.com/chenssy/article/details/17732841

    6.1、Vector和ArrayList

       1，vector是线程同步的，所以它也是线程安全的，而arraylist是线程异步的，是不安全的。如果不考虑到线程的安全因素，一般用arraylist效率比较高。
       2，如果集合中的元素的数目大于目前集合数组的长度时，vector增长率为目前数组长度的100%,而arraylist增长率为目前数组长度的50%.如过在集合中使用数据量比较大的数据，用vector有一定的优势。
       3，如果查找一个指定位置的数据，vector和arraylist使用的时间是相同的，都是0(1),这个时候使用vector和arraylist都可以。而如果移动一个指定位置的数据花费的时间为0(n-i)n为总长度，这个时候就应该考虑到使用linklist,因为它移动一个指定位置的数据所花费的时间为0(1),而查询一个指定位置的数据时花费的时间为0(i)。

       ArrayList 和Vector是采用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，都允许直接序号索引元素，但是插入数据要设计到数组元素移动等内存操作，所以索引数据快插入数据慢，Vector由于使用了synchronized方法（线程安全）所以性能上比ArrayList要差，LinkedList使用双向链表实现存储，按序号索引数据需要进行向前或向后遍历，但是插入数据时只需要记录本项的前后项即可，所以插入数度较快！

      6.2、Aarraylist和Linkedlist

       1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
       2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
       3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

这一点要看实际情况的。若只对单条数据插入或删除，ArrayList的速度反而优于LinkedList。但若是批量随机的插入删除数据，LinkedList的速度大大优于ArrayList. 因为ArrayList每插入一条数据，要移动插入点及之后的所有数据。

      6.3、HashMap与TreeMap

       1、HashMap通过hashcode对其内容进行快速查找，而TreeMap中所有的元素都保持着某种固定的顺序，如果你需要得到一个有序的结果你就应该使用TreeMap（HashMap中元素的排列顺序是不固定的）。HashMap中元素的排列顺序是不固定的）。

       2、 HashMap通过hashcode对其内容进行快速查找，而TreeMap中所有的元素都保持着某种固定的顺序，如果你需要得到一个有序的结果你就应该使用TreeMap（HashMap中元素的排列顺序是不固定的）。集合框架提供两种常规的Map实现：HashMap和TreeMap
(TreeMap实现SortedMap接口)。

       3、在Map 中插入、删除和定位元素，HashMap 是最好的选择。但如果您要按自然顺序或自定义顺序遍历键，那么TreeMap会更好。使用HashMap要求添加的键类明确定义了hashCode()和 equals()的实现。 这个TreeMap没有调优选项，因为该树总处于平衡状态。

      6.4、hashtable与hashmap

       1、历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现 。

       2、同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的 。

       3、值：只有HashMap可以让你将空值作为一个表的条目的key或value 。

       七、对集合的选择

      7.1、对List的选择

       1、对于随机查询与迭代遍历操作，数组比所有的容器都要快。所以在随机访问中一般使用ArrayList

       2、LinkedList使用双向链表对元素的增加和删除提供了非常好的支持，而ArrayList执行增加和删除元素需要进行元素位移。

       3、对于Vector而已，我们一般都是避免使用。

       4、将ArrayList当做首选，毕竟对于集合元素而已我们都是进行遍历，只有当程序的性能因为List的频繁插入和删除而降低时，再考虑LinkedList。

      7.2、对Set的选择

       1、HashSet由于使用HashCode实现，所以在某种程度上来说它的性能永远比TreeSet要好，尤其是进行增加和查找操作。

       3、虽然TreeSet没有HashSet性能好，但是由于它可以维持元素的排序，所以它还是存在用武之地的。

欢迎个人转载，但须在文章页面明显位置给出原文连接；
未经作者同意必须保留此段声明、不得随意修改原文、不得用于商业用途，否则保留追究法律责任的权利。

【 CSDN 】：csdn.zxiaofan.com
【GitHub】：github.zxiaofan.com

如有任何问题，欢迎留言。祝君好运！
Life is all about choices！
将来的你一定会感激现在拼命的自己！