Pausa para el café #185. Una guía completa para el marco de la colección Java

Fuente: Medio Este tutorial le ayudará a comprender mejor el funcionamiento de las distintas clases e interfaces incluidas en Java Collection Framework. Java Collection es un marco que proporciona una arquitectura unificada para almacenar y administrar un grupo de objetos. En esencia, es un conjunto de clases e interfaces que proporcionan una forma estándar de representar y manipular colecciones de objetos en el lenguaje Java. El marco también ayuda a implementar estructuras de datos de uso común, como Lista, Conjunto y Mapa. Java Collection Framework incluye varias interfaces y clases. Aquí hay una lista de algunos de ellos:

Interfaces

Las interfaces en Java Collection Framework definen el comportamiento general y las operaciones que se pueden realizar en las colecciones. Esto incluye agregar o eliminar elementos, repetir elementos en una colección y más.

• Colección : la interfaz raíz en una jerarquía de colección, que representa un grupo de objetos conocidos como elementos.
• Lista : Colección ordenada de elementos que permite la duplicación.
• Conjunto : colección de elementos que no permiten duplicación.
• Mapa : una colección de pares clave-valor, donde cada clave es única.
• Cola : una cola es una estructura de datos que se utiliza para almacenar elementos en orden primero en entrar, primero en salir (FIFO).

Esta lista no incluye todo, sino solo las interfaces más utilizadas en Java Collection Framework. Ahora echemos un vistazo más de cerca a cada uno de ellos.

Recopilación

Una Colección es un grupo de objetos conocidos como sus elementos. Este es un objeto que puede contener referencias a otros objetos. La interfaz de Colección es la raíz de la jerarquía de colecciones. Esta es la interfaz base para todas las colecciones en Java Collection Framework. Define los métodos básicos que deben implementarse en todas las colecciones, como add() , remove() y contains() . A continuación se muestra un ejemplo del uso de colecciones en Java Collection Framework. Aquí, la interfaz Colección se utiliza para agregar y eliminar elementos de una colección:

import java.util.Collection;
import java.util.ArrayList;

public class CollectionExample {
    public static void main(String[] args) {
        // Создаем новую коллекцию
        Collection<String> stringCollection = new ArrayList<>();

        // Добавляем несколько элементов в коллекцию
        stringCollection.add("hello");
        stringCollection.add("world");
        stringCollection.add("foo");
        stringCollection.add("bar");

        // Печатаем число элементов в коллекции
        System.out.println("Number of elements: " + stringCollection.size());

        // Удаляем элемент из коллекции
        stringCollection.remove("foo");

        // Опять печатаем число элементов в коллекции
        System.out.println("Number of elements: " + stringCollection.size());
    }
}

La salida es: Como puede ver, la interfaz Colección es una forma sencilla y conveniente de realizar operaciones comunes con una colección de objetos. A menudo se utiliza como punto de partida cuando se trabaja con colecciones en Java. Java Collection Framework incluye varias interfaces que definen el comportamiento común para diferentes tipos de colecciones. Algunos de ellos forman parte del grupo de interfaz java.util.Collection :

• java.util.List
• java.util.set
• java.util.Cola

java.util.List

Una lista es una colección ordenada de objetos, cada elemento de los cuales ocupa una posición específica en la lista. La interfaz Lista amplía la interfaz Colección y agrega varios métodos para trabajar con listas, como métodos para acceder a elementos por su posición en la lista y métodos para buscar y ordenar listas. Una Lista puede contener elementos duplicados , se puede acceder a estos elementos por su posición en la lista. A continuación se muestra un ejemplo del uso de la interfaz Lista para agregar, eliminar y acceder a elementos en una lista:

import java.util.List;
import java.util.ArrayList;

public class ListExample {
    public static void main(String[] args) {
        // Создаем новый список
        List<String> stringList = new ArrayList<>();

        // Добавляем несколько элементов в список
        stringList.add("India");
        stringList.add("UAE");
        stringList.add("London");
        stringList.add("US");

        // Печатаем первый элемент в списке
        System.out.println("First element: " + stringList.get(0));

        // Удаляем второй элемент из списка
        stringList.remove(1);

        // Печатаем второй элемент в списке
        System.out.println("Second element: " + stringList.get(1));
    }
}

