LinkedHashMap用法详解

LinkedHashMap 是 Java 中的一个哈希表实现，它是基于 HashMap 的，同时保留了插入顺序或者访问顺序。
与 HashMap 相比，LinkedHashMap 不仅可以快速地访问和修改哈希表中的元素，而且还可以保证元素的顺序。

LinkedHashMap 的常用方法：

• put(K key, V value)：向哈希表中添加一个键值对，如果键已经存在，则会用新值替换旧值。
• get(Object key)：获取指定 key 对应的值，如果 key 不存在，则返回 null。
• remove(Object key)：删除指定 key 对应的键值对，如果 key 不存在，则不会有任何影响。
• removeEldestEntry(Map.Entry<K, V> eldest)：用于实现 LRU 缓存淘汰算法，可以在子类中重写此方法，控制是否移除最旧的元素。如 果返回 true，则会移除最旧的元素，如果返回 false，则不会有任何影响。
• keySet()：获取哈希表中所有键的集合。
• values()：获取哈希表中所有值的集合。
• entrySet()：获取哈希表中所有键值对的集合。
• clear()：清空哈希表，删除所有键值对。
• size()：返回哈希表中键值对的数量。
• containsKey(Object key)：判断哈希表中是否包含指定的键。
• containsValue(Object value)：判断哈希表中是否包含指定的值。
• clone()：创建并返回一个哈希表的副本。
• isEmpty()：判断哈希表是否为空。
• putAll(Map<? extends K, ? extends V> m)：将指定映射中的所有映射复制到此映射中。
• forEach(BiConsumer<? super K, ? super V> action)：对哈希表中的每个键值对执行指定操作。
• replaceAll(BiFunction<? super K, ? super V, ? extends V> function)：使用指定的函数对哈希表中的每个键值对进行替换。
• getOrDefault(Object key, V defaultValue)：获取指定键对应的值，如果键不存在，则返回默认值。
• merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction)：使用指定的函数对哈希表中的指定键的值进行合并。

import java.util.LinkedHashMap;
import java.util.Map;

public class LinkedHashMapDemo {
    public static void main(String[] args) {
        // 创建一个容量为 3、加载因子为 0.75、按插入顺序排序的 LinkedHashMap 对象
        // initialCapacity：是初始数组长度
        // loadFactor：负载因子，表示数组的元素数量/数组长度超过这个比例，数组就要扩容
        // accessOrder：false：基于插入顺序(默认)  true：基于访问顺序
        LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<>(3, 0.75f, true);

        // 添加键值对
        linkedHashMap.put("A", 1);
        linkedHashMap.put("B", 2);
        linkedHashMap.put("C", 3);

        // 打印键值对，按照插入顺序排序
        System.out.println("LinkedHashMap: " + linkedHashMap);

        // 访问键为 "A" 的值，会使其成为最近访问的元素
        linkedHashMap.get("A");

        // 打印键值对，按照访问顺序排序
        System.out.println("LinkedHashMap: " + linkedHashMap);

        // 移除键为 "B" 的元素
        linkedHashMap.remove("B");

        // 打印键值对
        System.out.println("LinkedHashMap: " + linkedHashMap);

        // 获取所有键的集合
        System.out.println("Keys: " + linkedHashMap.keySet());

        // 获取所有值的集合
        System.out.println("Values: " + linkedHashMap.values());

        // 获取所有键值对的集合
        for (Map.Entry<String, Integer> entry : linkedHashMap.entrySet()) {
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }

        // 判断是否包含指定的键和值
        System.out.println("Contains key \"C\": " + linkedHashMap.containsKey("C"));
        System.out.println("Contains value 2: " + linkedHashMap.containsValue(2));

        // 清空哈希表
        linkedHashMap.clear();

        // 判断哈希表是否为空
        System.out.println("Is empty: " + linkedHashMap.isEmpty());
    }
}

