总结之集合类框架(下)

最新推荐文章于 2021-05-31 00:13:02 发布

MonkeyC97

最新推荐文章于 2021-05-31 00:13:02 发布

阅读量108

点赞数

本文链接：https://blog.csdn.net/weixin_44778253/article/details/99704764

版权

Map集合

Collection集合的特点是每次进行单个对象的保存，如果现在要进行一对对象(偶对象)的保存就只能使用Map集合来完成，即Map集合中会一次性保存两个对象，且这两个对象的关系：key==value结构，这种结构最大的特点是可以通过key找到对应的value内容

Map接口概述

public interface Map<K,V>

在Map接口中有如下常用方法：

No.	方法名称	类型	描述
1	`public V put(K key,V value)`	普通	向Map中追加数据
2	`public V get(Object key)`	普通	根据key取得对应的value，如果没有返回null
3	`public Set<K> keySet()；`	普通	取得所有key信息，key不能重复
4	`public Collection<V> values();`	普通	取得所有value信息，可以重复
5	`public Set<Map.Entry<K,V>> entrySet();`	普通	将Map集合变为Set集合

Map本是一个接口，要使用Map需要通过子类进行对象实例化。Map接口的常用子类有如下四个：HashMap、Hashtable、TreeMap、ConcurrentHashMap

HashMap子类

import java.util.HashMap;
import java.util.Map;

public class TestDemo {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>();
        map.put(1,"hehe");
        map.put(1,"hehe");
        map.put(1,"haha");
        map.put(2,"hehe");
        map.put(3,"hehehe");
        System.out.println(map);
        System.out.println(map.get(3));
        System.out.println(map.get(4));
    }
}
/*
{1=haha, 2=hehe, 3=hehehe}
hehehe
null
*/

范例：取得Map中所有key信息

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class TestDemo{
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>();
        map.put(1,"hehe");
        map.put(2,"hehe");
        map.put(1,"hehe");
        map.put(3,"xixi");
        Set<Integer> set = map.keySet();
        Iterator<Integer> integerIterator = set.iterator();
        while(integerIterator.hasNext()){
            System.out.println(integerIterator.next());
        }
    }
}
//1
//2
//3

范例：将Map转换成Set

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class TestDemo {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>();
        map.put(1,"haha");
        map.put(2,"xixi");
        map.put(3,"hehehe");
        map.put(1,"haha");
        Set<Map.Entry<Integer,String>> set = map.entrySet();
        Iterator<Map.Entry<Integer, String>> integerIterator = set.iterator();
        while(integerIterator.hasNext()){
            System.out.println(integerIterator.next());
        }
    }
}

HashMap内部实现基本点分析

[外链图片转存失败(img-MQoIBpUh-1566111598177)(/Users/houchang/Library/Application Support/typora-user-images/image-20190816181333523.png)]

它可以看作是数组(Node[] table)和链表结合组成的复合结构，数组被分为一个一个桶(bucket)，通过哈希值决定了键值对在这个数组的寻址；哈希值相同的键值对，则以链表形式存储，如果链表大小超过阀值(TREEIFY_THRESHOLD,8),图中的链表就会被改造成树形结构。

构造方法

