Java `LinkedHashMap`

原文： https://www.programiz.com/java-programming/linkedhashmap

在本教程中，我们将借助示例学习 Java LinkedHashMap类及其操作。

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

LinkedHashMap接口扩展了HashMap类，以将其条目存储在哈希表中。 它在内部维护所有条目之间的双向链表，以对条目进行排序。

创建一个LinkedHashMap

为了创建链接的哈希映射，我们必须首先导入java.util.LinkedHashMap包。 导入包后，可以使用以下方法在 Java 中创建链接的哈希表。

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

在上面的代码中，我们创建了一个名为number的链接哈希映射。

这里，

• key - 用于关联映射中每个元素（值）的唯一标识符
• value - 由映射中的键关联的元素

注意部分new LinkedHashMap<>(8, 0.6)。 在此，第一个参数是capcity，第二个参数是loadFactor。

• capcity - 此链接的哈希映射的容量为 8。意味着，它可以存储 8 个条目。
• loadFactor - 此链接的哈希映射的负载因子为 0.6。 这意味着，只要我们的哈希映射填充了 60%，条目就会被移到新哈希表中，该哈希表的大小是原始哈希表的两倍。

默认容量和负载系数

无需定义其容量和负载因子就可以创建链接的哈希映射。 例如，

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

默认，

• 链接的哈希映射的容量将为 16
• 负载系数将为 0.75

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

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

此处，accessOrder是布尔值。 其默认值为false。 在这种情况下，链接的哈希映射中的条目将根据其插入顺序进行排序。

但是，如果将true作为accessOrder传递，则链接的哈希映射中的条目将按从最近访问到最近访问的顺序排序。

从其他映射创建LinkedHashMap

这是我们如何创建一个包含其他映射所有元素的链接哈希表。

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类提供允许我们在映射上执行各种操作的方法。

将元素插入LinkedHashMap

• put() - 将指定的键/值映射插入到映射中
• putAll() - 将指定映射中的所有条目插入此映射中
• 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) - 返回并从映射中删除与指定的key相关的条目
• remove(key, value) - 仅当将指定的key映射为指定的value并返回布尔值时，才从映射中删除条目

例如：

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慢。