Java集合类

关注

原创最新推荐文章于 2026-03-31 10:19:41 发布 848 阅读 AI 写同款· GEO 优化 ›

Java集合类框架学习 2 —— ArrayList(JDK1.8/JDK1.7/JDK1.6) 这一篇开始说ArrayList 参考代码为jdk1.6_45 jdk1.7_80 jdk1.8_111中的源码，对比阅读，发现修改的问题以及改进点 public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, java.io.Serializable 一、基本性质阅读详情

Java集合类

集合的基础关系图

Iterator
└Collection
 ├List
 │├LinkedList
 │├ArrayList
 │└Vector
 │　└Stack
 ├Set
 ├Queue
 └Map
   ├Hashtable
   ├HashMap
   └WeakHashMap

Collection是集合接口:

Set子接口:无序，不允许重复
List子接口:有序，可以有重复元素
Map子接口:无序，key不能重复，vlue可以重复

Iterator：只能正向遍历集合，适用于获取移除元素。
ListIerator：继承Iterator，可以双向列表的遍历，同样支持元素的修改。

这里写图片描述

上述类图中，实线边框的是实现类，比如ArrayList，LinkedList，HashMap等，折线边框的是抽象类，比如AbstractCollection，AbstractList，AbstractMap等，而点线边框的是接口，比如Collection，Iterator，List等。

发现一个特点，上述所有的集合类，都实现了Iterator接口，这是一个用于遍历集合中元素的接口，主要包含 hashNext(),next(),remove()三种方法。它的一个子接口LinkedIterator在它的基础上又添加了三种方法，分别是 add(),previous(),hasPrevious()。也就是说如果是先Iterator接口，那么在遍历集合中元素的时候，只能往后遍历，被遍历后的元素不会在遍历到，通常无序集合实现的都是这个接口，比如HashSet，HashMap；而那些元素有序的集合，实现的一般都是 LinkedIterator接口，实现这个接口的集合可以双向遍历，既可以通过next()访问下一个元素，又可以通过previous()访问前一个元素，比如ArrayList。

还有一个特点就是抽象类的使用。如果要自己实现一个集合类，去实现那些抽象的接口会非常麻烦，工作量很大。这个时候就可以使用抽象类，这些抽象类中给我们提供了许多现成的实现，我们只需要根据自己的需求重写一些方法或者添加一些方法就可以实现自己需要的集合类，工作流昂大大降低

各个常用集合的特性描述如下
这里写图片描述

Collection接口

我单独拷贝一部分内容如下：

/*
* it provides implementations of more
* specific subinterfaces like <tt>Set</tt> and <tt>List</tt>. 
*/
public interface Collection<E> extends Iterable<E> {

//Omit other methods 省略其他方法 

}

List

1 ArrayList

特点

以数组实现。节约空间，但数组有容量限制，默认初始化容量为10。超出限制时会增加50%容量，不是线程安全的。

用System.arraycopy（）复制到新的数组。因此最好能给出数组大小的预估值。
特点：ArrayList内部使用数组进行数据存储transient Object[] elementData，默认初始化容量为10，
private static final int DEFAULT_CAPACITY = 10;

 private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

2 LinkedList

特点

内部使用Node内部类进行数据存储，以双向链表实现。无容量限制，但双向链表本身使用了更多空间。添加删除速度快，查找速度慢。不是线程安全的。

每插入一个元素都要构造一个额外的Node对象，也需要额外的链表指针操作。

private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

按下标访问元素－get（i）、set（i,e）要悲剧的部分遍历链表将指针移动到位（如果i>数组大小的一半，会从末尾移起）。

插入、删除元素时修改前后节点的指针即可，不再需要复制移动。但还是要部分遍历链表的指针才能移动到下标所指的位置。

只有在链表两头的操作－add（）、addFirst（）、removeLast（）或用iterator（）上的remove（）倒能省掉指针的移动。

Apache Commons 有个TreeNodeList，里面是棵二叉树，可以快速移动指针到位。

3.Vector

特点

Vector内部使用数组进行数据存储，是线程安全的。由于每个方法都加锁，性能低，不建议使用

public synchronized void addElement(E obj) {
    modCount++;
    ensureCapacityHelper(elementCount + 1);
    elementData[elementCount++] = obj;
}

4 CopyOnWriteArrayList

