Clase Java HashSet
Clase Java HashSet
En este tutorial, aprenderemos sobre la clase Java HashSet. Aprenderemos sobre diferentes métodos y operaciones de conjuntos hash con la ayuda de ejemplos.
El HashSet La clase del marco Java Collections proporciona las funcionalidades de la estructura de datos de la tabla hash.
Implementa la interfaz Set.
Creación de un HashSet
Para crear un conjunto hash, debemos importar el java.util.HashSet paquete primero.
Una vez que importamos el paquete, así es como podemos crear conjuntos hash en Java.
// HashSet with 8 capacity and 0.75 load factor
HashSet<Integer> numbers = new HashSet<>(8, 0.75);
Aquí, hemos creado un conjunto hash llamado numbers .
Aviso, la parte nueva HashSet<>(8, 0.75) . Aquí, el primer parámetro es capacidad , y el segundo parámetro es loadFactor .
- capacidad - La capacidad de este conjunto hash es 8. Es decir, puede almacenar 8 elementos.
- factor de carga - El factor de carga de este conjunto hash es 0,6. Esto significa que, cada vez que nuestro conjunto hash se llena en un 60 %, los elementos se mueven a una nueva tabla hash del doble del tamaño de la tabla hash original.
Capacidad predeterminada y factor de carga
Es posible crear una tabla hash sin definir su capacidad y factor de carga. Por ejemplo,
// HashSet with default capacity and load factor
HashSet<Integer> numbers1 = new HashSet<>();
Por defecto,
- la capacidad del conjunto hash será 16
- el factor de carga será 0,75
Métodos de HashSet
El HashSet class proporciona varios métodos que nos permiten realizar varias operaciones en el conjunto.
Insertar elementos en HashSet
add()- inserta el elemento especificado en el conjuntoaddAll()- inserta todos los elementos de la colección especificada en el conjunto
Por ejemplo,
import java.util.HashSet;
class Main {
public static void main(String[] args) {
HashSet<Integer> evenNumber = new HashSet<>();
// Using add() method
evenNumber.add(2);
evenNumber.add(4);
evenNumber.add(6);
System.out.println("HashSet: " + evenNumber);
HashSet<Integer> numbers = new HashSet<>();
// Using addAll() method
numbers.addAll(evenNumber);
numbers.add(5);
System.out.println("New HashSet: " + numbers);
}
}
Salida
HashSet: [2, 4, 6] New HashSet: [2, 4, 5, 6]
Acceso a elementos de HashSet
Para acceder a los elementos de un conjunto hash, podemos usar el iterator() método. Para usar este método, debemos importar el java.util.Iterator paquete. Por ejemplo,
import java.util.HashSet;
import java.util.Iterator;
class Main {
public static void main(String[] args) {
HashSet<Integer> numbers = new HashSet<>();
numbers.add(2);
numbers.add(5);
numbers.add(6);
System.out.println("HashSet: " + numbers);
// Calling iterator() method
Iterator<Integer> iterate = numbers.iterator();
System.out.print("HashSet using Iterator: ");
// Accessing elements
while(iterate.hasNext()) {
System.out.print(iterate.next());
System.out.print(", ");
}
}
}
Salida
HashSet: [2, 5, 6] HashSet using Iterator: 2, 5, 6,
Eliminar elementos
remove()- elimina el elemento especificado del conjuntoremoveAll()- elimina todos los elementos del conjunto
Por ejemplo,
import java.util.HashSet;
class Main {
public static void main(String[] args) {
HashSet<Integer> numbers = new HashSet<>();
numbers.add(2);
numbers.add(5);
numbers.add(6);
System.out.println("HashSet: " + numbers);
// Using remove() method
boolean value1 = numbers.remove(5);
System.out.println("Is 5 removed? " + value1);
boolean value2 = numbers.removeAll(numbers);
System.out.println("Are all elements removed? " + value2);
}
}
Salida
HashSet: [2, 5, 6] Is 5 removed? true Are all elements removed? true
Establecer operaciones
Los diversos métodos del HashSet La clase también se puede usar para realizar varias operaciones de conjuntos.
Unión de Conjuntos
Para realizar la unión entre dos conjuntos, podemos usar el addAll() método. Por ejemplo,
import java.util.HashSet;
class Main {
public static void main(String[] args) {
HashSet<Integer> evenNumbers = new HashSet<>();
evenNumbers.add(2);
evenNumbers.add(4);
System.out.println("HashSet1: " + evenNumbers);
HashSet<Integer> numbers = new HashSet<>();
numbers.add(1);
numbers.add(3);
System.out.println("HashSet2: " + numbers);
// Union of two set
numbers.addAll(evenNumbers);
System.out.println("Union is: " + numbers);
}
}
Salida
HashSet1: [2, 4] HashSet2: [1, 3] Union is: [1, 2, 3, 4]
Intersección de Conjuntos
Para realizar la intersección entre dos conjuntos, podemos usar el retainAll() método. Por ejemplo
import java.util.HashSet;
class Main {
public static void main(String[] args) {
HashSet<Integer> primeNumbers = new HashSet<>();
primeNumbers.add(2);
primeNumbers.add(3);
System.out.println("HashSet1: " + primeNumbers);
HashSet<Integer> evenNumbers = new HashSet<>();
evenNumbers.add(2);
evenNumbers.add(4);
System.out.println("HashSet2: " + evenNumbers);
// Intersection of two sets
evenNumbers.retainAll(primeNumbers);
System.out.println("Intersection is: " + evenNumbers);
}
}
Salida
HashSet1: [2, 3] HashSet2: [2, 4] Intersection is: [2]
Diferencia de Conjuntos
Para calcular la diferencia entre los dos conjuntos, podemos usar el removeAll() método. Por ejemplo,
import java.util.HashSet;
class Main {
public static void main(String[] args) {
HashSet<Integer> primeNumbers = new HashSet<>();
primeNumbers.add(2);
primeNumbers.add(3);
primeNumbers.add(5);
System.out.println("HashSet1: " + primeNumbers);
HashSet<Integer> oddNumbers = new HashSet<>();
oddNumbers.add(1);
oddNumbers.add(3);
oddNumbers.add(5);
System.out.println("HashSet2: " + oddNumbers);
// Difference between HashSet1 and HashSet2
primeNumbers.removeAll(oddNumbers);
System.out.println("Difference : " + primeNumbers);
}
}
Salida
HashSet1: [2, 3, 5] HashSet2: [1, 3, 5] Difference: [2]
Subconjunto
Para verificar si un conjunto es un subconjunto de otro conjunto o no, podemos usar el containsAll() método. Por ejemplo,
import java.util.HashSet;
class Main {
public static void main(String[] args) {
HashSet<Integer> numbers = new HashSet<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(4);
System.out.println("HashSet1: " + numbers);
HashSet<Integer> primeNumbers = new HashSet<>();
primeNumbers.add(2);
primeNumbers.add(3);
System.out.println("HashSet2: " + primeNumbers);
// Check if primeNumbers is a subset of numbers
boolean result = numbers.containsAll(primeNumbers);
System.out.println("Is HashSet2 is subset of HashSet1? " + result);
}
}
Salida
HashSet1: [1, 2, 3, 4] HashSet2: [2, 3] Is HashSet2 is a subset of HashSet1? true
Otros métodos de HashSet
| Método | Descripción |
|---|---|
clone() | Crea una copia del HashSet |
contains() | Busca el HashSet para el elemento especificado y devuelve un resultado booleano |
isEmpty() | Comprueba si el HashSet está vacío |
size() | Devuelve el tamaño del HashSet |
clear() | Elimina todos los elementos del HashSet |
Para obtener más información sobre los métodos HashSet, visite Java HashSet (documentación oficial de Java).
¿Por qué HashSet?
En Java, HashSet se usa comúnmente si tenemos que acceder a elementos aleatoriamente. Se debe a que se accede a los elementos de una tabla hash mediante códigos hash.
El código hash de un elemento es una identidad única que ayuda a identificar el elemento en una tabla hash.
HashSet no puede contener elementos duplicados. Por lo tanto, cada elemento del conjunto hash tiene un código hash único.
Java