putAll(Map<? extends K,? extends V> m) 方法：将指定映射中的所有映射关系复制到此映射中。

import java.util.LinkedHashMap;
import java.util.Map;

public class LinkedHashMapPutAll {
    public static void main(String[] args) {
        // 创建第一个 LinkedHashMap 对象
        LinkedHashMap<String, Integer> linkedHashMap1 = new LinkedHashMap<>();
        linkedHashMap1.put("A", 1);
        linkedHashMap1.put("B", 2);

        // 创建第二个 LinkedHashMap 对象
        LinkedHashMap<String, Integer> linkedHashMap2 = new LinkedHashMap<>();
        linkedHashMap2.put("C", 3);
        linkedHashMap2.put("D", 4);

        // 复制第二个 LinkedHashMap 中的所有映射关系到第一个 LinkedHashMap 中
        linkedHashMap1.putAll(linkedHashMap2);

        // 打印第一个 LinkedHashMap
        System.out.println(linkedHashMap1);
    }
}

输出结果为：

{A=1, B=2, C=3, D=4}

forEach(BiConsumer<? super K,? super V> action) 方法：对此映射中的每个映射执行给定的操作

import java.util.LinkedHashMap;
import java.util.Map;

public class LinkedHashMapForEach {
    public static void main(String[] args) {
        // 创建一个 LinkedHashMap 对象
        LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put("A", 1);
        linkedHashMap.put("B", 2);
        linkedHashMap.put("C", 3);

        // 对此映射中的每个映射执行给定的操作
        linkedHashMap.forEach((key, value) -> System.out.println(key + ": " + value));
    }
}

输出结果为：

A: 1
B: 2
C: 3

replaceAll(BiFunction<? super K,? super V,? extends V> function) 方法：使用给定的函数计算此映射中的每个值，并将结果替换为该键的当前值。

import java.util.LinkedHashMap;

public class LinkedHashMapReplaceAll {
    public static void main(String[] args) {
        // 创建一个 LinkedHashMap 对象
        LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put("A", 1);
        linkedHashMap.put("B", 2);
        linkedHashMap.put("C", 3);

        // 使用给定的函数计算此映射中的每个值，并将结果替换为该键的当前值
        linkedHashMap.replaceAll((key, value) -> value * 2);

        // 打印 LinkedHashMap
        System.out.println(linkedHashMap);
    }
}

输出结果为：

{A=2, B=4, C=6}

getOrDefault(Object key, V defaultValue) 方法：返回指定键映射到的值，如果此映射不包含该键的映射，则返回默认值。

import java.util.LinkedHashMap;

public class LinkedHashMapGetOrDefault {
    public static void main(String[] args) {
        // 创建一个 LinkedHashMap 对象
        LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put("A", 1);
        linkedHashMap.put("B", 2);
        linkedHashMap.put("C", 3);

        // 获取指定键映射到的值，如果此映射不包含该键的映射，则返回默认值
        int value = linkedHashMap.getOrDefault("D", 0);

        // 打印获取的值
        System.out.println(value);
    }
}

输出结果为：

0

merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction) 方法：如果指定的键不存在或其值为 null，则将其与给定非 null 值关联；否则，将给定函数应用于当前值和给定值，并将结果关联到该键。

import java.util.LinkedHashMap;

public class LinkedHashMapMerge {
    public static void main(String[] args) {
        // 创建一个 LinkedHashMap 对象
        LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put("A", 1);
        linkedHashMap.put("B", 2);

        // 如果指定的键不存在或其值为 null，则将其与给定非 null 值关联；否则，将给定函数应用于当前值和给定值，并将结果关联到该键
        linkedHashMap.merge("C", 3, (v1, v2) -> v1 + v2);
        linkedHashMap.merge("A", 3, (v1, v2) -> v1 + v2);

        // 打印 LinkedHashMap
        System.out.println(linkedHashMap);
    }
}

输出结果为：

{A=4, B=2, C=3}