資料結構
網路
關係型資料庫管理系統
作業系統
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+ 次檢視