//无参构造方法
public HashMap() {
  			//默认的容量为16，默认构造因子为0.75F
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

//给定容量构造方法
public HashMap(int initialCapacity) {
  			//默认构造因子为0.75F
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

//给定容量和默认构造因子的构造方法
  public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }
//static final int MAXIMUM_CAPACITY = 1 << 30;（最大容量）

分析：当给定的容量 < 0时，抛出异常：Illegal initial capacity，如果容量比最大容量大，那么将最大容量赋值与给定容量，如果构造因子 <= 0或者不是数字的时候，抛出异常：IllegalArguementException，其中定义了threshold阀值

threshold = initialCapacity * loadFactor，当HashMap的size到达阀值之后，则需要扩容，通过resize().

tableSizeFor()的作用是返回一个比给定整数大且最接近的2的幂次方整数，如给定10，返回2的4次方16.

  static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

分析：首先，int n = cap -1是为了防止cap已经是2的幂时，执行完后面的几条无符号右移操作之后，返回的capacity是这个cap的2倍，因为cap已经是2的幂了，就已经满足条件了。如果不懂可以往下看完几个无符号移位后再回来看。

如果n这时为0了（经过了cap-1之后），则经过后面的几次无符号右移依然是0，最后返回的capacity是1（最后有个n+1的操作）。这里只讨论n不等于0的情况。

[外链图片转存失败(img-jawdrRQi-1566111598179)(/Users/houchang/Desktop/blog/5679451-42e4ccca9e5b0392.png)]

 public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

直接进putMapEntries(m,false)看源码

   final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
     //得到m中元素的个数
        int s = m.size();
     //如果m中有元素
        if (s > 0) {
          //如果table没有被初始化
            if (table == null) { // pre-size
              //计算hashmap的容量
                float ft = ((float)s / loadFactor) + 1.0F;
                int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                         (int)ft : MAXIMUM_CAPACITY);
                if (t > threshold)
                    threshold = tableSizeFor(t);
            }
          //扩容
            else if (s > threshold)
                resize();
          //然后就开始遍历 带插入的 map ，将每一个 <Key ,Value> 插入到本HashMap实例。
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
                K key = e.getKey();
                V value = e.getValue();
              // put(K,V)也是调用　putVal　函数进行元素的插入
                putVal(hash(key), key, value, false, evict);
            }
        }
    }

对于无参构造，HashMap也许是按照lazy-load原则，在首次使用时被初始化既然如此，我们去看看put方法，似乎只有一个putVal的调用。

public V put(K key,V value){
  return putVal(hash(key),key,value,false,true);
}

putVal方法：

  final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

在putVal方法的最初几行，我们就可以发现几个有意思的地方：

如果表格是null，resize()方法会负责初始化它，这从tab = resize()可以看出。
resize方法兼顾两个职责，穿件出事存储表格，或者在容量不满足需求的时候，进行扩容(resize)

具体键值对在哈希表中的位置(数组index) 取决于下面的位运算：i = (n - 1) & hash

我们会发现，它并不是key本身的hashCode，而是来自HashMap内部的另外一个hash方法，注意，为什么这里需要将高位数据移位到低位进行异或运算呢？

这是因为有些数据计算出的哈希值差异主要在高位，而HashMap里的哈希寻址是忽略容量以上的高位的，那么这种处理就可以有效避免类似情况下的哈希碰撞

resize()方法

   final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

依据resize()源码，不考虑极端情况(容量理论最大极限由MAXIMUM_CAPACITY指定，数值 1<<30，也就是2的30次方)

门限值 =(负载因子) * (容量)，如果构建HashMap的时候没有指定它们，那么就是依据相应的默认常量值
门限通常是以倍数进行调整(newThr = oldThr << 1)，当元素个数超过门限大小时，则调整Map的大小
扩容后，需要将老的数组中的元素重新放置到新的数组，这是扩容的一个主要开销来源。

容量、负载因子、树化

容量和负载因子决定了可用的桶的数量，空桶太多会浪费时间，如果使用的太满则会严重影响操作性能，在实际中，如果能够知道HashMap要存取的键值对数量，可以考虑预先设置合适的容量大小，具体数值我们可以根据扩容发生的条件来做简单的评估：

负载因子 * 容量 > 元素数量

也就是满足，预先设计的容量需要大于 预估元素 / 负载因子，同时它还是2的幂数

负载因子不要设置超过0.75的数值，因为会显著得增加冲突，降低性能。
如果使用太小的负载因子，按照上面的公式，预设容量值也进行调整，否则可能会导致更加频繁的扩容，增加无所谓的开销，本身访问性能也受影响

树化：

  final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            resize();
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            TreeNode<K,V> hd = null, tl = null;
            do {
                TreeNode<K,V> p = replacementTreeNode(e, null);
                if (tl == null)
                    hd = p;
                else {
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);
            if ((tab[index] = hd) != null)
                hd.treeify(tab);
        }
    }

当bin的数量大于TREEIFY_THRESHOLD时：

如果容量小于MIN_TREEIFY_CAPACITY，只会进行简单的扩容
如果容量大于MIN_TREEIFY_CAPACITY,则会进行树化改造

