【复习】Java集合框架 - Hashmap和Treemap的区别
Java集合框架
- Java集合框架
- Collection：存储单列数据
- List ：存储有序、可重复的数据
- ArrayList：常用，查找效率高，线程不安全，底层的数据结构是数组。
- LinkedList ：插入和删除的效率高，线程不安全，底层的数据结构是双向链表。
- Vector：1.0就出现了，线程安全，效率没有ArrayList高，底层的数据结构也是数组，扩容时一般是扩容为当前容量的两倍。
- Set ：存储无序、不可重复的数据。
- HashSet：线程不安全，底层是数组+链表，也就是使用链地址法解决冲突的散列表，遍历输出时输出顺序与输入顺序不一定相同。
- LinkedHashSet：其父类是HashSet，比HashSet多维护了两个指针，因此遍历输出时的输出顺序与输入顺序一致。
- TreeSet ：底层是用红黑树来实现的，会根据元素的属性进行排序，有自然排序和定制排序两种。
- HashSet：线程不安全，底层是数组+链表，也就是使用链地址法解决冲突的散列表，遍历输出时输出顺序与输入顺序不一定相同。
- List ：存储有序、可重复的数据
- Map：存储双列数据，key-value
- HashMap：无序的，1.8中底层的数据结构是 数组+链表+红黑树，允许null值
- LinkedHashMap：继承HashMap，需要维护两个指针，遍历输出时的输出顺序与输入顺序一致。
- TreeMap：底层的数据结构是红黑树，会根据元素的属性进行排序，有自然排序和定制排序两种。
- HashTable ：1.0 出现的版本，不允许null值
- Properties：继承自 HashTable
- HashMap：无序的，1.8中底层的数据结构是 数组+链表+红黑树，允许null值
- Collection：存储单列数据
- Collections：此类包含对集合进行操作的多态算法。
- ConcurrentHashMap：处理并发情况的 HashMap。在多线程情况下使用，线程安全。不允许null值。1.8中：数组+链表+红黑树+CAS+synchronized
常见问题
1、为什么要重写hashcode和equals方法？
在使用HashSet和HashMap等hash结构时，如果放入的元素类型是自定义的类，则需要重写hashcode和equals方法。这是因为HashSet和HashMap的底层都是用 数组+链表，即使用链地址法解决冲突的散列表来实现的。
当调用添加元素的方法时，首先会计算这个元素的hash值，由此得到它在底层数组中的存储位置：若该存储位置为空则添加成功；若该存储位置不为空，则比较两个元素的hash值是否相等，若不相等，则添加成功，若相等，则再使用equals方法检查两个元素的内容是否相等，若不相等，则添加成共，若相等，则HashSet添加失败，HashMap会修改key所对应的value为新的value。
当我们实例化两个相同的自定义类时，因为其存储地址不一样，因此得到的hash值是不一样的，那么用容器进行存储的时候，就会存进去两个属性一样的实例，因此，我们需要重写hashcode和equals方法，以此来判断这两个实例是否相等。
其中，hashcode的好处是：计算较快，且可以很快定位到地址，因此在比较两个元素是否相等时都会先比较其hashcode是否相等，若相等再调用equals进行比较。
2、怎样重写hashcode和equals方法？
hashcode：可以用成员变量的hashcode做运算来比较，比如a变量左移5位+b变量。
equals：先用等号判断两实例是不是存储在同一位置，若是则返回true；再使用instanceof运算符判断 other 是否为当前实例所属的类，若不是则返回false；最后用equals一一比较成员变量是否都相等，若有一个不相等则返回false。
3、HashMap的扩容问题
在1.8中，实例化HashMap的时候并不会一开始就新建一个数组，而是在第一次进行push操作的时候才会新建数组，默认大小为16。当添加的元素逐渐变多，数量达到一个门槛时就会触发扩容，这个门槛就等于 当前数组长度*加载因子 ，当大于这个门槛，数组就会扩容为原来的两倍。
4、ArrayList的扩容问题
ArrayList的扩容：在1.8中，实例化了一个ArrayList时不会立刻新建一个数组，在第一次add操作时才会新建一个数组，默认大小为10，用minCAPACITY来记录增加的元素个数，每进行一次add操作，就检查minCAPACITY是否大于当前数组长度，若是，则将当前数组扩容为原来的1.5倍；若扩大后依然不能满足，则直接扩大为minCAPACITY；若minCAPACITY大于MAX_CAPACITY则采取处理。
5、ConcurrentHashmap的put方法源码分析
public V put(K key, V value) {
return putVal(key, value, false);
}
/** Implementation for put and putIfAbsent */
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();//不允许null
//基于key的值计算hash值，并进行一定的扰动
//扰动函数：为了使散列表紧凑些，将Hash值的高16位右移并与原Hash值取异或运算（^），混合高16位和低16位的值，得到一个更加散列的低16位的Hash值。
//这个值一定是个整数，方便后面添加元素判断该节点类型
int hash = spread(key.hashCode());
//记录某个桶上元素的个数，如果超过8个，则会转成红黑树
int binCount = 0;
for (Node<K,V>[] tab = table;;) {//table是存储数据的数组
Node<K,V> f; int n, i, fh;
//如果数组还未进行初始化，先对数组进行初始化（用到了CAS）
if (tab == null || (n = tab.length) == 0)
tab = initTable();
//如果hash计算得到的桶位置没有元素，利用CAS将元素添加
//CAS（比较并交换）操作的就是乐观锁，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {//tabAt是用来取当前对应的角标的值
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
//如果hash计算得到的桶位置元素的hash值为MOVED，证明正在扩容，那么协助扩容
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
else {
//hash计算的桶位置元素不为空，且当前并没有处于扩容操作，则进行元素的添加
V oldVal = null;
//对当前桶进行加锁，保证线程安全，执行元素添加
synchronized (f) { //对某个桶位加锁
//可能扩容之后相应角标位置的值变了，所以需要进行一下判断，看看是否还是原来的值
if (tabAt(tab, i) == f) {
//判断hash值是否大于零，若是，则证明它是一个普通链结点
if (fh >= 0) {
//比较这条链表上有没有相同的值，有则更新value，无则加在链表尾部
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
K ek;
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
if (!onlyIfAbsent)
e.val = value;
break;
}
//将新数据添加到最后
Node<K,V> pred = e;
if ((e = e.next) == null) {
pred.next = new Node<K,V>(hash, key,
value, null);
break;
}
}
}
//是一个树结构
else if (f instanceof TreeBin) {
Node<K,V> p;
binCount = 2;
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
if (binCount != 0) {
//判断链表长度是否大于8
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);//若大于8，且数组大小大于64，则树化
if (oldVal != null)
return oldVal;
break;
}
}
}
addCount(1L, binCount);//判断是否需要扩容
return null;
}
6、ConcurrentHashmap的扩容问题
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
int n = tab.length, stride;
//如果是多cpu，那么每个线程划分任务，最小任务量是16个桶位的迁移
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE; // subdivide range
//如果是扩容线程，此时新数组为null
if (nextTab == null) { // initiating
try {
@SuppressWarnings("unchecked")
//两倍扩容创建新数组
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
nextTab = nt;
} catch (Throwable ex) { // try to cope with OOME
sizeCtl = Integer.MAX_VALUE;
return;
}
nextTable = nextTab;
//记录线程开始迁移的桶位，从后往前迁移
transferIndex = n;
}
//记录新数组的末尾
int nextn = nextTab.length;
//已经迁移的桶位，会用这个节点占位（这个节点的hash值为-1--MOVED）
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
boolean advance = true;
boolean finishing = false; // to ensure sweep before committing nextTab
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
while (advance) {
int nextIndex, nextBound;
//i记录当前正在迁移桶位的索引值
//bound记录下一次任务迁移的开始桶位
//--i >= bound 成立表示当前线程分配的迁移任务还没有完成
if (--i >= bound || finishing)
advance = false;
//没有元素需要迁移 -- 后续会去将扩容线程数减1，并判断扩容是否完成
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
//计算下一次任务迁移的开始桶位，并将这个值赋值给transferIndex
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) {
bound = nextBound;
i = nextIndex - 1;
advance = false;
}
}
//如果没有更多的需要迁移的桶位，就进入该if
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
//扩容结束后，保存新数组，并重新计算扩容阈值，赋值给sizeCtl
if (finishing) {
nextTable = null;
table = nextTab;
sizeCtl = (n << 1) - (n >>> 1);
return;
}
//扩容任务线程数减1
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
//判断当前所有扩容任务线程是否都执行完成
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
//所有扩容线程都执行完，标识结束
finishing = advance = true;
i = n; // recheck before commit
}
}
//当前迁移的桶位没有元素，直接在该位置添加一个fwd节点
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd);
//当前节点已经被迁移
else if ((fh = f.hash) == MOVED)
advance = true; // already processed
else {
//当前节点需要迁移，加锁迁移，保证多线程安全
//此处迁移逻辑和jdk7的ConcurrentHashMap相同，不再赘述
synchronized (f) {
if (tabAt(tab, i) == f) {
Node<K,V> ln, hn;
if (fh >= 0) {
int runBit = fh & n;
Node<K,V> lastRun = f;
for (Node<K,V> p = f.next; p != null; p = p.next) {
int b = p.hash & n;
if (b != runBit) {
runBit = b;
lastRun = p;
}
}
if (runBit == 0) {
ln = lastRun;
hn = null;
}
else {
hn = lastRun;
ln = null;
}
for (Node<K,V> p = f; p != lastRun; p = p.next) {
int ph = p.hash; K pk = p.key; V pv = p.val;
if ((ph & n) == 0)
ln = new Node<K,V>(ph, pk, pv, ln);
else
hn = new Node<K,V>(ph, pk, pv, hn);
}
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;
}
else if (f instanceof TreeBin) {
TreeBin<K,V> t = (TreeBin<K,V>)f;
TreeNode<K,V> lo = null, loTail = null;
TreeNode<K,V> hi = null, hiTail = null;
int lc = 0, hc = 0;
for (Node<K,V> e = t.first; e != null; e = e.next) {
int h = e.hash;
TreeNode<K,V> p = new TreeNode<K,V>
(h, e.key, e.val, null, null);
if ((h & n) == 0) {
if ((p.prev = loTail) == null)
lo = p;
else
loTail.next = p;
loTail = p;
++lc;
}
else {
if ((p.prev = hiTail) == null)
hi = p;
else
hiTail.next = p;
hiTail = p;
++hc;
}
}
ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
(hc != 0) ? new TreeBin<K,V>(lo) : t;
hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
(lc != 0) ? new TreeBin<K,V>(hi) : t;
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;
}
}
}
}
}
}
持续更新…