Conclusión: Como se muestra arriba, la interfaz Lista proporciona una manera conveniente de trabajar con colecciones ordenadas de elementos. Generalmente se usa cuando necesita mantener el orden de los elementos en una colección o cuando necesita acceder a elementos por su índice en una lista.

java.util.Set

Un conjunto en Java Collection Framework es un conjunto desordenado de elementos únicos que no permite elementos duplicados . La interfaz Set extiende la interfaz Collection y agrega varios métodos, como métodos para verificar si un elemento está en un conjunto y métodos para agregar y eliminar elementos de un conjunto. A continuación se muestra un ejemplo del uso de la interfaz Set para agregar y eliminar elementos de un conjunto en Java Collection Framework:

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

public class SetExample {
    public static void main(String[] args) {
        // Создаем новый set
        Set<String> stringSet = new HashSet<>();

        // Добавляем несколько элементов в set
        stringSet.add("Jan");
        stringSet.add("Feb");
        stringSet.add("March");
        stringSet.add("April");

        // Проверяем наличие в set elemento "March"
        if (stringSet.contains("March")) {
            System.out.println("The set contains the element 'March'");
        }

        // Удаляем элемент "April" из set
        stringSet.remove("April");

        // Опять проверяем наличие elemento "April" в set
        if (!stringSet.contains("April")) {
            System.out.println("The set no longer contains the element 'April'");
        }
    }
}

Conclusión:

java.util.Cola

Una cola es una estructura de datos que se utiliza para almacenar elementos en orden primero en entrar, primero en salir (FIFO). Esto significa que el primer elemento agregado a la cola será el primer elemento eliminado. A continuación se muestra un ejemplo de cómo utilizar una cola en Java Collection Framework:

// Creación очереди
Queue<String> queue = new LinkedList<>();

// Добавление элементов в очередь
queue.add("apple");
queue.add("banana");
queue.add("orange");
// Печатаем очередь
System.out.println("Queue: " + queue);
// Удаляем элемент из очереди
String element = queue.remove();
System.out.println("Removed element: " + element);
// Печатаем обновленную очередь
System.out.println("Queue: " + queue);

En este ejemplo, creamos una cola de cadenas y le agregamos tres elementos: "manzana", "plátano" y "naranja". Luego imprimimos la cola para ver su estado actual. A continuación, eliminamos el elemento de la cola y lo imprimimos en la consola. Finalmente, imprimimos la cola actualizada para asegurarnos de que el elemento eliminado ya no esté en la cola.

Mapa

La interfaz java.util.Map en Java Collection Framework se utiliza para asignar claves a valores. Le permite almacenar elementos como pares clave-valor y proporciona métodos para acceder, modificar e iterar elementos en un mapa. A continuación se muestra un ejemplo del uso de la interfaz del Mapa :

// Создаем Map
 Map<String, Integer> map = new  HashMap <>();
// Добавляем элементы в Map
map.put("apple", 1);
map.put("banana", 2);
map.put("orange", 3);
// Печать Map
 System.out.println("Map: " + map);
// Получаем significado для определенного ключа
int  value  = map.get( "banana" );
System.out.println("Value for 'banana': " + value);
// Удаляем элемент из Map
map.remove("orange");
// Печать обновленной карты
 System.out.println( "Map: " + map);

En este ejemplo, creamos un mapa de cadenas y números enteros agregándole tres elementos: "manzana" coincide con 1, "plátano" coincide con 2 y "naranja" coincide con 3. Luego imprimimos el mapa para ver su significado actual. Después de eso, obtenemos el valor de la clave "banana" y lo imprimimos en la consola. Finalmente, eliminamos el par clave-valor de "naranja" del mapa e imprimimos el mapa actualizado para ver que el elemento eliminado ya no está allí.

Clases

Una clase es una implementación concreta de una interfaz de colección. Proporciona implementaciones específicas de comportamientos y operaciones comunes definidas por interfaces en el marco.

