LinkedHashMap用法详解

绝地灬酷狼 2024-03-26 12:26 35阅读 0赞

> 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);
        }
    }

输出结果为：

##### 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}