¿Cómo obtener un valor de LinkedHashMap por índice en Java?

LinkedHashMap es una clase predefinida en Java que es similar a HashMap , contiene clave y su valor respectivo a diferencia de HashMap, en LinkedHashMap se conserva el orden de inserción. La tarea es obtener valor de LinkedHashMap por su Índice, en otras palabras, un orden de su inserción. Como ventaja de LinkedHashMap sabemos que se conserva el orden de su inserción, su orden será el mismo que el insertado.

Ejemplo :

Input : Key - 2 : Value - 5
    Key - 4 : Value - 3
    Key - 1 : Value - 10
    Key - 3 : Value - 12
    Key - 5 : Value - 6

Input Index ( assuming index from 1-N ) :

Index - 2

Output :  3 ( Value 3 is at Index 2 )

Algoritmo:

1. Check whether the index in LinkedHashMap does exist or not. 
By using size of LinkedHashMap.

2. If exists a print, the value present there.

    else print " index does not exist ".

Método 1 (usando array de claves):

 Puede convertir todas las claves de LinkedHashMap en un conjunto usando el método Keyset y luego convertir el conjunto en una array usando el método toArray ahora usando el índice de array para acceder a la clave y obtener el valor de LinkedHashMap.

Sintaxis:

Object[] toArray()

Parámetros: El método no toma ningún parámetro.

Valor devuelto: el método devuelve una array que contiene los elementos similares al Conjunto.

Ejemplo

// Java program to get a value from LinkedHashMap by index
// Using Array
import java.util.*;
import java.io.*;
 
public class GFG {
 
    public static void main(String[] args)
    {
 
        // create linked hash map instance
        LinkedHashMap<Integer, Integer> lhm
            = new LinkedHashMap<Integer, Integer>();
 
        // Add mappings
        lhm.put(2, 5);
        lhm.put(4, 3);
        lhm.put(1, 10);
        lhm.put(3, 12);
        lhm.put(5, 6);
 
        // get the key set
        Set<Integer> keySet = lhm.keySet();
 
        Integer[] keyArray
            = keySet.toArray(new Integer[keySet.size()]);
 
        // taking input of index
        Integer index = 2;
        Integer key = keyArray[index - 1];
 
        // get value from the LinkedHashMap for the key
        System.out.println("Value at index " + index
                           + " is : " + lhm.get(key));
    }
}

Value at index 2 is : 3

Método 2 (usando la lista):

Este método es similar al primer método, puede convertir las claves en una lista de arrays o una lista vinculada en lugar de convertirlas en una array.

Ejemplo

// Java program to get a value from LinkedHashMap by index
// Using ArrayList
 
import java.util.*;
import java.io.*;
 
public class GFG {
 
    public static void main(String[] args)
    {
 
        // create an instance of linked hash map
        LinkedHashMap<Integer, Integer> lhm
            = new LinkedHashMap<Integer, Integer>();
 
        // Add mappings
        lhm.put(2, 5);
        lhm.put(4, 3);
        lhm.put(1, 10);
        lhm.put(3, 12);
        lhm.put(5, 6);
 
        // get the key set
        Set<Integer> keySet = lhm.keySet();
 
        // Integer[] keyArray = keySet.toArray(new
        // Integer[keySet.size()]); replacing array with
        // ArrayList here.
        List<Integer> listKeys
            = new ArrayList<Integer>(keySet);
 
        Integer index = 2; // taking input of index
        Integer key = listKeys.get(index - 1);
 
        // get value from the LinkedHashMap for the key
        System.out.println("Value at index " + index
                           + " is : " + lhm.get(key));
    }
}

Value at index 2 is : 3

Método 3 (usando un iterador): 

Podemos obtener todas las entradas de LinkedHashMap usando el método entrySet() e iterar a través de ellas usando el bucle For-each hasta que sea igual al índice, romper e imprimir el valor.

Ejemplo

// Java program to get a value from LinkedHashMap by index
// Using iterator
 
import java.util.*;
import java.io.*;
 
class GFG {
    public static void main(String[] args)
    {
 
        // create an instance of linked hashmap
        LinkedHashMap<Integer, Integer> lhm
            = new LinkedHashMap<Integer, Integer>();
 
        // Add mappings
        lhm.put(2, 5);
        lhm.put(4, 3);
        lhm.put(1, 10);
        lhm.put(3, 12);
        lhm.put(5, 6);
 
        // get all entries from the LinkedHashMap
        Set<Map.Entry<Integer, Integer> > entrySet
            = lhm.entrySet();
 
        // create an iterator
        Iterator<Map.Entry<Integer, Integer> > iterator
            = entrySet.iterator();
 
        int i = 0;
        int index = 1;
        int value = 0;
 
        while (iterator.hasNext()) {
 
            if (index - 1 == i) {
                value = iterator.next()
                            .getValue(); // index is found
                                         // get value
                break; // at that index and break
            }
 
            iterator.next();
            i++;
        }
        // print value
        System.out.println("Value at index " + index + " : "
                           + value);
    }
}

Value at index 1 : 5

Complejidad de tiempo: O(n)

Nota: No se recomienda el uso del Método 1 y el Método 2, ya que requieren la asignación de una nueva array o ArrayList para realizar esta tarea, que cuesta más espacio, en su lugar, utilice el método iterador (método directo), que solo requiere iteración.