让我们从一个简单的 Java 代码片段开始，演示如何在 Java 中创建和使用 LinkedHashMap。

import java.util.LinkedHashMap;

public class LinkedHashMapCreation {
    public static void main(String[] args) {
        
        // Create a LinkedHashMap of Strings (keys) and Integers (values)
        LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<>();
        
        // Displaying the LinkedHashMap
        System.out.println("LinkedHashMap Elements: " + linkedHashMap);
    }
}

输出

LinkedHashMap Elements:：{}

        LinkedHashMap类与HashMap类似，但有一个附加功能，即维护插入元素的顺序。HashMap 具有快速插入、搜索和删除的优势，但它从不维护插入的轨迹和顺序，而 LinkedHashMap 则提供了可以按插入顺序访问元素的功能。 

LinkedHashMap 的特点：

    LinkedHashMap 包含基于键的值。它实现 Map 接口并扩展 HashMap 类。

    它仅包含唯一元素。

    它可能有一个空键和多个空值。

    它是非同步的。

    它与 HashMap 相同，但有一个额外的特性，即它维护插入顺序。例如，当我们使用 HashMap 运行代码时，我们会得到不同的元素顺序。

LinkedHashMap的声明：

public class LinkedHashMap<K,​V> extends HashMap<K,​V> implements Map<K,​V>

其中，K是键对象类型，V是值对象类型

K：地图中键的类型。

V：地图中映射的值的类型。

LinkedHashMap 内部如何工作？

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

public class LinkedHashMap 
extends HashMap 
implements Map 

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

Hash：所有输入的键都转换为哈希，即键的较短形式，以便更快地进行搜索和插入。
Key：由于该类扩展了HashMap，数据是以键值对的形式存储的。因此，该参数是数据的键。
Value：每个键都有一个与之关联的值。此参数存储键的值。由于泛型，此值可以是任何形式。
Next：由于 LinkedHashMap 存储了插入顺序，因此它包含了 LinkedHashMap 下一个节点的地址。
Previous：此参数包含LinkedHashMap前一个节点的地址。 

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

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

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

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

LinkedHashMap<K，V> lhm = new LinkedHashMap<K，V>();

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

LinkedHashMap<K，V> lhm = new LinkedHashMap<K，V>(int capacity);

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

LinkedHashMap<K，V> lhm = new LinkedHashMap<K，V>(Map<? extends K,​? extends V> map);

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

LinkedHashMap<K，V> lhm = new LinkedHashMap<K，V>(int capacity，float fillRatio);

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

LinkedHashMap<K，V> lhm = new LinkedHashMap<K，V>(int capacity，float fillRatio，boolean Order);
这里，对于Order 属性，最后访问顺序传递 true，插入顺序传递 false。

LinkedHashMap 的方法 

方法	描述
containsValue​(Object value)	如果此映射将一个或多个键映射到指定值，则返回 true。
entrySet()	返回此映射中包含的映射的集合视图。
get​(Object key)	返回指定键映射到的值，如果此映射不包含该键的映射，则返回 null。
keySet()	返回此映射中包含的键的 Set 视图。
removeEldestEntry​(Map.Entry<K,​V> eldest)	如果此映射应删除其最旧的条目，则返回 true。
values()	返回此映射中包含的值的 Collection 视图。

应用：由于 LinkedHashMap 使用双向链接列表来维护插入顺序，我们可以通过重写removeEldestEntry()方法来实现 LRU 缓存功能，以实施在将新映射添加到映射时自动删除过时映射的策略。这允许您使用您定义的一些标准使数据过期。

例子：

// 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<String, String> lhm
            = new LinkedHashMap<String, String>();

        // Adding entries in Map
        // using put() method
        lhm.put("one", "practice.geeksforgeeks.org");
        lhm.put("two", "code.geeksforgeeks.org");
        lhm.put("four", "www.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=www.geeksforgeeks.org}
Getting value for key 'one': practice.geeksforgeeks.org
Size of the map: 3
Is map empty? false
Contains key 'tw...

LinkedHashMap类上的各种操作
        我们来看看如何对LinkedHashMap类实例执行一些常用的操作。

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

例子：

// 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<Integer, String> hm1
            = new LinkedHashMap<Integer, String>();

        // 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() 方法再次添加元素。由于 LinkedHashMap 中的元素是使用键进行索引的，因此只需重新插入我们希望更改的键的更新值即可更改键的值。

例子：

// 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<Integer, String> hm
            = new LinkedHashMap<Integer, String>();

        // 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：删除元素
        为了从 LinkedHashMap 中删除一个元素，我们可以使用 remove() 方法。此方法将键的值作为输入，搜索此类键是否存在，然后从此 LinkedHashMap 中删除该键的映射（如果映射中存在）。除此之外，如果定义了最大大小，我们还可以从映射中删除第一个输入的元素。

例子：

// 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<Integer, String> hm
            = new LinkedHashMap<Integer, String>();

        // 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
        有多种方法可以遍历 LinkedHashMap。最著名的方法是使用for-each 循环遍历映射的集合视图（使用 map.entrySet() 实例方法获取）。然后对于每个条目（集合元素），可以使用 getKey() 和getValue()方法获取键和值的值。

例子：

// 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<Integer, String> hm
            = new LinkedHashMap<Integer, String>();

        // 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<Integer, String> 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