How to Iterate LinkedHashMap in Reverse Order in Java?
The LinkedHashMap is used to maintain an order of elements inserted into it. It provides where the elements can be accessed in their insertion order. A LinkedHashMap contains values based on the key. It implements the Map interface and extends the HashMap class. It contains only unique elements or mappings.
Syntax of Linkedhashmap
public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>
Where K is key and V is value.
We can give key and value as our own data types like string, float, integer, etc. We can reverse the elements in the linked hash map by first reversing the elements. After reversing, we can iterate it.
Method 1: ( Using reverse() method)
This method is used to reverse the elements or mappings order in the LinkedHashMap.
Syntax:
public static void reverse(List myList)
Parameters: myList is the List provided to the Collections.reverse(myList) method.
Returns: It does not return anything but modifies the list internally.
Exception: It throws UnsupportedOperationException if the specified List or its list-iterator does not support the set operation.
Steps:
- Import necessary packages
- Create a LinkedHashMap with keys and values
- Reverse the LinkedHashMap
- Iterate it.
Example 1:
Student details displaying ascending and descending order with an integer as key and value as a string.
Java
// 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 Main { public static void main(String[] args) { System.out.println( "Student Details:" ); // creating HashMap object of type <String, String> LinkedHashMap<Integer, String> lhm = new LinkedHashMap<Integer, String>(); // adding key-value pairs to HashMap object lhm.put( 1 , "Sravan Kumar" ); lhm.put( 2 , "Ishitha" ); lhm.put( 3 , "Harsha" ); lhm.put( 4 , "Vamsi" ); lhm.put( 5 , "Jyothika" ); // Insertion Order iterating System.out.println( "Insertion Order of LinkedHashMap:" + " 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\nReverse of Insertion Order:" + " 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)); } } } |
Student Details: Insertion Order of LinkedHashMap: iterating Key : 1 Value : Sravan Kumar Key : 2 Value : Ishitha Key : 3 Value : Harsha Key : 4 Value : Vamsi Key : 5 Value : Jyothika Reverse of Insertion Order: iterating Key : 5 Value : Jyothika Key : 4 Value : Vamsi Key : 3 Value : Harsha Key : 2 Value : Ishitha Key : 1 Value : Sravan Kumar
Example 2: Both keys and values are of string types.
Java
// 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 Main { public static void main(String[] args) { // creating HashMap object of type <String, String> LinkedHashMap<String, String> lhm = new LinkedHashMap<String, String>(); System.out.println( "Staff DataBase" ); // adding key-value pairs to HashMap object lhm.put( "CSE" , "Subba Rao" ); lhm.put( "IT" , "Maruti" ); lhm.put( "Civil" , "Sundari Devi" ); // Insertion Order iterating System.out.println( "Insertion Order of LinkedHashMap:" + " iterating \n" ); // getting keySet() into Set Set<String> set = lhm.keySet(); // get Iterator from key set Iterator<String> itr = set.iterator(); // iterating as per Insertion Order while (itr.hasNext()) { String key = itr.next(); System.out.println( "Key : " + key + "\t\t" + "Value : " + lhm.get(key)); } // Reverse of Insertion Order iterating System.out.println( "\n\nReverse of Insertion Order:" + " iterating \n" ); // convert to ArrayList of key set List<String> alKeys = new ArrayList<String>(lhm.keySet()); // reverse order of keys Collections.reverse(alKeys); // iterate LHM using reverse order of keys for (String strKey : alKeys) { System.out.println( "Key : " + strKey + "\t\t" + "Value : " + lhm.get(strKey)); } } } |
Staff DataBase Insertion Order of LinkedHashMap: iterating Key : CSE Value : Subba Rao Key : IT Value : Maruti Key : Civil Value : Sundari Devi Reverse of Insertion Order: iterating Key : Civil Value : Sundari Devi Key : IT Value : Maruti Key : CSE Value : Subba Rao
Method 2: (Using the listIterator method)
Syntax:
ListIterator listIterator(int index)
Parameters: This method has only an argument, i.e, index – index of the first element to be returned from the list iterator (by a call to next).
Returns: This method returns a list iterator over the elements in this list (in proper sequence), starting at the specified position in the list.
Java
// Java program to iterate // LinkedHashMap in reverse order import java.util.ArrayList; import java.util.LinkedHashMap; import java.util.List; import java.util.ListIterator; import java.util.Set; public class LinkedHashMapIterateReverseExample { public static void main(String[] args) { // create an instance of linked hashmap LinkedHashMap<String, String> lhmap = new LinkedHashMap<String, String>(); // Add mappings lhmap.put( "one" , "Beginner" ); lhmap.put( "two" , "For" ); lhmap.put( "three" , "Beginner" ); // get all keys from the LinkedHashMap Set<String> setKeys = lhmap.keySet(); // convert set to list List<String> listKeys = new ArrayList<String>(setKeys); // get a ListIterator for the ArrayList and // position it at the end to iterate backwards ListIterator<String> iterator = listKeys.listIterator(listKeys.size()); // Iterate in reverse order using the hasPrevious // and previous methods while (iterator.hasPrevious()) { String key = iterator.previous(); // get value mapped to the key System.out.println(key + " " + lhmap.get(key)); } } } |
three Beginner two For one Beginner
Method 3: (Using the descendingIterator method)
Syntax:
public Iterator descendingIterator()
Return Value: This method returns an iterator over the elements in this LinkedList in reverse sequence.
Java
// Java program to iterate // LinkedHashMap in reverse order import java.util.Iterator; import java.util.LinkedHashMap; import java.util.LinkedList; import java.util.Set; public class LinkedHashMapIterateReverseExample { public static void main(String[] args) { // create an instance of linked hashmap LinkedHashMap<String, String> lhmap = new LinkedHashMap<String, String>(); // Add mappings lhmap.put( "one" , "Beginner" ); lhmap.put( "two" , "For" ); lhmap.put( "three" , "Beginner" ); // get all keys from the LinkedHashMap Set<String> setKeys = lhmap.keySet(); // convert set to LinkedList LinkedList<String> listKeys = new LinkedList<String>(setKeys); // get descending iterator Iterator<String> iterator = listKeys.descendingIterator(); // iterate the keys and get the values from the // map while (iterator.hasNext()) { String key = iterator.next(); // get the value System.out.println(key + " " + lhmap.get(key)); } } } |
three Beginner two For one Beginner
Contact Us