LinkedHashMap is a predefined class in Java which is similar to HashMap, containing key and its respective value unlike HashMap, In LinkedHashMap insertion order is preserved. The task is to get the first and last entry present in LinkedHashMap. Iteration to get last and first value. The first and the last entry in Map is the entry that is inserted first and the entry that is to be inserted last where insertion order is preserved.
Methods:
- The naive approach using the for-each loop for iteration over Map.
- Converting the keys of LinkedHashMap to an integer array.
- Converting keys in LinkedHashMap to List like ArrayList to LinkedList.
Illustration:
Input :
Key- 2 : Value-5
Key- 14 : Value-35
Key- 31 : Value-20
Key- 36 : Value-18
Key- 52 : Value-6
Output:
Key Value
First-> 2 5
Last -> 52 6
Method 1: Naive approach using the for-each loop for iteration over Map.
Construct function getFirst() and getLast()
- getFirst() print the first entry
- getLast() move to last entry (index is equal to size of LinkedHashMap)
Example:
// Java Program to get first or last entry // from Java LinkedHashMap // Importing all class of // java.util package import java.util.*;
// Importing java input/output classes import java.io.*;
class GFG {
// getLast() method
public static void
getLast(LinkedHashMap<Integer, Integer> lhm)
{
int count = 1 ;
for (Map.Entry<Integer, Integer> it :
lhm.entrySet()) {
if (count == lhm.size()) {
System.out.println( "Last Key-> " +it.getKey());
System.out.println( "Last Value-> " +it.getValue());
return ;
}
count++;
}
}
// getFirst() method to get first element from
// java LinkedHashMap
public static void
getFirst(LinkedHashMap<Integer, Integer> lhm)
{
int count = 1 ;
for (Map.Entry<Integer, Integer> it :
lhm.entrySet()) {
if (count == 1 ) {
System.out.println( "First Key-> " +it.getKey());
System.out.println( "First Value-> " +it.getValue());
return ;
}
count++;
}
}
// Main driver method
public static void main(String[] args)
{
// Creating(defining) a LinkedHashMap
LinkedHashMap<Integer, Integer> LHM
= new LinkedHashMap<>();
// Adding elements to above LinkedHashMap
LHM.put( 2 , 5 );
LHM.put( 14 , 35 );
LHM.put( 36 , 20 );
LHM.put( 34 , 18 );
LHM.put( 52 , 6 );
// Calling getFirst() method in main()
getFirst(LHM);
// Calling getLast() method in main()
getLast(LHM);
}
} |
First Key-> 2 First Value-> 5 Last Key-> 52 Last Value-> 6
Time complexity: O(n)
Method 2: Converting the keys of LinkedHashMap to an integer array.
Algorithm:
- Getting first and value corresponding to the key.
- Printing last and value corresponding to the key.
Pseudo Code : Integer[] aKeys = LHM.keySet().toArray(new Integer[LHM.size()]); // where LHM is name of LinkedHashMap created and aKeys of array to be converted.
Example:
// Java Program to get first or last entry // from Java LinkedHashMap // By converting Map to integer array // Importing all class of // java.util package import java.util.*;
// Importing java input/output classes import java.io.*;
class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating a LinkedHashMAp
LinkedHashMap<Integer, Integer> LHM
= new LinkedHashMap<>();
// Adding. elements to above LinkedHashMap
// Custom inputs
LHM.put( 1 , 8 );
LHM.put( 2 , 6 );
LHM.put( 3 , 7 );
LHM.put( 4 , 2 );
LHM.put( 5 , 5 );
// Getting all keys from the LinkedHashMap, and
// converting it to an array
Integer[] aKeys
= LHM.keySet().toArray( new Integer[LHM.size()]);
// Condition check
// If array is having element
// Print key and value
if (aKeys.length > 0 ) {
// Print first key and first value
// From integer array
System.out.println( "First key-> " + aKeys[ 0 ]);
System.out.println( "First value-> "
+ LHM.get(aKeys[ 0 ]));
// Print first key from integer array
System.out.println( "Last key-> "
+ aKeys[aKeys.length - 1 ]);
// Print last value from integer array
System.out.println(
"Last value-> "
+ LHM.get(aKeys[aKeys.length - 1 ]));
}
}
} |
First key-> 1 First value-> 8 Last key-> 5 Last value-> 5
Time Complexity: O(1)
Method 3: Converting keys in LinkedHashMap to List like ArrayList to LinkedList.
Algorithm
- Get first and the value corresponding to the key.
- Print last and the value corresponding to the key.
Pseudo Code: List<Integer> lKeys = new ArrayList<Integer>(LHM.keySet()); // where LHM is name of LinkedHashMap and lKeys is name of List
Example
// Java Program to get first or last entry // from Java LinkedHashMap // By converting Map to List // Importing all class of // java.util package import java.util.*;
// Importing java input/output classes import java.io.*;
// Main class class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating a LinkedHashMapc
LinkedHashMap<Integer, Integer> LHM
= new LinkedHashMap<>();
// Adding elements to above LinkedHashMap
// Custom inputs
LHM.put( 1 , 8 );
LHM.put( 2 , 6 );
LHM.put( 3 , 7 );
LHM.put( 4 , 2 );
LHM.put( 5 , 5 );
// Creating a List
List<Integer> lKeys
= new ArrayList<Integer>(LHM.keySet());
// Condition check
// If there is single element in List
// Print key and value
if (lKeys.size() > 0 ) {
// Print first key form List
System.out.println( "First key: "
+ lKeys.get( 0 ));
// Print first value from List
System.out.println( "First value: "
+ LHM.get(lKeys.get( 0 )));
// Print last key from List
System.out.println(
"Last key: " + lKeys.get(lKeys.size() - 1 ));
// Print last value from List
System.out.println(
"Last value: "
+ LHM.get(lKeys.get(lKeys.size() - 1 )));
}
}
} |
First key: 1 First value: 8 Last key: 5 Last value: 5
Time Complexity: O(1)