¿Cómo obtener la primera o la última entrada de Java LinkedHashMap?

LinkedHashMap es una clase predefinida en Java que es similar a HashMap, que contiene la clave y su valor respectivo a diferencia de HashMap, en LinkedHashMap se conserva el orden de inserción. La tarea es obtener la primera y la última entrada presentes en LinkedHashMap. Iteración para obtener el último y el primer valor. La primera y la última entrada en Map es la entrada que se inserta primero y la entrada que se insertará en último lugar donde se conserva el orden de inserción. 

Métodos:

1. El enfoque ingenuo que usa el bucle for-each para la iteración sobre Map. 
2. Convertir las claves de LinkedHashMap en una array de enteros.
3. Convertir claves en LinkedHashMap a List como ArrayList a LinkedList.

Ilustración:

Aporte :

Clave-2: Valor-5

Clave-14: Valor-35

Clave-31: Valor-20

Clave-36: Valor-18

Clave-52: Valor-6

Producción:

Valor clave

Primero-> 2 5

Último -> 52 6

Método 1: enfoque ingenuo utilizando el ciclo for-each para la iteración sobre Map. 

Construya la función getFirst() y getLast()

• getFirst() imprime la primera entrada
• getLast() se mueve a la última entrada (el índice es igual al tamaño de LinkedHashMap)

Ejemplo:

// 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

Complejidad temporal: O(n)

Método 2: convertir las claves de LinkedHashMap en una array de enteros.

Algoritmo: 

• Obteniendo primero y valor correspondiente a la clave.
• Impresión de último y valor correspondiente a la tecla.

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.

Ejemplo: 

// 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

Complejidad de tiempo: O(1)

Método 3: convertir claves en LinkedHashMap a List como ArrayList a LinkedList.

Algoritmo 

• Obtener primero y el valor correspondiente a la clave.
• Imprime el último y el valor correspondiente a la clave.

Pseudo Code:
List<Integer> lKeys = new ArrayList<Integer>(LHM.keySet());
// where LHM is name of LinkedHashMap and 
         lKeys is name of List

Ejemplo 

// 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

Complejidad de tiempo: O(1)