CodeGym /Blog Java /Random-ES /Conjunto Java
Autor
Jesse Haniel
Lead Software Architect at Tribunal de Justiça da Paraíba

Conjunto Java

Publicado en el grupo Random-ES
Set es una interfaz en Java Collection Framework. Puede usar Java Set para implementar colecciones desordenadas con elementos únicos. En este artículo, veremos esta interfaz y sus implementaciones en el lenguaje Java, los métodos para trabajar con un conjunto y también daremos algunos ejemplos.

¿Qué es el conjunto de Java?

Set es una interfaz de Java Collection Framework, pero Set no es una colección ordenada, a diferencia de List . Eso significa que los elementos de Java Set se mantienen sin un orden particular. Por lo tanto, no hay control sobre la posición en la que puede insertar un elemento. Además, no puede acceder a los elementos por su índice. Matemáticamente, un Conjunto es una colección de elementos únicos. De hecho, se trata de una Colección desordenada (Colección desordenada), en la que no se pueden almacenar elementos idénticos. Si agrega intencionalmente un elemento duplicado a un Conjunto , esta acción se ignorará y el Conjunto no cambiará. Sin embargo, está permitido almacenar un elemento nulo en él.

Establecer implementaciones

Java Set es una interfaz, por lo que debe usar una de sus implementaciones para crear objetos. Estos son HashSet , TreeSet y LinkedHashSet . En Set s, cada elemento se almacena en una sola instancia, y diferentes implementaciones de Set usan un orden diferente para almacenar elementos. En un HashSet , el orden de los elementos está determinado por un algoritmo complejo. Si el orden de almacenamiento es importante para usted, use un contenedor TreeSet , que almacena objetos ordenados en orden ascendente en orden de comparación, o un LinkedHashSet, que almacena elementos en orden adicional. Los conjuntos se utilizan a menudo para las pruebas de pertenencia, de modo que pueda verificar fácilmente si un objeto pertenece a un conjunto determinado, por lo que, en la práctica, generalmente se elige una implementación de HashSet que está optimizada para una búsqueda rápida. HashSet es una colección que usa sus valores hash devueltos por el método hashCode() para almacenar elementos internamente. Es decir, dentro del HashSet<E> , se almacena el objeto HashMap<E, Object> , que almacena los valores del HashSet como claves. El uso de códigos hash le permite buscar, agregar y eliminar rápidamente elementos de un conjunto . LinkedHashSet es un HashSetque también almacena elementos en una lista enlazada. Un HashSet normal no mantiene el orden de los elementos. En primer lugar, oficialmente simplemente no existe y, en segundo lugar, incluso el orden interno puede cambiar drásticamente cuando se agrega un solo elemento. Y puede obtener un iterador de LinkedHashSet y usarlo para recorrer todos los elementos en el orden exacto en que se agregaron al LinkedHashSet . No muy a menudo, pero a veces puede ser muy necesario. Un TreeSet es una colección que almacena elementos como un árbol ordenado por valores. Dentro de TreeSet<E> hay un TreeMap<E, Object> que almacena todos estos valores. Y este TreeMaputiliza un árbol binario equilibrado rojo-negro para almacenar elementos. Por lo tanto, tiene operaciones add() , remove() y contains() muy rápidas.

Crear un objeto de conjunto

Para crear un Set Object puedes usar uno de los siguientes formularios:

Set<Integer> intSet = new HashSet<>();
Set<String> vSet = new HashSet<>();
Set mySet = new LinkedHashSet();
HashSet<String> myHashset = new HashSet<>();
Aquí hay un ejemplo simple, donde creamos 2 Set s, HashSet y LinkedHashSet , y agregamos 5 elementos a cada uno. Podemos usar el método add() para esto.

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;

public class HashSetTest {
    public static void main(String[] args) {
        Set mySet = new HashSet();
        Set mySet2 = new LinkedHashSet();
//adding some string elements
        mySet.add("Stuart");
        mySet.add("Alex");
        mySet.add("Johnny");
        mySet.add("Igor");
        mySet.add("Bel");
        System.out.println(mySet);
        mySet2.add("Stuart");
        mySet2.add("Alex");
        mySet2.add("Johnny");
        mySet2.add("Igor");
        mySet2.add("Bel");
        System.out.println(mySet2);
    }
}
Aquí está la salida del programa:
[Alex, Igor, Stuart, Johnny, Bel] [Stuart, Alex, Johnny, Igor, Bel]
Como mencionamos anteriormente, HashSet no mantiene el orden de los elementos, pero LinkedHashSet sí. Fue LinkedHashSet el que nos proporcionó los elementos en el orden en que los escribimos en el conjunto.

