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。
  1. 为每个内核均分任务,并保证其不小于16;
  2. 若nextTab为null,则初始化其为原table的2倍;
  3. 死循环遍历,直到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=(^(>>>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(longxintcheck)方法:
    ①利用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和setArrayList觉得优于LinkedList,因为LinkedList要移动指针。
       3.对于新增和删除操作add和removeLinedList比较占优势,因为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! 
将来的你一定会感激现在拼命的自己!

发布了140 篇原创文章 · 获赞 157 · 访问量 95万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 编程工作室 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览