Java中的LinkedHashMap

LinkedHashMap类就像 HashMap 一样，具有一个附加功能，即维护插入其中的元素的顺序。 HashMap 提供了快速插入、搜索和删除的优势，但它从未维护 LinkedHashMap 提供的插入轨道和插入顺序，其中元素可以按插入顺序访问。

LinkedHashMap 的重要特性如下：

• LinkedHashMap 包含基于键的值。它实现了 Map 接口并扩展了 HashMap 类。
• 它只包含独特的元素。
• 它可能有一个空键和多个空值。
• 它是非同步的。
• 它与 HashMap 相同，但具有维护插入顺序的附加功能。例如，当我们使用 HashMap 运行代码时，我们会得到不同的元素顺序。

宣言：

public class LinkedHashMap extends HashMap implements Map

这里， K是键对象类型， V是值对象类型

• K - 映射中键的类型。
• V – 映射中映射的值的类型。

它实现了 Map 接口，并扩展了 HashMap 类。虽然 LinkedHashMap 的层次结构如下图所示 如下：

LinkedHashMap 如何在内部工作？

LinkedHashMap 是HashMap类的扩展，它实现了Map接口。因此，该类被声明为：

public class LinkedHashMap 
extends HashMap 
implements Map 

在这个类中，数据以节点的形式存储。 LinkedHashMap 的实现与双向链表非常相似。因此，LinkedHashMap 的每个节点表示为：

• 散列：所有输入的键都被转换成一个更短形式的散列，以便搜索和插入更快。
• Key：由于这个类扩展了HashMap，所以数据是以键值对的形式存储的。因此，这个参数是数据的关键。
• 值：对于每个键，都有一个与之关联的值。此参数存储键的值。由于泛型，这个值可以是任何形式。
• Next：由于 LinkedHashMap 存储了插入顺序，它包含了到 LinkedHashMap 的下一个节点的地址。
• Previous：此参数包含 LinkedHashMap 的上一个节点的地址。

同步的 LinkedHashMap

LinkedHashMap 的实现不同步。如果多个线程同时访问链接的哈希映射，并且至少有一个线程在结构上修改映射，则必须在外部同步。这通常是通过同步一些自然封装地图的对象来完成的。如果不存在这样的对象，则应使用Collections.synchronizedMap方法“包装”地图。这最好在创建时完成，以防止对地图的意外不同步访问：

Map m = Collections.synchronizedMap(new LinkedHashMap(...));

LinkedHashMap 类的构造函数

为了创建LinkedHashMap ，我们需要创建 LinkedHashMap 类的对象。 LinkedHashMap 类由各种允许创建 ArrayList 的构造函数组成。以下是此类中可用的构造函数：

1、LinkedHashMap()：用于构造一个默认的LinkedHashMap构造函数。

LinkedHashMap lhm = new LinkedHashMap();

2、LinkedHashMap(int capacity)：用于初始化一个特定的LinkedHashMap，具有指定的容量。

LinkedHashMap lhm = new LinkedHashMap(int capacity);

3. LinkedHashMap(Map K ,​? extends V > map )：用于用指定map的元素初始化一个特定的LinkedHashMap。

LinkedHashMap lhm = new LinkedHashMap(Map map);

4. LinkedHashMap(int capacity, float fillRatio)：用于初始化LinkedHashMap的容量和填充率。也称为loadFactor的 fillRatio 是一个指标，用于确定何时自动增加 LinkedHashMap 的大小。默认情况下，此值为 0.75，这意味着当地图满 75% 时，地图的大小会增加。

LinkedHashMap lhm = new LinkedHashMap(int capacity, float fillRatio);

5. LinkedHashMap(int capacity, float fillRatio, boolean Order)：该构造函数还用于初始化LinkedHashMap的容量和填充率以及是否遵循插入顺序。

LinkedHashMap lhm = new LinkedHashMap(int capacity, float fillRatio, boolean Order);

这里，对于Order 属性，为最后一个访问顺序传递 true，为插入顺序传递 false。

LinkedHashMap 的方法

METHOD	DESCRIPTION
containsValue​(Object value)	Returns true if this map maps one or more keys to the specified value.
entrySet()	Returns a Set view of the mappings contained in this map.
get​(Object key)	Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.
keySet()	Returns a Set view of the keys contained in this map.
removeEldestEntry​(Map.Entry eldest)	Returns true if this map should remove its eldest entry.
values()	Returns a Collection view of the values contained in this map.

Application: Since the LinkedHashMap makes use of Doubly LinkedList to maintain the insertion order, we can implement LRU Cache functionality by overriding the removeEldestEntry() method to impose a policy for automatically removing stale when new mappings are added to the map. This lets you expire data using some criteria that you define.

例子：

Java

// Java Program to Demonstrate Working of LinkedHashMap
 
// Importing required classes
import java.util.*;
 
// LinkedHashMapExample
public class GFG {
 
    // Main driver method
    public static void main(String a[])
    {
 
        // Creating an empty LinkedHashMap
        LinkedHashMap lhm
            = new LinkedHashMap();
 
        // Adding entries in Map
        // using put() method
        lhm.put("one", "practice.geeksforgeeks.org");
        lhm.put("two", "code.geeksforgeeks.org");
        lhm.put("four", "quiz.geeksforgeeks.org");
 
        // Printing all entries inside Map
        System.out.println(lhm);
 
        // Note: It prints the elements in same order
        // as they were inserted
 
        // Getting and printing value for a specific key
        System.out.println("Getting value for key 'one': "
                           + lhm.get("one"));
 
        // Getting size of Map using size() method
        System.out.println("Size of the map: "
                           + lhm.size());
 
        // Checking whether Map is empty or not
        System.out.println("Is map empty? "
                           + lhm.isEmpty());
 
        // Using containsKey() method to check for a key
        System.out.println("Contains key 'two'? "
                           + lhm.containsKey("two"));
 
        // Using containsKey() method to check for a value
        System.out.println(
            "Contains value 'practice.geeks"
            + "forgeeks.org'? "
            + lhm.containsValue("practice"
                                + ".geeksforgeeks.org"));
 
        // Removing entry using remove() method
        System.out.println("delete element 'one': "
                           + lhm.remove("one"));
 
        // Printing mappings to the console
        System.out.println("Mappings of LinkedHashMap : "
                           + lhm);
    }
}

