Java LinkedHashMap

LinkedHashMap与HashMap的异同：同样是基于散列表实现，区别是，LinkedHashMap内部多了一个双向循环链表的维护，该链表是有序的，可以按元素插入顺序或元素最近访问顺序(LRU)排列，简单地说：LinkedHashMap=散列表+循环双向链表。

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

LinkedHashMap继承了HashMap类，以将其条目存储在哈希表中。它在内部在所有条目之间维护一个双链列表，以对条目进行排序。

创建一个LinkedHashMap

为了创建双向链表，我们必须先导入java.util.LinkedHashMap包。导入程序包后，可以使用以下方法在Java中创建双向链表。

//LinkedHashMap的初始容量为8，负载因子为0.6
LinkedHashMap<Key, Value> numbers = new LinkedHashMap<>(8, 0.6f);

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

这里，

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

• Value - map中的键所关联的元素

注意 new LinkedHashMap<>(8,0.6) 这一部分。这里，第一个参数是capacity，第二个参数是loadFactor。

• capacity -  该双向链表的容量为8。意味着，它可以存储8个条目。

• loadFactor- 这个双向链表的负载因子为0.6。这意味着，每当哈希映射被填满60%时，条目就会被移动到一个新哈希表，其大小是原始哈希表的两倍。

默认容量和负载因子

无需定义其容量和负载因子就可以创建双向链表。例如，

//具有默认容量和负载因子的LinkedHashMap
LinkedHashMap<Key, Value> numbers1 = new LinkedHashMap<>();

默认，

• 双向链表的容量将为 16

• 负载因子将为 0.75

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

//具有指定顺序的LinkedHashMap
LinkedHashMap<Key, Value> numbers2 = new LinkedHashMap<>(capacity, loadFactor, accessOrder);

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

但是，如果accessOrder值为true，则双向链表中的条目将将按从最近访问的顺序排序。

从其他双向链表创建LinkedHashMap

下面是创建一个包含其他映射的所有元素的双向链表。

import java.util.LinkedHashMap;

class Main {
    public static void main(String[] args) {
        //创建偶数的LinkedHashMap
        LinkedHashMap<String, Integer> evenNumbers = new LinkedHashMap<>();
        evenNumbers.put("Two", 2);
        evenNumbers.put("Four", 4);
        System.out.println("LinkedHashMap1: " + evenNumbers);

        //从其他LinkedHashMap创建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

• putIfAbsent() -如果map中不存在指定的键，则将指定的键/值映射插入到map中

例如，

import java.util.LinkedHashMap;

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

        // 使用 put()
        evenNumbers.put("Two", 2);
        evenNumbers.put("Four", 4);
        System.out.println("原始LinkedHashMap: " + evenNumbers);

        // 使用 putIfAbsent()
        evenNumbers.putIfAbsent("Six", 6);
        System.out.println("更新后的LinkedHashMap(): " + evenNumbers);

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

        // 使用 putAll()
        numbers.putAll(evenNumbers);
        System.out.println("新的LinkedHashMap: " + numbers);
    }
}

输出结果

原始LinkedHashMap: {Two=2, Four=4}
更新后的LinkedHashMap: {Two=2, Four=4, Six=6}
新的LinkedHashMap: {One=1, Two=2, Four=4, Six=6}

访问LinkedHashMap元素

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

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

• keySet() - 返回map所有键的集合

• values() - 返回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);

        // 使用 entrySet()
        System.out.println("Key/Value 映射: " + numbers.entrySet());

        // 使用 keySet()
        System.out.println("Keys（键）: " + numbers.keySet());

        // 使用 values()
        System.out.println("Values（值）: " + numbers.values());
    }
}

输出结果

LinkedHashMap: {One=1, Two=2, Three=3}
Key/Value 映射: [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);

        // 使用 get()
        int value1 = numbers.get("Three");
        System.out.println("返回数字: " + value1);

        // 使用 getOrDefault()
        int value2 = numbers.getOrDefault("Five", 5);
        System.out.println("返回数字: " + value2);
    }
}

输出结果

LinkedHashMap: {One=1, Two=2, Three=3}
返回数字: 3
返回数字: 5

删除LinkedHashMap元素

• remove(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);

        //具有单个参数的删除方法
        int value = numbers.remove("Two");
        System.out.println("删除值: " + value);

        //具有两个参数的删除方法
        boolean result = numbers.remove("Three", 3);
        System.out.println("条目3被删除了吗？ " + result);

        System.out.println("更新后的LinkedHashMap: " + numbers);
    }
}

输出结果

LinkedHashMap: {One=1, Two=2, Three=3}
删除值: 2
条目3被删除了吗？ True
更新后的LinkedHashMap: {One=1}

LinkedHashMap的其他方法

LinkedHashMap 与 HashMap 的区别

LinkedHashMap和HashMap都实现Map接口。但是，它们之间存在一些差异。

• LinkedHashMap在内部维护一个双向链表。因此，它保持其元素的插入顺序。

• LinkedHashMap类需要比HashMap更多的存储空间。这是因为LinkedHashMap在内部维护链表。

• LinkedHashMap的性能比HashMap慢。

编程笔记 » Java LinkedHashMap