数据结构
网络
关系型数据库管理系统
操作系统
Java
MS Excel
iOS
HTML
CSS
Android
Python
C编程
C++
C#
MongoDB
MySQL
Javascript
PHP
物理
化学
生物
数学
英语
经济学
心理学
社会学
时尚研究
法律研究如何在Java中以逆序迭代LinkedHashMap？
LinkedHashMap 用于维护元素添加的精确顺序。它阐明了按插入顺序访问元素的方法。
除了基于键存储值之外，LinkedHashMap 类还扩展了 HashMap 类的功能并实现了 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");
// obtain all keys from the 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 或其列表迭代器无法支持 set 操作，则会发生 UnsupportedOperationException。
Collections.reverse()
代码演示了以插入顺序和逆序两种方式迭代 LinkedHashMap。它首先按插入顺序打印 LinkedHashMap 中的键值对，然后按逆插入顺序打印。
算法
步骤 1 - 启动程序并打印“员工详细信息：”。
步骤 2 - 创建一个名为“lhm”的新 LinkedHashMap 对象，其中包含 Integer 键和 String 值。
步骤 3 - 向“lhm”LinkedHashMap 添加键值对。
步骤 4 - 打印“LinkedHashMap 的插入顺序 -> 迭代”。
步骤 5 - 使用“keySet”方法从“lhm”LinkedHashMap 获取键集并将其存储在“set”Set 中。
步骤 6 - 使用“iterator”方法从“set”Set 获取迭代器。
步骤 7 - 使用带条件“itr.hasNext()”的“while”语句进入循环，以按插入顺序迭代键。
步骤 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.get(strKey)”打印键及其在“lhm”LinkedHashMap 中对应的值。
步骤 17 - 结束循环。
步骤 18 - 结束程序。
示例
// Java program to iterate LinkedHashMap in reverse order
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("Employee Details:");
// generate HashMap object of type <String, String>
LinkedHashMap<Integer, String> lhm
= new LinkedHashMap<Integer, String>();
// adding key-value pairs to HashMap object
lhm.put(1, "Amy");
lhm.put(2, "John");
lhm.put(3, "Paul");
System.out.println(
"Sequence of LinkedHashMap Insertions->"
+ " iterating \n");
// getting keySet() into Set
Set<Integer> set = lhm.keySet();
// get Iterator from key set
Iterator<Integer> itr = set.iterator();
// iterating as per Insertion Order
while (itr.hasNext()) {
Integer key = itr.next();
System.out.println("Key : " + key + "\t\t" + "Value : " + lhm.get(key));
}
// Reverse of Insertion Order iterating
System.out.println("\n\nReversing of Order of Insertion->"
+ " iterating \n");
// convert to ArrayList of key set
List<Integer> alKeys
= new ArrayList<Integer>(lhm.keySet());
// reverse order of keys
Collections.reverse(alKeys);
// iterate LHM using reverse order of keys
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()
此方法类似于上述方法，但是，我们将 Set 直接转换为 LinkedList 对象，而不是使用 ArrayList。我们将使用 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 的选项。
1K+ 次查看
