LinkedHashMap se utiliza para mantener un orden de elementos insertados en él. Proporciona dónde se puede acceder a los elementos en su orden de inserción. Un LinkedHashMap contiene valores basados en la clave. Implementa la interfaz Map y amplía la clase HashMap . Contiene solo elementos únicos o asignaciones.
Sintaxis de Linkedhashmap
public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>
Donde K es clave y V es valor.
Podemos dar clave y valor como nuestros propios tipos de datos como string, flotante, entero, etc. Podemos invertir los elementos en el mapa hash vinculado invirtiendo primero los elementos. Después de invertir, podemos iterarlo.
Método 1: (usando el método inverso())
Este método se utiliza para invertir el orden de los elementos o asignaciones en LinkedHashMap.
Sintaxis:
public static void reverse(List myList)
Parámetros: myList es la lista proporcionada al método Collections.reverse(myList) .
Devoluciones: No devuelve nada pero modifica internamente la lista.
Excepción: arroja una excepción de operación no admitida si la lista especificada o su iterador de lista no admite la operación de configuración.
Pasos:
- Importar paquetes necesarios
- Crear un LinkedHashMap con claves y valores
- Invertir el LinkedHashMap
- Iterarlo.
Ejemplo 1:
Detalles del estudiante que muestran un orden ascendente y descendente con un número entero como clave y valor como una 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
Ejemplo 2: tanto las claves como los valores son de tipo 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)
{
// 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
Método 2: (usando el método listIterator )
Sintaxis:
ListIterator listIterator(int index)
Parámetros: este método solo tiene un argumento, es decir, índice: índice del primer elemento que se devolverá desde el iterador de lista (mediante una llamada a siguiente).
Devoluciones: este método devuelve un iterador de lista sobre los elementos de esta lista (en la secuencia adecuada), comenzando en la posición especificada en la lista.
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", "Geeks");
lhmap.put("two", "For");
lhmap.put("three", "Geeks");
// 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 Geeks two For one Geeks
Método 3: (usando el método descendingIterator )
Sintaxis:
public Iterator descendingIterator()
Valor devuelto: este método devuelve un iterador sobre los elementos de esta LinkedList en secuencia inversa.
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", "Geeks");
lhmap.put("two", "For");
lhmap.put("three", "Geeks");
// 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 Geeks two For one Geeks
Publicación traducida automáticamente
Artículo escrito por sravankumar8128 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA