HashTable es una estructura de datos subyacente en la que no se conserva el orden de inserción en HashTable y se basa en el código hash de las claves. No se permiten claves duplicadas, pero se pueden duplicar valores. Se permiten objetos heterogéneos tanto para claves como para valores. El valor nulo no está permitido tanto para la clave como para el valor; de lo contrario, obtendremos RunTimeException diciendo NullPointerException . Implementa interfaces serializables y clonables pero no RandomAccess. Cada método dentro de él está sincronizado y, por lo tanto, los objetos HashTable son seguros para subprocesos. HashTable es la mejor opción si nuestra operación frecuente es la operación de búsqueda.
Métodos:
Hay varias formas en las que podemos iterar a través de HashTable, que son las siguientes:
- Uso de la interfaz de enumeración
- Usando el método keySet() de Map and Enhance for loop
- Usando el método keySet() de Map and Iterator Interface
- Usando el método entrySet() de Map y mejorado para bucle
- Usando el método entrySet() de la interfaz Map and Iterator
- Usando el método Iterable.forEach() de la versión Java 8
Ahora analicemos la implementación interna de todos los métodos uno por uno en detalle para obtener una mejor comprensión de la iteración a través de HashTable.
Método 1: Uso de la interfaz de enumeración
La interfaz java.util.Enumeration es una de las interfaces predefinidas, cuyo objeto se utiliza para recuperar los datos de la variable del marco de las colecciones. Solo en dirección hacia adelante y no en dirección hacia atrás. Esta interfaz ha sido reemplazada por un iterador.
Java
// Java Program to Iterate through HashTable
// using enumeration interface
// Importing required packages
import java.util.*;
import java.util.Enumeration;
// MAin Class
class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating Hashtable object where key is of Integer
// type and value is of String type
Hashtable<Integer, String> ht = new Hashtable<>();
// Putting key-value pairs to HashTable object
// Custom input entries
ht.put(1, "Ram");
ht.put(2, "Shyam");
ht.put(3, "Bijay");
ht.put(4, "Hritik");
ht.put(5, "Piyush");
// Creating Enumeration interface
// and get keys() from Hashtable
Enumeration<Integer> e = ht.keys();
// Iterating through the Hashtable
// object
// Checking for next element in Hashtable object
// with the help of hasMoreElements() method
while (e.hasMoreElements()) {
// Getting the key of a particular entry
int key = e.nextElement();
// Print and display the Rank and Name
System.out.println("Rank : " + key
+ "\t\t Name : "
+ ht.get(key));
}
}
}
Rank : 5 Name : Piyush Rank : 4 Name : Hritik Rank : 3 Name : Bijay Rank : 2 Name : Shyam Rank : 1 Name : Ram
Método 2: Usar el método keySet() de Map and Enhance for loop
El método java.util.HashMap.keySet() en Java se utiliza para crear un conjunto de elementos clave contenidos en el mapa hash. Básicamente, devuelve una vista de conjunto de claves, o podemos crear un nuevo conjunto y almacenar los elementos clave en ellos.
Java
// Java program to iterate through HashTable
// using keySet method and enhance for-loop
// Importing required packages
import java.util.*;
import java.util.Set;
// Main Class
class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating Hashtable object in where key is of
// Integer type
// and value is of String type
Hashtable<Integer, String> ht = new Hashtable<>();
// Putting key-value pairs to HashTable object
// custom entries
ht.put(1, "Java");
ht.put(2, "Scala");
ht.put(3, "Python");
ht.put(4, "Pearl");
ht.put(5, "R");
// Getting keySets of Hashtable and
// storing it into Set
Set<Integer> setOfKeys = ht.keySet();
// Iterating through the Hashtable
// object using for-Each loop
for (Integer key : setOfKeys) {
// Print and display the Rank and Name
System.out.println("Rank : " + key
+ "\t\t Name : "
+ ht.get(key));
}
}
}
Rank : 5 Name : R Rank : 4 Name : Pearl Rank : 3 Name : Python Rank : 2 Name : Scala Rank : 1 Name : Java
Método 3: Uso del método keySet( ) de la interfaz Mapa e iterador
Nuevamente, usaremos el mismo método que se implementó en el ejemplo anterior, pero aquí para la iteración usaremos la interfaz iterable.
Java
// Java program to iterate through HashTable
// using keySet method and Iterator Interface
// Importing required libraries
import java.util.*;
import java.util.Iterator;
import java.util.Set;
// Main class
class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating Hashtable object where key is of Integer
// type
// and value is of String type
Hashtable<Integer, String> ht = new Hashtable<>();
// Putting key-value pairs to HashTable object
// Custom input entries
ht.put(1, "Java");
ht.put(2, "Scala");
ht.put(3, "Python");
ht.put(4, "Pearl");
ht.put(5, "R");
// Getting keySets of Hashtable and
// storing it into Set
Set<Integer> setOfKeys = ht.keySet();
// Creating an Iterator object to
// iterate over the given Hashtable
Iterator<Integer> itr = setOfKeys.iterator();
// Iterating through the Hashtable object
// Checking for next element using hasNext() method
while (itr.hasNext()) {
// Getting key of a particular entry
int key = itr.next();
// Print and display the Rank and Name
System.out.println("Rank : " + key
+ "\t\t Name : "
+ ht.get(key));
}
}
}
Rank : 5 Name : R Rank : 4 Name : Pearl Rank : 3 Name : Python Rank : 2 Name : Scala Rank : 1 Name : Java
Método 4: Usar el método entrySet() de Map y bucle for mejorado
El método java.util.HashMap.entrySet() en Java se usa para crear un conjunto de los mismos elementos contenidos en el mapa hash. Básicamente, devuelve una vista establecida del mapa hash, o podemos crear un nuevo conjunto y almacenar los elementos del mapa en ellos.
Java
// Java program to iterate through HashTable
// using entrySet method and enhance for-loop
// Importing required libraries
import java.util.*;
import java.util.Map.Entry;
import java.util.Set;
// Main Class
class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating Hashtable object where key is of Integer
// type and value is of String type
Hashtable<Integer, String> ht = new Hashtable<>();
// Putting key-value pairs to HashTable object
// Custom input entries
ht.put(1, "Java");
ht.put(2, "Scala");
ht.put(3, "Python");
ht.put(4, "Pearl");
ht.put(5, "R");
// Storing all entries of Hashtable
// in a Set using entrySet() method
Set<Entry<Integer, String> > entrySet
= ht.entrySet();
// Iterating through the Hashtable object
// using for-each loop
for (Entry<Integer, String> entry : entrySet) {
// print ad display the Rank and Name
System.out.println("Rank : " + entry.getKey()
+ "\t\t Name : "
+ entry.getValue());
}
}
}
Rank : 5 Name : R Rank : 4 Name : Pearl Rank : 3 Name : Python Rank : 2 Name : Scala Rank : 1 Name : Java
Método 5: Usar el método entrySet() de la interfaz Map and Iterator
Nuevamente, usaremos el mismo método que se implementó en el ejemplo anterior, pero aquí para la iteración usaremos la interfaz iterable.
Java
// Java program to iterate through hashtable using
// entrySet method and Iterator interface
// Importing required libraries
import java.util.*;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
// Main Class
class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating Hashtable object where key is of Integer
// type
// and value is of String type
Hashtable<Integer, String> ht = new Hashtable<>();
// Putting key-value pairs to Hashtable object
// Custom input entries
ht.put(1, "Java");
ht.put(2, "Scala");
ht.put(3, "Python");
ht.put(4, "Pearl");
ht.put(5, "R");
// Storing all entries of Hashtable in a Set
// using entrySet() method
Set<Entry<Integer, String> > entrySet
= ht.entrySet();
// Creating an Iterator object to
// iterate over the given Hashtable
Iterator<Entry<Integer, String> > itr
= entrySet.iterator();
// Iterating through the Hashtable object
// using iterator
// Checking for next element
// using hasNext() method
while (itr.hasNext()) {
// Getting a particular entry of HashTable
Entry<Integer, String> entry = itr.next();
// Print and display the Rank and Name
System.out.println("Rank : " + entry.getKey()
+ "\t\t Name : "
+ entry.getValue());
}
}
}
Rank : 5 Name : R Rank : 4 Name : Pearl Rank : 3 Name : Python Rank : 2 Name : Scala Rank : 1 Name : Java
6. Usando el método Iterable.forEach() de la versión Java 8
Con la llegada de las nuevas características de Havoc en la versión 8. Ha pasado bastante tiempo desde que se lanzó Java 8. Con el lanzamiento, mejoraron algunas API existentes y agregaron algunas funciones nuevas. Uno de ellos es el método forEach() en la interfaz java.lang.Iterable .
Java
// Java program to iterate through HashTable
// using Iterable forEach()method of java 8
// Import required libraries
import java.util.*;
// Main Class
class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating Hashtable object in where key is of
// Integer type
// and value is of String type
Hashtable<Integer, String> ht = new Hashtable<>();
// Putting key-value pairs to HashTable object
// Custom input entries
ht.put(1, "Java");
ht.put(2, "Scala");
ht.put(3, "Python");
ht.put(4, "Ruby");
ht.put(5, "R");
// Iterating through Hashtable using
// forEach loop of java 8
ht.forEach((key, value)
-> System.out.println(
"Rank : " + key
+ "\t\t Name : " + value));
}
}
Rank : 1 Name : Java Rank : 2 Name : Scala Rank : 3 Name : Python Rank : 4 Name : Ruby Rank : 5 Name : R
Publicación traducida automáticamente
Artículo escrito por mroshanmishra0072 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA