极客教程Java LinkedHashMap
LinkedHashMap 类 就像HashMap一样，有一个额外的功能，即维护插入元素的顺序。HashMap提供了快速插入、搜索和删除的优势，但是它从来没有维护过插入的轨迹和顺序，而LinkedHashMap则提供了元素可以按照插入的顺序进行访问。
LinkedHashMap的重要特征如下
- 一个LinkedHashMap包含了基于键的值。它实现了Map接口并扩展了HashMap类。
- 它只包含唯一的元素。
- 它可以有一个空键和多个空值。
- 它是非同步的。
- 它与HashMap相同，但有一个额外的特点，即它保持插入顺序。例如，当我们用HashMap运行代码时，我们会得到一个不同的元素顺序。
声明
public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>
这里， K 是键对象类型， V 是值对象类型
- K – 地图中的键的类型。
- V – 地图中映射的值的类型。
它实现了Map<K, V>接口，并扩展了HashMap<K, V>类。虽然LinkedHashMap的层次结构在下面的媒体中有所描述，但是 ****。
LinkedHashMap如何在内部工作
LinkedHashMap是 HashMap 类的一个扩展，它实现了 Map 接口。因此，该类被声明为。
public class LinkedHashMap
extends HashMap
implements Map
在这个类中，数据是以节点的形式存储的。LinkedHashMap的实现非常类似于一个双链列表。因此，LinkedHashMap的每个节点都被表示为。
- hash： 所有的输入键都被转换为哈希，这是一个更简短的键的形式，这样搜索和插入就更快。
- Key: 因为这个类扩展了HashMap，数据是以键值对的形式存储的。因此，这个参数是数据的关键。
- value： 对于每个键，都有一个与之相关的值。这个参数存储了键的值。由于泛型的存在，这个值可以是任何形式。
- before： 由于LinkedHashMap存储的是插入顺序，这个参数包含了LinkedHashMap的下一个节点的地址。
- after： 这个参数包含了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() | 返回该地图中包含的映射的Set视图。 |
| get(Object key) | 返回指定键所映射的值，如果此地图不包含键的映射，则返回空值。 |
| keySet() | 返回此地图中包含的键的Set视图。 |
| removeEldestEntry(Map.Entry<K,V> eldest) | 如果这个地图应该删除其最老的条目，则返回true。 |
| 值() | 返回该地图中包含的值的集合视图。 |
应用： 由于LinkedHashMap使用了Doubly LinkedList来维护插入顺序，我们可以通过覆盖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 'two'? true
Contains value 'practice.geeksforgeeks.org'? true
delete element 'one': practice.geeksforgeeks.org
Mappings of LinkedHashMap : {two=code.geeksforgeeks.org, four=www.geeksforgeeks.org}
对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（）方法。这个方法将key的值作为输入，搜索是否存在这样的key，然后将key的映射从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()方法来获取key和value的值。
例子
// 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