HashMap的使用方法總結、實現原理、使用示例

目錄

 

存值特點

數據結構：

數組+單項鍊表+紅黑樹

圖解：

變量

構造函數

public HashMap()

public HashMap(int initialCapacity)：自定義數組長度

public HashMap(int initialCapacity, float loadFactor):自定義數組長度和家在因子

public HashMap(Map m)：通過map初始化

public void clear()：數組對應的值置空，即清空map

public Object clone()：克隆map

public V compute(K key, BiFunction remappingFunction)：對key在map中的值進行操作

public V computeIfAbsent(K key, Function mappingFunction)：不存在加添加

public V computeIfPresent(K key,BiFunction remappingFunction)只對已經存在key的進行操作，其他不操作

public Set> entrySet()：獲取鍵值對Entry的Set集合

public void forEach(BiConsumer action)：遍歷

public V getOrDefault(Object key, V defaultValue)：key存在返回value，key不存在返回defaultValue

public boolean isEmpty()：判斷集合是不是空

public Set keySet()：獲取key的set集合

public V merge(K key, V value,BiFunction remappingFunction)；key存在修改，不存在新增

public void putAll(Map m)：putmap

public V putIfAbsent(K key, V value)：key不存在就添加

public boolean remove(Object key, Object value)：對應的key、value存在就刪除

public V replace(K key, V value)：替換可以對應的value的值

public void replaceAll(BiFunction function)：根據自定義規則修改元素

public int size()：map的長度

public Collection values()：獲取值得集合

---

存值特點

key和value都可以爲空

數據結構：

數組+單項鍊表+紅黑樹

鏈表長度>=8：鏈表變爲紅黑樹

紅黑樹長度<=6:紅黑樹變爲鏈表

鏈表節點

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;//hash值
    final K key;//可以值
    V value;//值
    Node<K,V> next;//指向下一個鏈表節點

數組

transient Node<K,V>[] table;

圖解：

變量

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;	默認數組初始容量-必須是2的冪
static final float DEFAULT_LOAD_FACTOR = 0.75f;	在構造函數中未指定時使用的加載因子。
transient Set<Map.Entry<K,V>> entrySet;	保存緩存entrySet ()。HashMap中value的集合
transient int size;	map包含元素容量
final float loadFactor;	哈希表的裝載因子
static final int MAXIMUM_CAPACITY = 1 << 30;	最大數據容量
static final int MIN_TREEIFY_CAPACITY = 64;	樹形結構最小容量爲64
transient int modCount;	記錄被改變的次數.主要用於iterators 的快速失敗判斷.
transient Node<K,V>[] table;	鏈表數組
int threshold;	調整大小的下一個大小值(容量*加載因子)。
static final int TREEIFY_THRESHOLD = 8;	鏈表>=8，轉變爲紅黑樹
static final int UNTREEIFY_THRESHOLD = 6;	紅黑樹<=6,轉變成鏈表

構造函數

public HashMap()

默認加載因子：0.75f

public HashMap(int initialCapacity)：自定義數組長度

輸入的數字會計算爲最接近2的冪數

1 ->1
10->16
17->32
31->32
33->64

public HashMap(int initialCapacity, float loadFactor):自定義數組長度和家在因子

public HashMap(Map<? extends K, ? extends V> m)：通過map初始化

public class Test {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"1");
        map.put(3,"1");
        map.put(4,"1");
        Map<Integer,String> map2 = new HashMap<>(map);
        System.out.println(map2);
    }
}

結果：

{1=1, 2=1, 3=1, 4=1}

public void clear()：數組對應的值置空，即清空map

public class Test {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"1");
        map.put(3,"1");
        map.put(4,"1");
        map.clear();
        System.out.println(map);
    }
}

結果

{}

public Object clone()：克隆map

注意：要用全名定義HashMap<Integer,String> map = new HashMap<>(4);，不能寫成Map<Integer,String> map = new HashMap<>(4);

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"1");
        map.put(3,"1");
        map.put(4,"1");
        HashMap<Integer,String> map2 = (HashMap<Integer, String>) map.clone();
        System.out.println(map2);
        map2.remove(4);
        System.out.println(map);
        System.out.println(map2);
    }
}

結果：對克隆的修改，不會影響原來的map

{1=1, 2=1, 3=1, 4=1}
{1=1, 2=1, 3=1, 4=1}
{1=1, 2=1, 3=1}

public V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction)：對key在map中的值進行操作

修改key=3，的value的值

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");

        String test = map.compute(3, (k,v) -> v+1 );
        map.compute(5,(k,v)->{
            return "test";
        });
        map.compute(2,(k,v)->{
            return "test";
        });
        System.out.println(test);
        System.out.println(map);
    }
}

結果：1、對應的key存在，修改key對應value的值，2、如果對應的key不存在，新增一個key、value

31
{1=1, 2=test, 3=31, 4=2, 5=test}

public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)：不存在加添加

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");

        String test = map.computeIfAbsent(3, key -> "test" );
        String test2 = map.computeIfAbsent(5, key -> "test" );

        System.out.println(test);
        System.out.println(test2);
        System.out.println(map);
    }
}

結果：1、存在直接返回；2、key不存在就添加一個值

3
test
{1=1, 2=2, 3=3, 4=2, 5=test}

public V computeIfPresent(K key,BiFunction<? super K, ? super V, ? extends V> remappingFunction)只對已經存在key的進行操作，其他不操作

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");

        String test = map.computeIfPresent(3, (key,value) -> "test" );
        String test2 = map.computeIfPresent(5, (key,value) -> "test" );

        System.out.println(test);
        System.out.println(test2);
        System.out.println(map);
    }
}

結果：1、對key存在的進行操作；2、對key不存在的不作處理

test
null
{1=1, 2=2, 3=test, 4=2}

public boolean containsKey(Object key)，containsValue(Object value)：包含key、包含值

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");

        String test = map.computeIfPresent(3, (key,value) -> "test" );
        String test2 = map.computeIfPresent(5, (key,value) -> "test" );

        System.out.println(map.containsKey(1));
        System.out.println(map.containsKey(5));
        System.out.println(map.containsValue("1"));
        System.out.println(map.containsValue("5"));
    }
}

結果：

true
false
true
false

public Set<Map.Entry<K,V>> entrySet()：獲取鍵值對Entry的Set集合

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");

        Set<Map.Entry<Integer, String>> entries = map.entrySet();
        for (Map.Entry<Integer, String> entry : entries) {
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }
    }
}

結果：

1
1
2
2
3
3
4
2

public void forEach(BiConsumer<? super K, ? super V> action)：遍歷

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");

        map.forEach((key,value)->{
            System.out.println(key+":"+value);
        });
    }
}

結果：

1:1
2:2
3:3
4:2

public V getOrDefault(Object key, V defaultValue)：key存在返回value，key不存在返回defaultValue

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");

        System.out.println(map.getOrDefault(1,"5"));
        System.out.println(map.getOrDefault(5,"6"));
    }
}

結果：

1
6

public boolean isEmpty()：判斷集合是不是空

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");

        System.out.println(map.isEmpty());
    }
}

結果：

false

public Set<K> keySet()：獲取key的set集合

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");
        Set<Integer> integers = map.keySet();
        for (Integer integer : integers) {
            System.out.println(integer+":"+map.get(integer));
        }
    }
}

結果：

1:1
2:2
3:3
4:2

public V merge(K key, V value,BiFunction<? super V, ? super V, ? extends V> remappingFunction)；key存在修改，不存在新增

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");
        map.merge(1,"1",(key,value)->{
           return "test";
        });
        map.merge(2,"5",(key,value)->{
            return "test";
        });
        map.merge(7,"1",(key,value)->{
            return "test";
        });
        map.merge(5,"6",(key,value)->{
            return "test";
        });
        System.out.println(map);
    }
}

結果：

{1=test, 2=test, 3=3, 4=2, 5=6, 7=1}

public void putAll(Map<? extends K, ? extends V> m)：putmap

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");
        HashMap<Integer,String> map2 = new HashMap<>(4);
        map2.put(5,"7");
        map2.put(6,"7");
        map.putAll(map2);
        System.out.println(map);
    }
}

結果：

{1=1, 2=2, 3=3, 4=2, 5=7, 6=7}

public V putIfAbsent(K key, V value)：key不存在就添加

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");
        map.putIfAbsent(3,"5");
        map.putIfAbsent(4,"2");
        map.putIfAbsent(5,"2");
        System.out.println(map);
    }
}

結果：

{1=1, 2=2, 3=3, 4=2, 5=2}

public boolean remove(Object key, Object value)：對應的key、value存在就刪除

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");
        map.remove(1,"3");
        map.remove(2,"2");
        System.out.println(map);
    }
}

結果：

{1=1, 3=3, 4=2}

public V replace(K key, V value)：替換可以對應的value的值

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");
        map.replace(1,"3");
        map.replace(2,"5");
        System.out.println(map);
    }
}

結果：

{1=3, 2=5, 3=3, 4=2}

public boolean replace(K key, V oldValue, V newValue)：替換key、oldValue存在元素的value爲newValue

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");
        map.replace(1,"1","3");
        map.replace(2,"5","6");
        System.out.println(map);
    }
}

結果：

{1=3, 2=2, 3=3, 4=2}

public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function)：根據自定義規則修改元素

修改key>2的value爲test

public class Test {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>(4);
        map.put(1, "1");
        map.put(2, "2");
        map.put(3, "3");
        map.put(4, "2");
        map.replaceAll((key, value) -> {
            if (key > 2) {
                return "test";
            }
            return value;

        });
        System.out.println(map);
    }
}

結果：

public class Test {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>(4);
        map.put(1, "1");
        map.put(2, "2");
        map.put(3, "3");
        map.put(4, "2");
        map.replaceAll((key, value) -> {
            if (key > 2) {
                return "test";
            }
            return value;

        });
        System.out.println(map);
    }
}

public int size()：map的長度

public Collection<V> values()：獲取值得集合

public class Test {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>(4);
        map.put(1, "1");
        map.put(2, "2");
        map.put(3, "3");
        map.put(4, "2");
        Collection<String> values = map.values();
        for (String value : values) {
            System.out.println(value);
        }
        System.out.println(map);
    }
}

結果：

1
2
3
2
{1=1, 2=2, 3=3, 4=2}