输出

{one=practice.geeksforgeeks.org, two=code.geeksforgeeks.org, four=quiz.geeksforgeeks.org}
Getting value for key 'one': practice.geeksforgeeks.org
Size of the map: 3
Is map empty? false
Contains key 'two'? true
Contains value 'practice.geeksforgeeks.org'? true
delete element 'one': practice.geeksforgeeks.org
Mappings of LinkedHashMap : {two=code.geeksforgeeks.org, four=quiz.geeksforgeeks.org}

HashMap类的各种操作

让我们看看如何对 LinkedHashMap 进行一些常用的操作。

操作 1：添加元素

为了向 LinkedHashMap 添加元素，我们可以使用 put() 方法。这与 HashMap 不同，因为在 HashMap 中，插入顺序不保留，但在 LinkedHashMap 中保留。

例子

Java

// Java Program to Demonstrate Adding
// Elements to a LinkedHashMap
 
// Importing required classes
import java.util.*;
 
// Main class
// AddElementsToLinkedHashMap
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
 
        // Initialization of a LinkedHashMap
        // using Generics
        LinkedHashMap hm1
            = new LinkedHashMap();
 
        // Add mappings to Map
        // using put() method
        hm1.put(3, "Geeks");
        hm1.put(2, "For");
        hm1.put(1, "Geeks");
 
        // Printing mappings to the console
        System.out.println("Mappings of LinkedHashMap : "
                           + hm1);
    }
}

输出

Mappings of LinkedHashMap : {3=Geeks, 2=For, 1=Geeks}

操作2：更改元素

添加元素后，如果我们希望更改元素，可以通过使用 put() 方法再次添加元素来完成。由于树图中的元素是使用键索引的，因此可以通过简单地插入我们希望更改的键的更新值来更改键的值。

例子

Java

// Java Program to Demonstrate Updation of Elements
// of LinkedHashMap
 
import java.util.*;
 
// Main class
// UpdatingLinkedHashMap
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
 
        // Initialization of a LinkedHashMap
        // using Generics
        LinkedHashMap hm
            = new LinkedHashMap();
 
        // Inserting mappings into Map
        // using put() method
        hm.put(3, "Geeks");
        hm.put(2, "Geeks");
        hm.put(1, "Geeks");
 
        // Printing mappings to the console
        System.out.println("Initial map : " + hm);
 
        // Updating the value with key 2
        hm.put(2, "For");
 
        // Printing the updated Map
        System.out.println("Updated Map : " + hm);
    }
}

输出

Initial map : {3=Geeks, 2=Geeks, 1=Geeks}
Updated Map : {3=Geeks, 2=For, 1=Geeks}

操作3：移除元素

为了从 TreeMap 中删除一个元素，我们可以使用 remove() 方法。此方法获取键值并从该树形图中删除该键的映射（如果它存在于映射中）。除此之外，如果定义了最大尺寸，我们还可以从地图中删除第一个输入的元素。

例子

Java

// Java program to Demonstrate Removal of Elements
// from LinkedHashMap
 
// Importing utility classes
import java.util.*;
 
// Main class
// RemovingMappingsFromLinkedHashMap
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
        // Initialization of a LinkedHashMap
        // using Generics
        LinkedHashMap hm
            = new LinkedHashMap();
 
        // Inserting the Elements
        // using put() method
        hm.put(3, "Geeks");
        hm.put(2, "Geeks");
        hm.put(1, "Geeks");
        hm.put(4, "For");
 
        // Printing the mappings to the console
        System.out.println("Initial Map : " + hm);
 
        // Removing the mapping with Key 4
        hm.remove(4);
 
        // Printing the updated map
        System.out.println("Updated Map : " + hm);
    }
}

输出

Initial Map : {3=Geeks, 2=Geeks, 1=Geeks, 4=For}
Updated Map : {3=Geeks, 2=Geeks, 1=Geeks}

操作 4：遍历 LinkedHashMap

有多种方法可以遍历 Map。最著名的方法是使用 for-each 循环并获取密钥。键的值是通过使用getValue()方法找到的。

例子

Java

// Java program to demonstrate
// Iterating over LinkedHashMap
 
// Importing required classes
import java.util.*;
 
// Main class
// IteratingOverLinkedHashMap
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
 
        // Initialization of a LinkedHashMap
        // using Generics
        LinkedHashMap hm
            = new LinkedHashMap();
 
        // Inserting elements into Map
        // using put() method
        hm.put(3, "Geeks");
        hm.put(2, "For");
        hm.put(1, "Geeks");
 
        // For-each loop for traversal over Map
        for (Map.Entry mapElement :
             hm.entrySet()) {
 
            Integer key = mapElement.getKey();
 
            // Finding the value
            // using getValue() method
            String value = mapElement.getValue();
 
            // Printing the key-value pairs
            System.out.println(key + " : " + value);
        }
    }
}

输出

3 : Geeks
2 : For
1 : Geeks

相关文章：

• LRU 缓存实现
• Java中TreeMap、HashMap、LinkedHashMap的区别