为什么HashMap要树化呢？

本质上是个安全问题，因为元素放置过程中，如果一个对象哈希冲突，都被放置到同一个桶里，则会形成一个链表，我们知道链表查询是线性的，会严重影响存取的性能。

Hashtable

/**
 * Hashtable的使用
 */
public class Test18 {
    public static void main(String[] args) {
        Map<Integer,String> map = new Hashtable<>();
        map.put(1,"hehe");
        map.put(2,"haha");
        map.put(3,"xixixi");
        System.out.println(map);
    }
}
//{3=xixixi, 2=haha, 1=hehe}

HashMap于Hashtable的区别

NO.	区别	HashMap	Hashtable
1	版本	JDK1.2	JDK1.0
2	性能	异步处理，性能高	同步处理，性能低
3	安全性	非线程安全	线程安全
4	null操作	允许存放null(有且只有一个)	key和value都不为空，否则出现NullPointerException

ConcurrentHashMap子类

Hashtable本身性能比较低,因为它的实现基本就是将put、get、size等各种方法加上"synchronized"关键字，简单来说，这就导致了所有并发操作都要竞争同一把锁，一个线程在进行同步操作时，其他线程只能等待，大大降低了并发操作的效率。

早期ConcurrentHashMap，其实现是基于：

分离锁，也就是将内部进行分段(Segment),里面则是HashEntry的数组，和HashMap类似，哈希相同的条目也是以链表形式存放
HashEntry内部使用volatile的value字段来保证可见性，也利用了不可变对象的机制以改进利用Unsafe提供的底层能力，不如 volatile access，去直接完成部分操作，以最优化性能，毕竟Unsafe中的很多操作都是JVM intrinsic优化过的

在进行***并发写操作的时候***：

ConcurrentHashMap会获取再入锁，以保证数据一致性，Segment本身就是基于reentrantLock的扩展实现，所以在并发修改期间，相应Segment是被锁定的。
在最初阶段，进行重复性的扫描，以确定相应key值是否已经在数组里面，进而决定是更新还是防止操作，重复扫描，检测冲突ConcurrentHashMaop的常见技巧
在ConcurrentHashMap中扩容同样存在，不过有一个明显区别，就是它进行的不是整体的扩容，而是单独对Segment进行扩容

另外一个Map的size方法同样需要关注，它的实现涉及分离锁的一个副作用。

试想，如果不进行同步，简单的计算所有Segment的总值，可能会因为并发put，导致结果不准确，但是直接锁定所有Segment进行计算，就会变得非常昂贵，其实，分离锁也限制了Map的初始化等操作。

所以，ConcurrentHashMap的实现是通过重试机制(RETRIES_BEFORE_LOCK，指定重试次数2)，来试图获取可靠值，如果没有监控到发生变化(通过对比Segment.modCount)，就直接返回，否则获取锁进行操作。

在JDK1.8之后ConcurrentHashMap发生了哪些变化？

总体结构上，它的内部存储变得和HashMap 结构非常相似，同样是大的桶(bucket)数组，然
内部也是一个个所谓的链表结构(bin)，同步的粒度要更细致一些。
其内部仍然有 Segment 定义，但仅仅是为了保证序列化时的兼容性而已，不再有任何结构上的用处。
因为不再使用 Segment，初始化操作大大简化，修改为 lazy-load 形式，这样可以有效避免初始开销，解决了老版本很多人抱怨的这一点。
数据存储利用 volatile 来保证可见性。
使用 CAS 等操作，在特定场景进行无锁并发操作
使用Unsafe、LongAdder之类底层手段，进行极端情况的优化。

MonkeyC97

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
总结之集合类框架(下)

Map集合Collection集合的特点是每次进行单个对象的保存，如果现在要进行一对对象(偶对象)的保存就只能使用Map集合来完成，即Map集合中会一次性保存两个对象，且这两个对象的关系：key==value结构，这种结构最大的特点是可以通过key找到对应的value内容Map接口概述public interface Map<K,V>在Map接口中有如下常用方法：No...
复制链接

扫一扫