此处为整理,更详细的源码分析请查阅 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相关
|
|
|
|
|
|
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 ();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。
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,则扩容。
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);
}
- 为每个内核均分任务,并保证其不小于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倍 ,完成扩容。
- 若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;不转树)。
以下为引用:
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性能好,但是由于它可以维持元素的排序,所以它还是存在用武之地的。