HashMap 方法总结

• HashMap继承关系
• HashMap常见方法
• HashMap全部方法简介

HashMap继承关系

HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。

HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。

HashMap 是无序的，即不会记录插入的顺序。

HashMap常见方法

put - 添加新的键值对

// 实例HashMap
    public static HashMap<Integer, String> createItSHashMap() {
        HashMap<Integer, String> hashMap = new HashMap<>();
        hashMap.put(1,"a");
        hashMap.put(2,"bcd");
        hashMap.put(3,"hello");
        hashMap.put(4,"IZONKUN");
        hashMap.put(5,"world");
        hashMap.put(6,"a");
        return hashMap;
    }

    public static HashMap<String, String> createStSHashMap() {
        HashMap<String, String> hashMap = new HashMap<>();
        hashMap.put("fir","a");
        hashMap.put("sec","b");
        hashMap.put("the","c");
        hashMap.put("fou","d");
        hashMap.put("fiv","e");
        hashMap.put("six","f");
        return hashMap;
    }
// 源码方法
    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) {
        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;
    }

containsKey - 查看是否包含键

// 输入参数：E Key是什么类型就输入什么类型
public static void main(String[] args){
    HashMap<String,String> arrayList = createStSHashMap();
    System.out.println(arrayList.containsKey("fir"));
}
// 返回值 boolean
true
// 源码方法    
public boolean containsKey(Object key) {
    return getNode(hash(key), key) != null;
}
final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        if ((e = first.next) != null) {
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

containsValue - 查看是否包含值

// 输入参数：E value是什么类型就输入什么类型
public static void main(String[] args){
    HashMap<String,String> arrayList = createStSHashMap();
    System.out.println(arrayList.containsValue("b"));
}
// 返回值 boolean
true
// 源码方法 
public boolean containsValue(Object value) {
    Node<K,V>[] tab; V v;
    if ((tab = table) != null && size > 0) {
        for (Node<K,V> e : tab) {
            for (; e != null; e = e.next) {
                if ((v = e.value) == value ||
                    (value != null && value.equals(v)))
                    return true;
            }
        }
    }
    return false;
}

get - 获取对应值

getOrDefault - 获取对应值或获取默认值

replace - 更改映射

isEmpty - 判空

clone - 拷贝一份hashMap

HashMap全部方法简介

方法	描述
clear()	删除hashMap中的所有键/值对
clone()	复制一份hashMap
isEmpty()	判断hashMap是否为空
size()	计算hashMap中键/值对的数量
put()	将键/值对添加到hashMap中
putAll()	将所有键/值对添加到hashMap中
putIfAbsent()	如果hashMap中不存在指定的键，则将指定的键/值对插入
remove()	删除hashMap中指定键key的映射关系
containsKey()	检查hashMap中是否存在指定key对应的映射关系
containsValue()	检查hashMap中是否存在指定value对应的映射关系
replace()	替换hashMap中是指定的Key对应的value
replaceAll()	将hashMap中所有的映射关系替换成给定函数所执行的结果
get()	获得指定key对应的value
getOrDefault()	获取指定key对应的value，如果找不到key，则返回设置的默认值
forEach()	对hashMap中每个映射执行指定的操作
entrySet()	返回hashMap中所有映射项的集合视图
keySet()	返回hashMap中所有key组成的集合视图
values()	返回hashMap中存在的所有value值
merge()	添加键值对到hashMap中
compute()	对hashMap中指定key的值进行重新计算
computeIfAbsent()	对hashMap指定的key的值进行重新计算，如果不存在这个key，则添加到hashMap中
computeIfPresent()	对hashMap中指定key的值进行重新计算，前提是该key存在于hashMap中