Métodos de conjuntos de Java

Estos son algunos de los métodos importantes de Java Set :
  • suma booleana(E e) . Agrega el elemento especificado al conjunto si aún no está presente (operación opcional).

  • eliminación booleana (Objeto o) . Elimina el elemento especificado de este conjunto si está presente (operación opcional).

  • booleano removeAll(Colección c) . Elimina de este conjunto todos sus elementos que están contenidos en la colección especificada (operación opcional).

  • booleano retenerTodo(Colección c) . Conserva solo los elementos de este conjunto que están contenidos en la colección especificada (operación opcional).

  • anular claro() . Elimina todos los elementos del conjunto.

  • Iterador iterador() . Devuelve un iterador sobre los elementos de este conjunto.

  • tamaño int() . se utiliza para obtener el número de elementos en el Conjunto.

  • booleano estáVacío() . para comprobar si Set está vacío o no.

  • booleano contiene (Objeto o) . Devuelve verdadero si este Conjunto contiene el elemento especificado.

  • Iterador iterador() . Devuelve un iterador sobre los elementos de este conjunto. Los elementos se devuelven sin ningún orden en particular.

  • Objeto[] aArray() . Devuelve una matriz que contiene todos los elementos de este conjunto. Si este conjunto garantiza en qué orden su iterador devuelve sus elementos, este método debe devolver los elementos en el mismo orden.

Los métodos son similares a los de ArrayList , excepto que el método add(Object o) solo agrega un objeto al conjunto si aún no está allí. El valor de retorno del método es verdadero si el objeto ha sido agregado y falso en caso contrario. También hay algunos métodos heredados de la interfaz Collection<> : parallelStream() , removeIf() , stream() y forEach() heredados de la interfaz java.lang.Iterable .

Ejemplo de operaciones principales de Java Set

En este ejemplo, creamos una matriz de cadenas y luego la pasamos a mySet usando la operación Arrays.asList . Luego eliminamos un par de elementos más y agregamos un par más. En este caso, uno de los elementos del conjunto ya existe: no se añadirá. También intentaremos las operaciones de comprobar si hay vacío isEmpty() , determinar el tamaño del conjunto size() y borrar el conjunto de todos los elementos clear() .

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

public class HashSetTest2 {
   public static void main(String[] args) {
       //creating a string Array with some names
       String [] friends =  {"Stuart", "Ivy", "Johnny", "Alex", "Igor", "Tanya"};
       //creating a new set and adding elements from string array into it
       Set<String> mySet = new HashSet<>(Arrays.asList(friends));
       System.out.println(mySet);
       //removing two elements from the set
       mySet.remove("Igor");
       mySet.remove("Stuart");

       System.out.println(mySet);

       //adding 2 new Elements into set
       mySet.add("Dasha");
       mySet.add("Alex"); //it's second Alex, can't be added
       System.out.println(mySet);
       //cheking the size of mySet
       int size = mySet.size();
       System.out.println("The quantity of set's elements = " + size);
       //Checking if the set is empty
       System.out.println("Is mySet empty? " + mySet.isEmpty());
       //checking if some elements are in set
       System.out.println("Is Igor in set? " + mySet.contains("Igor"));
       System.out.println("Is Johnny in set? "+ mySet.contains("Johnny"));
       //deleting all elements from the set
       mySet.clear();
       System.out.println("Is mySet empty now? " + mySet.isEmpty());

   }
}
La salida del programa está aquí:
[Alex, Igor, Stuart, Tanya, Johnny, Ivy] [Alex, Tanya, Johnny, Ivy] [Alex, Dasha, Tanya, Johnny, Ivy] La cantidad de elementos del conjunto = 5 ¿Está mySet vacío? falso ¿Igor está en el set? false ¿Está Johnny en el set? true ¿MySet está vacío ahora? verdadero