特点

并发优化的ArrayList,线程安全的，写速度慢，修改数据会增加容量开销。

基于不可变对象策略，在修改时先复制出一个数组快照来修改，改好了，再让内部指针指向新数组。

因为对快照的修改对读操作来说不可见，所以读读之间不互斥，读写之间也不互斥，只有写写之间要加锁互斥。但复制快照的成本昂贵，典型的适合读多写少的场景。

虽然增加了addIfAbsent（e）方法，会遍历数组来检查元素是否已存在，性能可想像的不会太好。

5 List遗憾

无论哪种实现，按值返回下标contains（e）, indexOf（e）, remove（e）都需遍历所有元素进行比较，性能可想像的不会太好。

没有按元素值排序的SortedList。

除了CopyOnWriteArrayList，再没有其他线程安全又并发优化的实现如ConcurrentLinkedList。凑合着用Set与Queue中的等价类时，会缺少一些List特有的方法如get（i）。如果更新频率较高，或数组较大时，还是得用Collections.synchronizedList（list），对所有操作用同一把锁来保证线程安全。

Map

Map属于key-value数据结构

HashMap

特点

HashMap。不是线程安全的。HashMap允许null为key。
在JDK1.8之前，HashMap采用数组+链表实现，JDK1.8中，HashMap采用数组+链表+红黑树实现
参考资料：JDK1.8 HashMap源码分析
在这里插入图片描述
jdk1.8之前的结构图由table和链表组成
注意：同一个hash桶中的最新数据插入时是插在最前面的，即途中链表的最下面，而它的末节点总是指向数组中的下标的数据位置（这个地方可以根据源码找到规律）

以Entry[]数组实现的哈希桶数组，用Key的哈希值取模桶数组的大小可得到数组下标。

插入元素时，如果两条Key落在同一个桶（比如哈希值1和17取模16后都属于第一个哈希桶），我们称之为哈希冲突。JDK的做法是链表法，Entry用一个next属性实现多个Entry以单向链表存放。查找哈希值为17的key时，先定位到哈希桶，然后链表遍历桶里所有元素，逐个比较其Hash，如果相同则覆盖，不同则在头节点指向当前这个新节点完成插入。

链表仍然有个问题，那就是如果hash相同的链表很长了的话，逐个查找就很浪费时间，那么在数据结构中我们知道有二叉树查找，它显然要比全部对比一遍要快很多，所以在JDK8里，新增默认为8的阈值，当一个桶里的Entry超过閥值，就不以单向链表而以红黑树来存放，以加快Key值落在同一个哈希桶中的数据查找速度。（JDK8 hashMap源码解读：https://blog.youkuaiyun.com/v123411739/article/details/78996181）
在这里插入图片描述
如上图，7的hash桶中的链表长度未达到阈值时仍然是链表结构，但是3对应的链表长度达到了阈值则转换成为了红黑树结构（关于红黑树我会在后面的数据结构中单独讲解）

当然，最好还是桶里只有一个元素，不用去比较。所以默认当Entry数量达到桶数量的75%时，哈希冲突已比较严重，就会成倍扩容桶数组，并重新分配所有原来的Entry。扩容成本不低，所以也最好有个预估值。

确定哈希桶数组索引位置

不管增加、删除、查找键值对，定位到哈希桶数组的位置都是很关键的第一步。前面说过HashMap的数据结构是数组和链表的结合，所以我们当然希望这个HashMap里面的元素位置尽量分布均匀些，尽量使得每个位置上的元素数量只有一个，那么当我们用hash算法求得这个位置的时候，马上就可以知道对应位置的元素就是我们要的，不用遍历链表，大大优化了查询的效率。HashMap定位数组索引位置，直接决定了hash方法的离散性能。先看看源码的实现(方法一+方法二):

方法一：
static final int hash(Object key) { //jdk1.8 & jdk1.7
 int h;
 // h = key.hashCode() 为第一步 取hashCode值
 // h ^ (h >>> 16) 为第二步 高位参与运算
 return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
方法二：
static int indexFor(int h, int length) { //jdk1.7的源码，jdk1.8没有这个方法，但是实现原理一样的
 return h & (length-1); //第三步 取模运算
}

这里的Hash算法本质上就是三步：取key的hashCode值、高位运算、取模运算。

1.7中取模用与操作（hash & （arrayLength-1））也就是h%length，但是&比%具有更高的效率，会比较快，所以数组的大小永远是2的N次方，你随便给一个初始值比如17会转为32。默认第一次放入元素时的初始值是16。
在JDK1.8的实现中，优化了高位运算的算法，通过hashCode()的高16位异或低16位实现的：(h = k.hashCode()) ^ (h >>> 16)，主要是从速度、功效、质量来考虑的，这么做可以在数组table的length比较小的时候，也能保证考虑到高低Bit都参与到Hash的计算中，同时不会有太大的开销。

iterator（）时顺着哈希桶数组来遍历，看起来是个乱序。

扩容机制

扩容(resize)就是重新计算容量，向HashMap对象里不停的添加元素，而HashMap对象内部的数组无法装载更多的元素时，对象就需要扩大数组的长度，以便能装入更多的元素。当然Java里的数组是无法自动扩容的，方法是使用一个新的数组代替已有的容量小的数组，就像我们用一个小桶装水，如果想装更多的水，就得换大水桶。

我们分析下resize的源码，鉴于JDK1.8融入了红黑树，较复杂，为了便于理解我们仍然使用JDK1.7的代码，好理解一些，本质上区别不大。JDK1.8请参考JDK1.8 HashMap源码分析

 1 void resize(int newCapacity) { //传入新的容量
 2 Entry[] oldTable = table; //引用扩容前的Entry数组
 3 int oldCapacity = oldTable.length; 
 4 if (oldCapacity == MAXIMUM_CAPACITY) { //扩容前的数组大小如果已经达到最大(2^30)了
 5 threshold = Integer.MAX_VALUE; //修改阈值为int的最大值(2^31-1)，这样以后就不会扩容了
 6 return;
 7 }
 8 
 9 Entry[] newTable = new Entry[newCapacity]; //初始化一个新的Entry数组
10 transfer(newTable); //！！将数据转移到新的Entry数组里
11 table = newTable; //HashMap的table属性引用新的Entry数组
12 threshold = (int)(newCapacity * loadFactor);//修改阈值
13 }

这里就是使用一个容量更大的数组来代替已有的容量小的数组，transfer()方法将原有Entry数组的元素拷贝到新的Entry数组里。

 1 void transfer(Entry[] newTable) {
 2 Entry[] src = table; //src引用了旧的Entry数组
 3 int newCapacity = newTable.length;
 4 for (int j = 0; j < src.length; j++) { //遍历旧的Entry数组
 5 Entry<K,V> e = src[j]; //取得旧Entry数组的每个元素
 6 if (e != null) {
 7 src[j] = null;//释放旧Entry数组的对象引用（for循环后，旧的Entry数组不再引用任何对象）
 8 do {
 9 Entry<K,V> next = e.next;
10 int i = indexFor(e.hash, newCapacity); //！！重新计算每个元素在数组中的位置
11 e.next = newTable[i]; //标记[1]
12 newTable[i] = e; //将元素放在数组上
13 e = next; //访问下一个Entry链上的元素
14 } while (e != null);
15 }
16 }
17 }

newTable[i]的引用赋给了e.next，也就是使用了单链表的头插入方式，同一位置上新元素总会被放在链表的头部位置；这样先放在一个索引上的元素终会被放到Entry链的尾部(如果发生了hash冲突的话），这一点和Jdk1.8有区别。在旧数组中同一条Entry链上的元素，通过重新计算索引位置后，有可能被放到了新数组的不同位置上。

HashTable

HashMap与HashTable有什么区别？对比Hashtable VS HashMap

两者都是用key-value方式获取数据。
HashMap允许null值作为key和value，而Hashtable不可以
HashMap不是同步的，而Hashtable是同步的。

Hashtable是原始集合类之一（也称作遗留类）。HashMap作为新集合框架的一部分在Java2的1.2版本中加入。它们之间有一下区别：

● HashMap和Hashtable大致是等同的，除了非同步和空值（HashMap允许null值作为key和value，而Hashtable不可以）。

● HashMap不是同步的，而Hashtable是同步的。

● 迭代HashMap采用快速失败机制，而Hashtable不是，所以这是设计的考虑点。
　　　● HashMap没法保证映射的顺序一直不变，但是作为HashMap的子类LinkedHashMap，如果想要预知的顺序迭代（默认按照插入顺序），你可以很轻易的置换为HashMap，如果使用Hashtable就没那么容易了。

6、在Hashtable上下文中同步是什么意思？

同步意味着在一个时间点只能有一个线程可以修改哈希表，任何线程在执行hashtable的更新操作前需要获取对象锁，其他线程等待锁的释放。

LinkedHashMap

特点
LindedHashMap和HashMap类似，只是里面多维护了一个添加的顺序，这样遍历集合时候能够按照顺序输出，不是线程安全的。
源码详解参考：Java集合之LinkedHashMap以及LRU缓存的实现

扩展HashMap，每个Entry增加双向链表，号称是最占内存的数据结构。

支持iterator（）时按Entry的插入顺序来排序（如果设置accessOrder属性为true，则所有读写访问都排序）。

插入时，Entry把自己加到Header Entry的前面去。如果所有读写访问都要排序，还要把前后Entry的before/after拼接起来以在链表中删除掉自己，所以此时读操作也是线程不安全的了。

TreeMap

以红黑树实现，不是线程安全的.

红黑树又叫自平衡二叉树：
对于任一节点而言，其到叶节点的每一条路径都包含相同数目的黑结点。
上面的规定，使得树的层数不会差的太远，使得所有操作的复杂度不超过 O（lgn），但也使得插入，修改时要复杂的左旋右旋来保持树的平衡。

支持iterator（）时按Key值排序，可按实现了Comparable接口的Key的升序排序，或由传入的Comparator控制。可想象的，在树上插入/删除元素的代价一定比HashMap的大。

支持SortedMap接口，如firstKey（），lastKey（）取得最大最小的key，或sub（fromKey, toKey）, tailMap（fromKey）剪取Map的某一段。

EnumMap

EnumMap的原理是，在构造函数里要传入枚举类，那它就构建一个与枚举的所有值等大的数组，按Enum. ordinal（）下标来访问数组。性能与内存占用俱佳。

美中不足的是，因为要实现Map接口，而 V get（Object key）中key是Object而不是泛型K，所以安全起见，EnumMap每次访问都要先对Key进行类型判断，在JMC里录得不低的采样命中频率。

ConcurrentHashMap

并发优化的HashMap。

特点
ConcurrentHashMap实现和HashMap类似，只是通过分段锁实现一个线程安全的Map。
锁分段技术：首先将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。

在这里插入图片描述
在JDK5里的经典设计，默认16把写锁（可以设置更多），有效分散了阻塞的概率。数据结构为Segment[]，每个Segment一把锁。Segment里面才是哈希桶数组（你可以联想hashMapJDK8之前的结构图）。Key先算出它在哪个Segment里，再去算它在哪个哈希桶里。

也没有读锁，因为put/remove动作是个原子动作（比如put的整个过程是一个对数组元素/Entry 指针的赋值操作），读操作不会看到一个更新动作的中间状态。

但在JDK8里，Segment[]的设计被抛弃了，改为精心设计的，只在需要锁的时候加锁。
在jdk1.8中主要做了2方面的改进
改进一：取消segments字段，直接采用transient volatile HashEntry<K,V>[] table保存数据，采用table数组元素作为锁，从而实现了对每一行数据进行加锁，进一步减少并发冲突的概率。
改进二：将原先table数组＋单向链表的数据结构，变更为table数组＋单向链表＋红黑树的结构（和hashMap变动相同的地方)。
size计算：新增字段 transient volatile CounterCell[] counterCells; 可方便的计算hashmap中所有元素的个数，性能大大优于jdk1.7中的size()方法。（面试官可能会问1.7中的size计算）

1.数据结构：取消了Segment分段锁的数据结构，取而代之的是数组+链表+红黑树的结构。
2.保证线程安全机制：JDK1.7采用segment的分段锁机制实现线程安全，其中segment继承自ReentrantLock。JDK1.8采用CAS+Synchronized保证线程安全。
3.锁的粒度：原来是对需要进行数据操作的Segment加锁，现调整为对每个数组元素加锁（Node）。
4.链表转化为红黑树:定位结点的hash算法简化会带来弊端,Hash冲突加剧,因此在链表节点数量大于8时，会将链表转化为红黑树进行存储。5.查询时间复杂度：从原来的遍历链表O(n)，变成遍历红黑树O(logN)。

ConcurrentSkipListMap

JDK6新增的并发优化的SortedMap，以SkipList结构实现。Concurrent包选用它是因为它支持基于CAS的无锁算法，而红黑树则没有好的无锁算法。

原理上，可以想象为多个链表组成的N层楼，其中的元素从稀疏到密集，每个元素有往右与往下的指针。从第一层楼开始遍历，如果右端的值比期望的大，那就往下走一层，继续往前走。

典型的空间换时间。每次插入，都要决定在哪几层插入，同时，要决定要不要多盖一层楼。

它的size（）同样不能随便调，会遍历来统计。

Set

所有Set几乎都是内部用一个Map来实现, 因为Map里的KeySet就是一个Set，而value是假值，全部使用同一个Object即可。

Set的特征也继承了那些内部的Map实现的特征。

HashSet内部是HashMap,不是线程安全的

public HashSet(){
	map = new HashMap<>(); 
}
private static final PRESENT = new Object();
public boolean add(E e) {
    return map.put(e, PRESENT)==null; 
}

hashSet实际是通过hashMap实现的，而且它保存的只是key，而所有的value都只是一个非空的boject对象值

LinkedHashSet内部是LinkedHashMap

TreeSet内部是TreeMap的SortedSet

ConcurrentSkipListSet

内部是ConcurrentSkipListMap的并发优化的SortedSet。

CopyOnWriteArraySet

内部是CopyOnWriteArrayList的并发优化的Set，利用其addIfAbsent（）方法实现元素去重，如前所述该方法的性能很一般。

好像少了个ConcurrentHashSet，本来也该有一个内部用ConcurrentHashMap的简单实现，但JDK偏偏没提供。Jetty就自己简单封了一个，Guava则直接用java.util.Collections.newSetFromMap（new ConcurrentHashMap（））实现。

Queue

Queue是在两端出入的List，所以也可以用数组或链表来实现。

普通队列

LinkedList

是的，以双向链表实现的LinkedList既是List，也是Queue。

ArrayDeque

以循环数组实现的双向Queue。大小是2的倍数，默认是16。

为了支持FIFO，即从数组尾压入元素（快），从数组头取出元素（超慢），就不能再使用普通ArrayList的实现了，改为使用循环数组。

有队头队尾两个下标：弹出元素时，队头下标递增；加入元素时，队尾下标递增。如果加入元素时已到数组空间的末尾，则将元素赋值到数组[0]，同时队尾下标指向0，再插入下一个元素则赋值到数组[1]，队尾下标指向1。如果队尾的下标追上队头，说明数组所有空间已用完，进行双倍的数组扩容。

PriorityQueue

用平衡二叉最小堆实现的优先级队列，不再是FIFO，而是按元素实现的Comparable接口或传入Comparator的比较结果来出队，数值越小，优先级越高，越先出队。但是注意其iterator（）的返回不会排序。

平衡最小二叉堆，用一个简单的数组即可表达，可以快速寻址，没有指针什么的。最小的在queue[0] ，比如queue[4]的两个孩子，会在queue[24+1] 和 queue[2（4+1）]，即queue[9]和queue[10]。

入队时，插入queue[size]，然后二叉地往上比较调整堆。

出队时，弹出queue[0]，然后把queque[size]拿出来二叉地往下比较调整堆。

初始大小为11，空间不够时自动50%扩容。

线程安全的队列

ConcurrentLinkedQueue/Deque

无界的并发优化的Queue，基于链表，实现了依赖于CAS的无锁算法。

ConcurrentLinkedQueue的结构是单向链表和head/tail两个指针，因为入队时需要修改队尾元素的next指针，以及修改tail指向新入队的元素两个CAS动作无法原子，所以需要的特殊的算法。

线程安全的阻塞队列

BlockingQueue，一来如果队列已空不用重复的查看是否有新数据而会阻塞在那里，二来队列的长度受限，用以保证生产者与消费者的速度不会相差太远。当入队时队列已满，或出队时队列已空，不同函数的效果见下表：

	立刻报异常	立刻返回布尔	阻塞等待	可设定等待时间
入队	add（e）	offer（e）	put（e）	offer（e, timeout, unit）
出队	remove（）	poll（）	take（）	poll（timeout, unit）
查看	element（）	peek（）	无	无