让我们从一个简单的 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
