如何在 Java 中以反向顺序迭代 LinkedHashMap？
LinkedHashMap 的目的是保持元素添加的精确顺序。它阐明了按插入顺序访问元素的方法。
除了根据键存储值之外，LinkedHashMap 类还扩展了 Hash Map 类的功能并实现了 Map 接口。它专门容纳唯一元素或映射。
它使我们能够灵活地利用各种数据类型（例如文本、浮点数、整数等）来分配键和值。通过最初反转元素，我们可以改变链接哈希图中元素的顺序。随后，我们可以根据需要重复此过程。
使用的方法
可以使用以下三种方法之一以相反的顺序迭代 LinkedHashMap -
使用 listIterator()
借助 reverse()
使用 descendingIterator()
方法 1：使用 listIterator()
此方法提供了一个列表迭代器，允许从列表中的指定位置开始，以正确的顺序遍历给定列表的元素。
语法
ListIterator listIterator(int index)
要返回的初始元素的索引通过列表迭代器返回（通过调用 next）：这是此方法接受的唯一参数。
它返回什么？此函数提供一个列表迭代器，依次（按正确顺序）遍历每个对象。即从列表中提供的位置开始。
listIterator()
在此方法中，我们首先利用"keySet"方法从 LinkedHashMap 对象中获取所有键。然后我们使用 ArrayList 构造函数将获得的 Set 转换为 ArrayList。
一旦我们有了列表，我们就利用 ListIterator 的"hasPrevious"和"previous"方法以相反的顺序遍历键。这样我们就可以从 LinkedHashMap 对象中检索相应的值。
算法
步骤 1 - 创建一个 LinkedHashMap 对象并向其中添加一些元素。
步骤 2 - 从 LinkedHashMap 对象中获取所有键。
步骤 3 - 将键转换为 List 对象。
步骤 4 - 为 List 对象创建一个 ListIterator 对象。
步骤 5 - 以相反的顺序通过 ListIterator 对象进行迭代。显示 LinkedHashMap 对象的值。
示例
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.ListIterator;
import java.util.Set;
public class Tutorialspoint {
public static void main(String[] args) {
LinkedHashMap<Integer, String> lhmap = new LinkedHashMap<Integer, String>();
lhmap.put(1, "Google");
lhmap.put(2, "Firefox");
lhmap.put(3, "Safari");
lhmap.put(4, "Brave");
lhmap.put(5, "Opera");
// 从 LinkedHashMap 中获取所有键
Set<Integer> setKeys = lhmap.keySet();
List<Integer> listKeys = new ArrayList<Integer>(setKeys);
ListIterator<Integer> iterator = listKeys.listIterator( listKeys.size() );
while(iterator.hasPrevious()){
System.out.println( lhmap.get( iterator.previous() ) );
}
}
}
输出
Opera Brave Safari Firefox Google
方法 2：借助 reverse()
这是 Collections 类定义的静态方法。可以使用 reverse() 方法反转 List 中条目的顺序。
语法
public static void reverse(List myList)
Collections.reverse(myList) 函数反转列表 myList 中元素的顺序。
它不会返回任何内容，但它会在内部更新列表。如果列表 myList 或其列表迭代器无法支持设置操作，则会出现 UnsupportedOperationException。
Collections.reverse()
代码演示了以插入顺序和反向顺序迭代 LinkedHashMap。它首先按插入顺序打印 LinkedHashMap 中的键值对，然后按相反的插入顺序打印。
算法
步骤 1 - 启动程序并打印"员工详细信息："。
步骤 2 - 使用整数键和字符串值创建一个名为"lhm"的新 LinkedHashMap 对象。
步骤 3 - 将键值对添加到"lhm"LinkedHashMap。
步骤 4 - 打印"LinkedHashMap 的插入顺序 -> 迭代"。
步骤 5 - 使用"keySet"方法从"lhm"LinkedHashMap 获取键集并将其存储在"set" Set。
步骤 6 - 使用"iterator"方法从"set"Set 中获取迭代器。
步骤 7 - 使用"while"语句和条件"itr.hasNext()"输入循环，按插入顺序迭代键。
步骤 8 - 在循环中，使用"itr.next()"检索下一个键并将其存储在"key"变量中。
步骤 9 - 使用"lhm.get(key)"从"lhm"LinkedHashMap 中打印键及其对应的值。
步骤 10 - 结束循环。
步骤 11 - 打印一个新的行。
步骤 12 - 打印"反转插入顺序 -> 迭代"。
步骤 13 - 创建一个名为"alKeys"的新 ArrayList，并使用 ArrayList 构造函数使用"lhm"LinkedHashMap 中的键对其进行初始化。
步骤 14 - 使用"Collections.reverse(alKeys)"反转"alKeys"ArrayList 中元素的顺序。
步骤 15 - 使用 for-each 循环遍历"alKeys"ArrayList，以"strKey"作为循环变量。
步骤 16 - 在循环中，使用"lhm"LinkedHashMap 打印键及其对应的值"lhm.get(strKey)"。
步骤 17 - 结束循环。
步骤 18 - 结束程序。
示例
// Java 程序以相反顺序迭代 LinkedHashMap
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
public class Tutorialspoint {
public static void main(String[] args){
System.out.println("员工详细信息：");
// 生成类型为 <String, String> 的 HashMap 对象
LinkedHashMap<Integer, String> lhm
= new LinkedHashMap<Integer, String>();
// 将键值对添加到 HashMap 对象
lhm.put(1, "Amy");
lhm.put(2, "John");
lhm.put(3, "Paul");
System.out.println(
"LinkedHashMap 插入序列->"
+ " 迭代 \n");
// 将 keySet() 放入 Set
Set<Integer> set = lhm.keySet();
// 从键集获取 Iterator
Iterator<Integer> itr = set.iterator();
// 按插入顺序迭代
while (itr.hasNext()) {
Integer key = itr.next();
System.out.println("Key : " + key + "\t\t" + "Value : " + lhm.get(key));
}
// 反向插入顺序迭代
System.out.println("\n\nReversing of Order of Insertion->"
+ " iterating \n");
// 转换为键集的 ArrayList
List<Integer> alKeys
= new ArrayList<Integer>(lhm.keySet());
// 反向键顺序
Collections.reverse(alKeys);
// 使用键的逆序迭代 LHM
for (Integer strKey : alKeys) {
System.out.println("Key : " + strKey + "\t\t" + "Value : " + lhm.get(strKey));
}
}
}
输出
Employee Details: Sequence of LinkedHashMap Insertions-> iterating Key : 1 Value : Amy Key : 2 Value : John Key : 3 Value : Paul Reversing of Order of Insertion-> iterating Key : 3 Value : Paul Key : 2 Value : John Key : 1 Value : Amy
方法 3：使用 descendingIterator()
descendingIterator() 方法用于获取一个迭代器，该迭代器以相反的顺序遍历 LinkedList 中的组件。
从最后一个元素（尾部）到第一个元素（头部），元素按该顺序返回。
语法
public Iterator descendingIterator()
返回值 − 此方法以相反的顺序提供遍历此 LinkedList 元素的迭代器。
descendingInterator()
此方法与上面的方法类似，但是，我们不会使用 ArrayList，而是将 Set 转换为 LinkedList 对象。我们将使用 LinkedList 类的 descendingIterator() 函数按如下所示的相反顺序迭代键。
算法
步骤 1 - 创建一个名为"lhmap"的新 LinkedHashMap 对象。
步骤 2 - 将键值对添加到"lhmap"LinkedHashMap。
步骤 3 - 从"lhmap"LinkedHashMap 获取一组键。
步骤 4 - 创建一个新的 LinkedList"listKeys"。使用"setKeys"的内容对其进行初始化。
步骤 5 - 生成一个迭代器。这里我们借助"listKeys"LinkedList 的 descendingIterator() 方法将其命名为"iterator"。
步骤 6 - 使用 while 循环按降序对键进行迭代。
步骤 7 - 在循环内部，从迭代器中检索下一个键，并从"lhmap"LinkedHashMap 中打印相应的值。
步骤 8 - 结束循环。
步骤 9 - 结束程序。
示例
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.Set;
public class Tutorialspoint {
public static void main(String[] args) {
LinkedHashMap<Integer, String> lhmap = new LinkedHashMap<>();
lhmap.put(10, "Ten");
lhmap.put(20, "Twenty");
lhmap.put(30, "Thirty");
lhmap.put(40, "Forty");
lhmap.put(50, "Fifty");
Set<Integer> setKeys = lhmap.keySet();
LinkedList<Integer> listKeys = new LinkedList<>(setKeys);
Iterator<Integer> iterator = listKeys.descendingIterator();
while (iterator.hasNext()) {
System.out.println(lhmap.get(iterator.next()));
}
}
}
输出
Fifty Forty Thirty Twenty Ten
结论
LinkedHashMap 在保持元素添加的准确顺序和提供按插入顺序访问元素的方法方面起着至关重要的作用。它通过实现 Map 接口和支持唯一元素映射，超越了 HashMap 类的功能。这允许在分配键和值时使用不同的数据类型。通过最初反转元素，我们能够修改链接哈希映射中的顺序并根据需要重复该过程。三种方法，即 listIterator()、reverse() 和 descendingIterator()，提供了以相反顺序迭代 LinkedHashMap 的选项。