• ArrayList : una implementación de la interfaz List con una matriz redimensionable.
• LinkedList : una lista doblemente enlazada, una implementación de las interfaces List y Deque .
• HashSet : una implementación de Set que utiliza una tabla hash para el almacenamiento.
• TreeSet : una implementación de Set que utiliza un árbol para almacenamiento.
• HashMap : una implementación de Map que utiliza una tabla hash para el almacenamiento.

La lista anterior es una de las clases más utilizadas en Java Collection Framework. Ahora veamos la explicación detallada de estas clases.

Lista de arreglo

La clase java.util.ArrayList en las colecciones de Java se utiliza para almacenar una matriz de elementos de tamaño variable en una lista. Es una implementación ampliamente utilizada de la interfaz java.util.List que utiliza una matriz para almacenar elementos y proporciona métodos eficientes para acceder, modificar e iterar a través de elementos en una lista. La clase java.util.ArrayList proporciona un acceso aleatorio rápido a sus elementos, pero una inserción y eliminación lenta en posiciones aleatorias. A continuación se muestra un ejemplo del uso de la clase ArrayList en Java Collection Framework:

// Создаем array list
List<String> list = new ArrayList<>();
// Добавляем элементы в array list
list.add("qa");
list.add("devops");
list.add("dev");
// Печатаем array list
System.out.println("Array list: " + list);
// Доступ к элементу по определенному индексу
String element = list.get(1);
System.out.println("Element at index 1: " + element);
// Удаление elemento из the array list
list.remove(1);
// Print the updated array list
System.out.println("Array list: " + list);

Como puede ver, creamos una matriz de cadenas y le agregamos tres elementos: "qa", "devops" y "dev". Luego imprimimos la lista de la matriz para ver su estado actual. Luego de esto, accedemos al elemento en el índice 1 y lo imprimimos en la consola. Finalmente, eliminamos el elemento en el índice 1 de la lista de matriz e imprimimos una lista de matriz actualizada para asegurarnos de que el elemento eliminado ya no esté en la lista.

Lista enlazada

La clase java.util.LinkedList en Java Collection Framework hereda de la clase AbstractList e implementa las interfaces List y Deque . Proporciona métodos eficientes para agregar, eliminar y acceder a elementos al principio y al final de una lista. Esta clase también es una implementación de la interfaz List , que utiliza una lista doblemente enlazada para almacenar elementos. Proporciona inserción y eliminación rápidas en posiciones arbitrarias, pero acceso aleatorio lento a sus elementos. A continuación se muestra un ejemplo de cómo utilizar la clase LinkedList en Java Collection Framework:

// Создаем linked list
List<String> list = new LinkedList<>();
// Добавляем элементы в linked list
list.add("selenium");
list.add("cypress");
list.add("playwright");
// Печатаем linked list
System.out.println("Linked list: " + list);
// Добавляем элемент в начало списка
list.add(0, "webdriver.io");
// Печатаем обновленный linked list
System.out.println("Linked list: " + list);
// Удаляем первый элемент в списке
list.remove(0);
// Еще раз печатаем обновленный linked list
System.out.println("Linked list: " + list);

En este ejemplo, creamos una lista vinculada de cadenas y le agregamos tres elementos: "selenio", "ciprés" y "dramaturgo". Luego imprimimos la lista vinculada para ver su estado actual. A continuación, agregamos el elemento "webdriver.io" al principio de la lista e imprimimos la lista enlazada actualizada. Finalmente, eliminamos el primer elemento de la lista e imprimimos la lista enlazada actualizada nuevamente para ver que el elemento eliminado ya no está en la lista.

Conjunto de hash

La clase java.util.HashSet en Java Collection Framework se utiliza para almacenar una colección de elementos únicos en un conjunto. Proporciona una implementación basada en tablas hash de la interfaz java.util.Set . También proporciona inserción, eliminación y búsqueda rápidas, pero no conserva el orden de sus elementos. A continuación se muestra un ejemplo del uso de la clase HashSet en Java Collection Framework:

// Создаем hash set
Set<String> set = new HashSet<>();

// Добавляем элементы в hash set
set.add("rose");
set.add("lily");
set.add("lotus");
// Попытка добавить повторяющийся элемент
set.add("rose");
// Печатаем hash set
System.out.println("Hash set: " + set);
// Удаляем элемент из hash set
set.remove("lily");
// Печать обновленного hash set
System.out.println("Hash set: " + set);

