Java LinkedHashMap

Java 集合框架中的 LinkedHashMap 类提供了 Map 接口的哈希表和 链表 实现。

LinkedHashMap 类扩展了 HashMap 类，以在哈希表中存储其条目。它在所有条目之间内部维护一个双向链表来排序其条目。

创建 LinkedHashMap

为了创建 linked hashmap，我们必须首先导入 java.util.LinkedHashMap 包。导入包后，我们可以在 Java 中这样创建 linked hashmaps。

// LinkedHashMap with initial capacity 8 and load factor 0.6
LinkedHashMap<Key, Value> numbers = new LinkedHashMap<>(8, 0.6f);

在上面的代码中，我们创建了一个名为 numbers 的 linked hashmap。

这里，

• Key - 用于将 map 中的每个元素（值）关联起来的唯一标识符
• Value - map 中键关联的元素

注意 new LinkedHashMap<>(8, 0.6) 这部分。这里，第一个参数是 **容量**，第二个参数是 **加载因子**。

• 容量 - 此 linked hashmap 的容量为 8。意味着它可以存储 8 个条目。
• 加载因子 - 此 linked hashmap 的加载因子为 0.6。这意味着，每当我们的哈希表填充到 60% 时，条目都会被移动到一个新哈希表中，其大小是原始哈希表大小的两倍。

默认容量和加载因子

可以不定义容量和加载因子来创建 linked hashmap。例如，

//LinkedHashMap with default capacity and load factor
LinkedHashMap<Key, Value> numbers1 = new LinkedHashMap<>();

默认情况下，

• linked hashmap 的容量将是 16
• 加载因子将为0.75

注意：LinkedHashMap 类还允许我们定义其条目的顺序。例如

// LinkedHashMap with specified order
LinkedHashMap<Key, Value> numbers2 = new LinkedHashMap<>(capacity, loadFactor, accessOrder);

这里，accessOrder 是一个布尔值。其默认值为 false。在这种情况下，linked hashmap 中的条目将根据其插入顺序排序。

但是，如果将 true 作为 accessOrder 传递，linked hashmap 中的条目将从最近最少访问到最近最多访问排序。

从其他 Map 创建 LinkedHashMap

这是如何创建包含其他 map 中所有元素的 linked hashmap。

import java.util.LinkedHashMap;

class Main {
    public static void main(String[] args) {
        // Creating a LinkedHashMap of even numbers
        LinkedHashMap<String, Integer> evenNumbers = new LinkedHashMap<>();
        evenNumbers.put("Two", 2);
        evenNumbers.put("Four", 4);
        System.out.println("LinkedHashMap1: " + evenNumbers);

        // Creating a LinkedHashMap from other LinkedHashMap
        LinkedHashMap<String, Integer> numbers = new LinkedHashMap<>(evenNumbers);
        numbers.put("Three", 3);
        System.out.println("LinkedHashMap2: " + numbers);
    }
}

输出

LinkedHashMap1: {Two=2, Four=4}
LinkedHashMap2: {Two=2, Four=4, Three=3}

LinkedHashMap 的方法

LinkedHashMap 类提供了允许我们对 map 执行各种操作的方法。

向 LinkedHashMap 插入元素

• put() - 将指定的键/值映射插入到映射中
• putAll() - 将指定 map 中的所有条目插入到此 map 中
• putIfAbsent() - 如果指定键不在映射中，则将指定的键/值映射插入到映射中

例如，

import java.util.LinkedHashMap;

class Main {
    public static void main(String[] args) {
        // Creating LinkedHashMap of even numbers
        LinkedHashMap<String, Integer> evenNumbers = new LinkedHashMap<>();

        // Using put()
        evenNumbers.put("Two", 2);
        evenNumbers.put("Four", 4);
        System.out.println("Original LinkedHashMap: " + evenNumbers);

        // Using putIfAbsent()
        evenNumbers.putIfAbsent("Six", 6);
        System.out.println("Updated LinkedHashMap(): " + evenNumbers);

        //Creating LinkedHashMap of numbers
        LinkedHashMap<String, Integer> numbers = new LinkedHashMap<>();
        numbers.put("One", 1);

        // Using putAll()
        numbers.putAll(evenNumbers);
        System.out.println("New LinkedHashMap: " + numbers);
    }
}