Ejemplo con LinkedHashSet y configurado en Array

Escribamos otro programa. En él, crearemos un conjunto basado en LinkedHashSet , le agregaremos elementos y luego convertiremos el conjunto en una matriz.

import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.Set;
   public class LinkedHashSet3 {
       public static void main(String[] args) {
           Set<String> set = new LinkedHashSet<>();
           set.add("C");
           set.add("D");
           set.add("E");
           set.add("F");
           set.add("G");
           set.add("A");
           set.add("B");
           System.out.println(set);
           set.remove("F");// removing an element from our set
           set.remove("C sharp");//trying to remove element that isn't in set
           System.out.println(set.remove("C sharp"));
           System.out.println("Print our set with elements removed: ");
           System.out.println(set);

//set to array
           String strArray[] = set.toArray(new String[set.size()]);
           System.out.println("New Array from set: ");
           System.out.println(Arrays.toString(strArray));
           System.out.println(strArray[0]);

       }
   }
Aquí está la salida del programa:
[C, D, E, F, G, A, B] false Imprime nuestro conjunto con los elementos eliminados: [C, D, E, G, A, B] Nueva matriz del conjunto: [C, D, E, G, A B] C

Establecer ejemplo con iterador

Vamos a crear un conjunto, luego imprimirlo usando un iterador y luego eliminar todos los números pares, también usando un iterador.

import java.util.*;

public class SetTest5
{
   public static void main(String[] args)
   {

       Set<Integer> mySet = new HashSe<>();
       for(int i = 0; i < 10; i++)
           mySet.add(i);

       Iterator iterator = mySet.iterator();

       //simple iteration
       while(iterator.hasNext()){
           int i = (int) iterator.next();
       }
       System.out.println(" " + mySet);

       //modification of mySet using iterator - removing all even numbers
       iterator = mySet.iterator();
       while(iterator.hasNext()){
           int x = (int) iterator.next();
           if(x%2 == 0) iterator.remove();
       }
       System.out.println(mySet);

       }
}
La salida del programa está aquí:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] [1, 3, 5, 7, 9

Ejemplo con TreeSet

Si la clasificación es importante para usted, utilice la implementación de TreeSet . En este breve ejemplo, completaremos el conjunto con los nombres de los amigos, como en los ejemplos anteriores. Sin embargo, en un TreeSet ordenado , los elementos se escribirán inmediatamente en orden ordenado. En este caso, los nombres se mostrarán en orden alfabético.

import java.util.Set;
import java.util.TreeSet;
public class TreeSetTest {

   public static void main(String[] args) {

       Set mySet = new TreeSet<>();
       mySet.add("Stuart");
       mySet.add("Alex");
       mySet.add("Johnny");
       mySet.add("Igor");
       mySet.add("Bel");
       System.out.println(mySet);

   }
La salida es:
[Alex, Bel, Igor, Johnny, Stuart]

Breves conclusiones

  • La interfaz de Java Set es parte de Java Collections Framework.

  • Clases implementadas: AbstractSet , ConcurrentHashMap.KeySetView , ConcurrentSkipListSet , CopyOnWriteArraySet , EnumSet , HashSet , JobStateReasons , LinkedHashSet , TreeSet .

  • Las implementaciones de conjuntos más populares son HashSet , LinkedHashSet y TreeSet .

  • El orden de los elementos HashSet está determinado por un algoritmo complejo. Si el orden de almacenamiento es importante para usted, use un contenedor TreeSet , que almacena objetos clasificados en orden ascendente en orden de comparación, o un LinkedHashSet , que almacena elementos en orden adicional.

  • La mayoría de las veces, los conjuntos se utilizan para probar la pertenencia. Es decir, comprobar si un objeto pertenece a un conjunto dado en el sentido matemático. Entonces, la mayoría de las implementaciones de Set en la práctica, generalmente se elige HashSet . Esta implementación está optimizada para una búsqueda rápida.

  • No puede agregar elementos duplicados a un conjunto, por lo que puede usar implementaciones de la interfaz Conjunto para almacenar elementos únicos.

  • Set le permite agregar solo un elemento nulo.

  • Set no es una lista y no admite índices o posiciones de sus elementos.

Comentarios
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION