Java集合类总结
Posted
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java集合类总结相关的知识,希望对你有一定的参考价值。
集合类和接口之间的关系图,能够比较清楚的展示各个类和接口之间的关系(其中:点框为接口(...) 短横线框为抽象类(---) 实线为类)
上图可以看到:集合可以分成两部分来学习。一个是以Collection为顶层接口,这种集合是单值元素<value>。一个是以Map为顶层接口,这种结合是<key,value>形式。
List和Set
Collection接口下面直接继承的有抽象类 AbstractCollection和两个接口:List、Set
相同点:
1、提供大致相同的操作数据集合的方法,例如:add()、remove()、congtains()、size()等
不同点:
1、List元素可重复、元素有序(和添加顺序一致)、元素可为空
2、Set元素不可重复、元素无序、元素可为空
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分别使用两种方式。所以对于集合排序,二者都可以使用。
1 Comparator<? super K> cpr = comparator; 2 if (cpr != null) { 3 do { 4 parent = t; 5 cmp = cpr.compare(key, t.key); 6 if (cmp < 0) 7 t = t.left; 8 else if (cmp > 0) 9 t = t.right; 10 else 11 return t.setValue(value); 12 } while (t != null); 13 } 14 else { 15 if (key == null) 16 throw new NullPointerException(); 17 @SuppressWarnings("unchecked") 18 Comparable<? super K> k = (Comparable<? super K>) key; 19 do { 20 parent = t; 21 cmp = k.compareTo(t.key); 22 if (cmp < 0) 23 t = t.left; 24 else if (cmp > 0) 25 t = t.right; 26 else 27 return t.setValue(value); 28 } while (t != null); 29 }
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提供了几个操作集合对象的方法,同时提供了几个静态共有常量。
常量如下:
这些常量可以在参数判断时使用。例如:
1 Map getMap(String key){ 2 if(StringUtil.isEmpty(key)){ 3 return Collections.EMPTY_MAP; 4 } 5 ... ... 6 }
几个比较常用的方法:sort()、addAll()、isEmpty()等,重点看sort()方法
1 public static <T extends Comparable<? super T>> void sort(List<T> list) { 2 list.sort(null); 3 }
sort()方法主要用来对List排序,因为Set无序。
这里主要看对于ArrayList的排序。因为它比较常用。
1 public void sort(Comparator<? super E> c) { 2 final int expectedModCount = modCount; 3 Arrays.sort((E[]) elementData, 0, size, c); 4 if (modCount != expectedModCount) { 5 throw new ConcurrentModificationException(); 6 } 7 modCount++; 8 }
这里面调用了Arrays.sort()方法,点进去看到函数是这样的:
1 public static <T> void sort(T[] a, int fromIndex, int toIndex, 2 Comparator<? super T> c) { 3 if (c == null) { 4 sort(a, fromIndex, toIndex); 5 } else { 6 rangeCheck(a.length, fromIndex, toIndex); 7 if (LegacyMergeSort.userRequested) 8 legacyMergeSort(a, fromIndex, toIndex, c); 9 else 10 TimSort.sort(a, fromIndex, toIndex, c, null, 0, 0); 11 } 12 }
这里看到,如果是LegacyMergeSort.userRequested
1 static final class LegacyMergeSort { 2 private static final boolean userRequested = 3 java.security.AccessController.doPrivileged( 4 new sun.security.action.GetBooleanAction( 5 "java.util.Arrays.useLegacyMergeSort")).booleanValue(); 6 }
这里理解为是一个配置,通过传参数来设置使用传统的归并排序。否则的话,使用TimSort排序,这个是归并排序的优化版,也就是说,默认使用TimSort排序。
归并排序:大致思路就是先把待排序数组依次分解,然后递归两两组合排序,直至整个数组有序。时间复杂度O(N*logN).
下面两个图就比较直观反映了数据处理过程
Collection是个接口,然后JDK提供了Collections类来对接口通用方法进行操作。类似的还有Arrays工具类。以后自己在设计接口的时候也可以考虑此种方式。
源码-HashMap
HashMap源码关键点:
- 数组+链表(JDK1.7及以前)
- 数组+红黑树(JDK1.8)
- 一个元素的添加过程
- 线程不安全的解释
这里画一个图,有点不恰当的是Entry[]里面应该存放链表的第一个元素。这里直接画到了外面。
Entry数组结构如下:
1 static class Entry<K,V> implements Map.Entry<K,V> { 2 final K key; 3 V value; 4 Entry<K,V> next; 5 int hash; 6 }
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()方法的处理
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链中的一个节点,结构如下:
1 static final class HashEntry<K,V> { 2 final K key; 3 final int hash; 4 volatile V value; 5 volatile HashEntry<K,V> next; 6 }
在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操作进行分析和学习。
初始化
构造函数的源码如下:
1 public ConcurrentHashMap(int initialCapacity, 2 float loadFactor, int concurrencyLevel) { 3 if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0) 4 throw new IllegalArgumentException(); 5 if (concurrencyLevel > MAX_SEGMENTS) 6 concurrencyLevel = MAX_SEGMENTS; 7 // Find power-of-two sizes best matching argumentsint sshift = 0; 8 int ssize = 1; 9 while (ssize < concurrencyLevel) { 10 ++sshift; 11 ssize <<= 1; 12 } 13 this.segmentShift = 32 - sshift; 14 this.segmentMask = ssize - 1; 15 if (initialCapacity > MAXIMUM_CAPACITY) 16 initialCapacity = MAXIMUM_CAPACITY; 17 int c = initialCapacity / ssize; 18 if (c * ssize < initialCapacity) 19 ++c; 20 int cap = MIN_SEGMENT_TABLE_CAPACITY; 21 while (cap < c) 22 cap <<= 1; 23 // create segments and segments[0] 24 Segment<K,V> s0 = 25 new Segment<K,V>(loadFactor, (int)(cap * loadFactor), 26 (HashEntry<K,V>[])new HashEntry[cap]); 27 Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize]; 28 UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]this.segments = ss; 29 }
传入的参数有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大小。
containsValue
containsValue操作采用了和size操作一样的想法。
以上是关于Java集合类总结的主要内容,如果未能解决你的问题,请参考以下文章