javaHashMap总结

java集合

java容器

即集合、数组都是对多个数据进行存储操作的结构

数组的缺点

  1. 一旦初始化,其长度不可更改
  2. 对于增删等操作不方便
  3. 数组一旦定义,其元素类型就确定了,不可更改
集合:
集合是存放数据对象引用的容器,集合可以避免数组的以上缺点
常见的集合
Collection集合,Map集合

今天主要说HashMap,其余的大家可以自己了解

Map接口

Map是一个键值对集合,存储键,值和之间的映射,Key无序,唯一;Value不要求有序,允许重复
Map常用的实现类:HashMap,TreeMap,HashTable,LinkedHashMap,ConcurrentHashMap

HashMap的相关知识

JDK1.7与JDK1.8HashMap的区别
  1. 底层由数组+链表改成数组+链表或红黑树
  2. 链表的插入方式由头插改成尾插
  3. 扩容时,JIK1.7需对原数组中的元素进行重新hash定位在原数组的位置,JDK1.8采用简单的逻辑判断,位置不变或旧容量大小
  4. 在插入时,JDK1.7先判断是否扩容再插入,JDK1.8先插入再判断是否扩容
  5. JDK1.7在new HashMap()时底层创建数组,JDK1.8在首次调用put方法时创建数组
HashMap源码(JDK1.8)
存储结构
存放所有结点的数组
transient Node<K,V>[] table;
//单向链表结点类
static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }
    //计算哈希值
    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }
    //返回一个大于等于cap的数字,该数字要为2的次方数
    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;
    }
属性
//数组初始化长度为16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//数组的最大长度为2^30
static final int MAXIMUM_CAPACITY = 1 << 30;
//负载因子默认大小为0.75f
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//树化阈值(链表长度超过8可能变为红黑树)
static final int TREEIFY_THRESHOLD = 8;
//树降级为链表的阈值
static final int UNTREEIFY_THRESHOLD = 6;
//树化的另一个参数,当哈希表中的所有元素的个数超过64时,链表长度超过8的才会树化
static final int MIN_TREEIFY_CAPACITY = 64;
//哈希表
transient Node<K,V>[] table;
//当前哈希表的元素个数
transient int size;
//当前哈希表结构修改次数
transient int modCount;
//扩容阈值,当哈希表中的元素超过阈值时,触发扩容
int threshold;
//负载因子
//计算threshold,threshold = capacity(当前数组的大小) * loadFactor
 final float loadFactor;
构造方法
//第一个:两个参数:初始化数组大小,负载因子
public HashMap(int initialCapacity, float loadFactor) {
        //initialCapacity必须大于0,且不能大于最大值2^30,如果大于则initialCapacity=2^30
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        //loadFactor必须大于0
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        //tableSizeFor()返回一个大于等于initialCapacity的数字,该数字要为2的次方数
        this.threshold = tableSizeFor(initialCapacity);
    }
//第二个:一个参数:初始化数组大小,调用第一个构造方法
  public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
  }
//第三个:常用的构造方法
public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }
//第四个:
public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }
put方法
public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
    
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        //tab引用当前HashMap的散列表
        //p是当前散列表的元素
        //n是散列表数组的长度
        //i是路由寻址((length-1)&hash) 结果
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //第一次调用putVal时初始化hashMap对象中的散列表
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //如果通过路由算法得到的在数组中的该位置为null,则直接添加key-value(在此对p进行了赋值)
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            //e是临时的元素,不为null,找到了一个与要插入的key-value一致的key的元素
            //k是元素的key
            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 {
                //链表,而且当前链表的头元素与插入元素的key不一致
                for (int binCount = 0; ; ++binCount) {
                    //条件成立的话,迭代到最后一个元素也没有找到与插入元素key相同的元素,即将该元素插入到链表末尾
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        //条件成立的话,说明当前链表的长度达到树化的标准,需要进行树化
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            //树化操作
                            treeifyBin(tab, hash);
                        break;
                    }
                    //条件成立的话,说明找到了相同key的元素,需要进行替换操作
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            //条件成立,说明找到了一个与插入元素key完全一致的数据进行替换
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        //表示散列表结构被修改的次数,替换元素的value不计数
        ++modCount;
        //插入新元素,size自增,若自增后大于扩容阈值,则触发扩容
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }
JDK1.7中HashMap在对线程环境中的问题
//HashMap扩容源码
void resize(int newCapacity) {
    Entry[] oldTable = table;
    int oldCapacity = oldTable.length;
    if (oldCapacity == MAXIMUM_CAPACITY) {
        threshold = Integer.MAX_VALUE;
        return;
    }

    Entry[] newTable = new Entry[newCapacity];
    transfer(newTable);
    table = newTable;
    threshold = (int)(newCapacity * loadFactor);
}
void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
     //for循环中的代码,逐个遍历链表,重新计算索引位置,将老数组数据复制到新数组中
        foreach (Entry<K,V> e : table) {
            while(null != e) {
                Entry<K,V> next = e.next;
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                int i = indexFor(e.hash, newCapacity);//假设线程一执行到这换成线程二
          //将当前entry的next链指向新的索引位置,newTable[i]有可能为空,有可能也是个entry链,如果是entry链,直接在链表头部插入。
          //第一次时 newTable[i] = null

                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            }
        }
    }

1)假设我们有两个线程
在这里插入图片描述
2)线程一被调度回来执行。

1,先是执行 newTalbe[i] = e;
2,然后是e = next,导致了e指向了key(7),
3,而下一次循环的next = e.next导致了next指向了key(3)
在这里插入图片描述
3)一切安好。

线程一接着工作。把key(7)摘下来,放到newTable[i]的第一个,然后把e和next往下移。
在这里插入图片描述
4)环形链接出现。

e.next = newTable[i] 导致 key(3).next 指向了 key(7)

注意:此时的key(7).next 已经指向了key(3), 环形链表就这样出现了。
在这里插入图片描述

HashTable和HashMap的区别
  1. 底层数据结构不同:jdk1.7底层都是数组+链表,但jdk1.8 HashMap加入了红黑树
  2. Hashtable 是不允许键或值为 null 的,HashMap 的键值则都可以为 null。
  3. 初始化容量不同:HashMap 的初始容量为:16,Hashtable 初始容量为:11,两者的负载因子默认都是:0.75。
  4. 同步性不同: Hashtable是同步(synchronized)的,适用于多线程环境,
    而hashmap不是同步的,适用于单线程环境。多个线程可以共享一个Hashtable;而如果没有正确的同步的话,多个线程是不能共享HashMap的。
  5. Hashtable扩容时,将容量变为原来的2倍加1,而HashMap扩容时,将容量变为原来的2倍。
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值