Aquí creamos un conjunto hash de cadenas y le agregamos tres elementos: "rosa", "lirio" y "loto". Luego intentamos agregar el elemento "rosa" nuevamente, pero como el conjunto de hash no permite duplicados, no se agregará. Después de esto imprimimos el conjunto de hash para ver su estado actual. Luego eliminamos el elemento "lirio" del conjunto e imprimimos el hash actualizado del conjunto para ver que el elemento eliminado ya no está en el conjunto.

Conjunto de árboles

La clase java.util.TreeSet en Java Collection Framework se utiliza para almacenar una colección de elementos únicos en un conjunto ordenados en orden ascendente. Proporciona una implementación basada en árbol de la interfaz java.util.Set para almacenar elementos sin permitir elementos duplicados. La clase proporciona inserción, eliminación y búsqueda rápidas y mantiene el orden de sus elementos según su orden natural o comparador. A continuación se muestra un ejemplo de cómo utilizar la clase TreeSet en Java Collection Framework:

// Создаем tree set
Set<String> set = new TreeSet<>();

// Добавляем элементы в tree set
set.add("apple");
set.add("banana");
set.add("orange");
// Попытка добавить повторяющийся элемент
set.add("apple");
// Печатаем tree set
System.out.println("Tree set: " + set);
// Удаляем элемент из tree set
set.remove("banana");
// Печатаем обновленный tree set
System.out.println("Tree set: " + set);

En este ejemplo, creamos un conjunto de cadenas de árbol y le agregamos tres elementos: "manzana", "plátano" y "naranja". Luego intentamos agregar el elemento "manzana" nuevamente, pero como el conjunto de árboles no permite duplicados, no se agregará. Después de esto imprimimos el conjunto de árboles para ver su estado actual. Dado que el conjunto de árboles está ordenado en orden ascendente, los elementos se imprimirán en el orden: “manzana”, “plátano” y “naranja”. Luego eliminamos el elemento "plátano" del conjunto e imprimimos el conjunto de árboles actualizado para ver que el elemento eliminado ya no está en el conjunto.

HashMap

La clase java.util.HashMap en Java Collection Framework se utiliza para almacenar la asignación de claves a valores en un mapa. Proporciona una implementación basada en tablas hash de la interfaz java.util.Map y permite almacenar elementos como pares clave-valor. La clase proporciona inserción, eliminación y búsqueda rápidas, pero no conserva el orden de sus elementos. A continuación se muestra un ejemplo de cómo utilizar la clase HashMap en Java Collection Framework:

// Создаем hash map
Map<String, Integer> map = new HashMap<>();

// Добавляем элементы в hash map
map.put("apple", 1);
map.put("banana", 2);
map.put("orange", 3);
// Печатаем hash map
System.out.println("Hash map: " + map);
// Получаем significado для определенного ключа
int value = map.get("banana");
System.out.println("Value for 'banana': " + value);
// Удаляем элемент из hash map
map.remove("orange");
// Печатаем обновленный hash map
System.out.println("Hash map: " + map);

En este ejemplo, creamos un mapa hash de cadenas de números enteros y le agregamos tres elementos: "manzana" coincide con 1, "plátano" coincide con 2 y "naranja" coincide con 3. Luego imprimimos el mapa hash para ver su estado actual. Después de eso, obtenemos el valor de la clave "banana" y lo imprimimos en la consola. Finalmente, eliminamos el par clave-valor para "naranja" del mapa hash e imprimimos el mapa hash actualizado para ver que el elemento eliminado ya no está en él.

Conclusión

Java Collection Framework es un conjunto de clases e interfaces que proporcionan una forma estándar de representar y manipular colecciones de objetos en el lenguaje de programación Java. Esto permite a los desarrolladores/probadores trabajar con colecciones de objetos de manera consistente y eficiente. El marco les proporciona métodos para almacenar, acceder y administrar elementos de una colección, y les permite cambiar fácilmente entre diferentes implementaciones de colección según los requisitos de la aplicación.