输出

Original LinkedHashMap: {Two=2, Four=4}
Updated LinkedHashMap: {Two=2, Four=4, Six=6}
New LinkedHashMap: {One=1, Two=2, Four=4, Six=6}

访问 LinkedHashMap 元素

1. 使用 entrySet()、keySet() 和 values()

• entrySet() - 返回映射中所有键/值映射的集合
• keySet() - 返回映射中所有键的集合
• values() - 返回映射中所有值的集合

例如，

import java.util.LinkedHashMap;

class Main {
    public static void main(String[] args) {
        LinkedHashMap<String, Integer> numbers = new LinkedHashMap<>();

        numbers.put("One", 1);
        numbers.put("Two", 2);
        numbers.put("Three", 3);
        System.out.println("LinkedHashMap: " + numbers);

        // Using entrySet()
        System.out.println("Key/Value mappings: " + numbers.entrySet());

        // Using keySet()
        System.out.println("Keys: " + numbers.keySet());

        // Using values()
        System.out.println("Values: " + numbers.values());
    }
}

输出

LinkedHashMap: {One=1, Two=2, Three=3}
Key/Value mappings: [One=1, Two=2, Three=3]
Keys: [One, Two, Three]
Values: [1, 2, 3]

2. 使用 get() 和 getOrDefault()

• get() - 返回与指定键关联的值。如果找不到键，则返回 null。
• getOrDefault() - 返回与指定键关联的值。如果找不到键，则返回指定的默认值。

例如，

import java.util.LinkedHashMap;

class Main {
    public static void main(String[] args) {

        LinkedHashMap<String, Integer> numbers = new LinkedHashMap<>();
        numbers.put("One", 1);
        numbers.put("Two", 2);
        numbers.put("Three", 3);
        System.out.println("LinkedHashMap: " + numbers);

        // Using get()
        int value1 = numbers.get("Three");
        System.out.println("Returned Number: " + value1);

        // Using getOrDefault()
        int value2 = numbers.getOrDefault("Five", 5);
        System.out.println("Returned Number: " + value2);
    }
}

输出

LinkedHashMap: {One=1, Two=2, Three=3}
Returned Number: 3
Returned Number: 5

移除 LinkedHashMap 元素

• remove(key) - 从 map 中返回并移除与指定 key 关联的条目
• remove(key, value) - 仅当指定 key 映射到指定 value 时，才从 map 中移除条目，并返回一个布尔值

例如，

import java.util.LinkedHashMap;

class Main {
    public static void main(String[] args) {

        LinkedHashMap<String, Integer> numbers = new LinkedHashMap<>();
        numbers.put("One", 1);
        numbers.put("Two", 2);
        numbers.put("Three", 3);
        System.out.println("LinkedHashMap: " + numbers);

        // remove method with single parameter
        int value = numbers.remove("Two");
        System.out.println("Removed value: " + value);

        // remove method with two parameters
        boolean result = numbers.remove("Three", 3);
        System.out.println("Is the entry Three removed? " + result);

        System.out.println("Updated LinkedHashMap: " + numbers);
    }
}

输出

LinkedHashMap: {One=1, Two=2, Three=3}
Removed value: 2
Is the entry {Three=3} removed? True
Updated LinkedHashMap: {One=1}

LinkedHashMap 的其他方法

LinkedHashMap 与 HashMap 对比

LinkedHashMap 和 HashMap 都实现了 Map 接口。然而，它们之间存在一些区别。

• LinkedHashMap 内部维护一个双向链表。因此，它维护元素的插入顺序。
• LinkedHashMap 类比 HashMap 需要更多的存储空间。这是因为 LinkedHashMap 内部维护链表。
• LinkedHashMap 的性能比 HashMap 慢。