Colecciones en Java

¿Qué es la colección en Java?

Una colección en java se representa como un contenedor que agrupa todos los elementos en una sola unidad. Por ejemplo , una carpeta de correo (grupo de correos electrónicos), un directorio telefónico (asignación de nombres a números de teléfono).

¿Qué es un marco?

Un marco es una base o diseño básico sobre el cual comienzas a trabajar utilizando las diferentes clases e interfaces proporcionadas. Por ejemplo , Laravel es uno de los frameworks PHP más famosos que proporciona un esqueleto básico para su aplicación.

¿Qué es el marco de colecciones en Java?

Todos los objetos se agrupan en un solo objeto junto con una arquitectura que representa y proporciona diferentes métodos para manipular colecciones. Por lo tanto, el marco de Colecciones en Java proporciona diferentes estructuras de datos ya implementadas para almacenar datos y métodos, para manipularlos con funciones como clasificación, búsqueda, eliminación e inserción . Por ejemplo , desea implementar un sistema para que alguna empresa aleatoria mejore el servicio a sus clientes, basándose en el orden de llegada. Esto también se conoce como implementación FIFO (primero en entrar, primero en salir). Ahora necesitamos implementar esta estructura de datos y luego usarla para lograr nuestro objetivo. El marco de Colecciones nos proporciona una interfaz de cola que solo necesitamos importar en lugar de implementar, luego usarla y listo. Implementación : puede importar todas las colecciones utilizando la siguiente línea:

import java.util.*;

Si desea importar una colección específica, utilice el nombre exacto del paquete, como por ejemplo:

import java.util.LinkedList;

Beneficios del marco de colecciones en Java

Tiene los siguientes beneficios.

1. Ya implementado (ahorro de tiempo).
2. Rendimiento Eficiencia (rapidez y calidad).
3. Reduce el esfuerzo para aprender y utilizar nuevas API.

¿Cuál es la jerarquía del marco de recopilación?

Ahora veamos la jerarquía de las colecciones, pero primero necesitamos conocer los componentes esenciales de este marco.

1. Interfaces
2. Clases (implementación)
3. Algoritmos

Jerarquía del marco de recopilación

Para su entendimiento:

1. Colección, Conjunto, Cola y Lista son todas interfaces. Conjunto, cola y lista se amplían mediante la interfaz Colección.
2. PriorityQueue, HashSet, LinkedList y Stack son clases o la implementación de estas interfaces.
3. No es obligatorio que una clase implemente una sola interfaz. LinkedList también implementa la interfaz Deque, por ejemplo.

Tipos de colecciones

El marco de colecciones de Java tiene muchos tipos de colecciones para reducir nuestros esfuerzos. Aquí hay una lista de algunas de las colecciones:

1. Clase ArrayList
2. Clase de lista vinculada
3. Interfaz de lista
4. Establecer interfaz
5. Interfaz de cola
6. Interfaz de mapa
7. Clase de cola prioritaria
8. Clase HashMap
9. Interfaz comparable
10. Clase LinkedHashMap
11. Clase TreeMap
12. Tabla de picadillo

Interfaces de colección

Aquí discutiremos algunas interfaces de colección comunes y luego algunos métodos implementados por las clases.

Interfaz de colección

Esta es una base básica para el marco de Colecciones, ya que proporciona todos los métodos necesarios para la implementación. El Mapa es la única estructura de datos que no lo implementa, pero el resto implementa sus métodos. Esta interfaz tiene métodos para conocer el tamaño de la colección y si existe un objeto en la colección, agregando o eliminando objetos de la colección.

Interfaz iterable

Es la interfaz raíz del marco de Colecciones, ya que la amplía la interfaz de Colección que implementan todas las clases. Devuelve un iterador para que la colección específica itere sobre ella.

Interfaz de cola

La cola se utiliza para contener los elementos pero no se pueden procesar. Al implementar las operaciones básicas de recolección, también proporciona métodos adicionales de inserción y extracción.

Establecer interfaz

El conjunto se utiliza para contener elementos únicos. Nunca contiene elementos duplicados y modela la abstracción de conjuntos matemáticos para representar conjuntos, como procesos que se ejecutan en una máquina.

Interfaz de lista

Una lista es una colección ordenada, a veces llamada secuencia, que puede contener elementos duplicados. Proporciona control al usuario para actualizar o eliminar un elemento específico, insertando un elemento en un punto específico utilizando su valor de índice entero. LinkedList y ArrayList son clases de implementación de la interfaz List.

Interfaz Deque

Deque significa cola de doble extremo, lo que significa que podemos realizar operaciones en ambos extremos. Podemos insertar y quitar elementos por ambos extremos. La interfaz Deque extiende la interfaz de cola. ArrayDeque y LinkedList implementan la interfaz Deque. Proporciona métodos para insertar, eliminar y examinar la instancia desde ambos extremos.

Interfaz de mapa

La interfaz del mapa también es parte del marco de Colecciones, pero no amplía la interfaz de la Colección. Se utiliza para almacenar pares clave-valor. Sus principales implementaciones son HashMap, TreeMap y LinkesHashMap, que son similares en ciertos aspectos a HashSet, TreeSet y LinkedHashSet. Siempre contiene claves únicas pero los valores se pueden duplicar. Es útil cuando necesita agregar, eliminar o buscar un elemento según una clave. Nos proporciona métodos básicos como poner , obtener , eliminar , dimensionar , vaciar , etc.

Métodos comunes de estas interfaces

Ahora veremos algunos métodos comunes proporcionados para la implementación de diferentes clases en este marco, excepto la interfaz Map.

Clases de colección

Como sabemos, el marco tiene diferentes interfaces que son implementadas por muchas clases dentro de él. Ahora echemos un vistazo a algunas clases de uso común.

Lista enlazada

Es la estructura de datos más utilizada que implementa una lista doblemente enlazada para almacenar los elementos que contiene. Puede almacenar elementos duplicados. Implementa la interfaz Dequeue extendida por la interfaz Queue y la interfaz List. No está sincronizado. Ahora veamos cómo resolver nuestro problema discutido anteriormente (el concepto FIFO) usando LinkedList. El problema es atender a los clientes de la manera en que llegan, es decir, el primero en entrar, el primero en salir .

Ejemplo

import java.util.*;
 
public class LinkedListExample {
    public static void main(String[] args) {
        Queue<String> customerQueue = new LinkedList<String>();
        //Adding customers to the Queue as they arrived
        customerQueue.add("John");
        customerQueue.add("Angelina");
        customerQueue.add("Brooke");
        customerQueue.add("Maxwell");
 
        System.out.println("Customers in Queue:"+customerQueue);
        //element() => returns head of the queue
        //we will see our first customer and serve him
        System.out.println("Head of the queue i.e first customer: "+customerQueue.element());
        //remove () method =>removes first element(customer) from the queue i.e the customer is served so remove him to see next
        System.out.println("Element removed from the queue: "+customerQueue.remove());
        //poll () => removes and returns the head
        System.out.println("Poll():Returned Head of the queue: "+customerQueue.poll());
        //print the remaining customers in the Queue
        System.out.println("Final Queue:"+customerQueue);
    }
}

Producción

Lista de arreglo

Simplemente implementa la interfaz Lista. Mantiene el orden de inserción y utiliza una matriz dinámica para almacenar elementos de diferentes tipos de datos. Los elementos se pueden duplicar. Tampoco está sincronizado y puede almacenar valores nulos. Ahora veamos sus diferentes métodos... Estos son útiles cuando no sabemos cuántos registros o elementos necesitamos insertar. Tomemos un ejemplo de una biblioteca donde no sabemos cuántos libros tenemos que conservar. Entonces, siempre que tengamos un libro, debemos insertarlo en ArrayList.

Ejemplo

public class ArrayListExample {
	public static void main(String args[]) {
		
		// Creating the ArrayList
		ArrayList<String> books = new ArrayList<String>();
		
		// Adding a book to the list
		books.add("Absalom, Absalom!");
		// Adding a book in array list
		books.add("A Time to Kill");
		// Adding a book to the list
		books.add("The House of Mirth");
		// Adding a book to the list
		books.add("East of Eden");
		// Traversing the list through Iterator
		Iterator<String> itr = books.iterator();
		while (itr.hasNext()) {
			System.out.println(itr.next());
		}
	}
}

Producción

Conjunto de hash

Implementa la interfaz Set y nunca contiene valores duplicados. Implementa la tabla hash para almacenar los valores. También permite valores nulos. Nunca mantiene el orden de inserción, pero proporciona un rendimiento de tiempo constante para los métodos add , remove , size y contains . Es mejor para operaciones de búsqueda y no está sincronizado.

Ejemplo

import java.util.*;  
class HashSetExample{  
    public static void main(String args[]){  
        //creating HashSet and adding elements to it  
        HashSet<Integer> hashSet=new HashSet();  
        hashSet.add(1);    
        hashSet.add(5);    
        hashSet.add(4);   
        hashSet.add(3);  
        hashSet.add(2);  
        //getting an iterator for the collection
        Iterator<Integer> i=hashSet.iterator(); 
        //iterating over the value 
        while(i.hasNext())  {  
            System.out.println(i.next());  
        }  
    }  
}

Producción

Como puedes ver no mantiene el orden de inserción.

ArrayDeque

Implementa la interfaz Deque por lo que permite operaciones desde ambos extremos. No permite valores nulos. Es más rápido que Stack y LinkedList cuando se implementa como Stack y LinkedList. ArrayDeque no tiene restricciones de tamaño a medida que crece y se reduce según los requisitos. No está sincronizado, lo que significa que no es seguro para subprocesos. Para mantenerlo seguro para subprocesos, tenemos que implementar alguna lógica externa.

Ejemplo

import java.util.*;  
public class ArrayDequeExample {  
   public static void main(String[] args) {  
       //creating Deque and adding elements  
       Deque<String> deque = new ArrayDeque<String>();  
       //adding an element
       deque.add("One"); 
       //adding an element at the start
       deque.addFirst("Two");     
       //adding an element at the end
       deque.addLast("Three");    
       //traversing elements of the collection  
       for (String str : deque) {  
            System.out.println(str);  
       }  
   }  
}

Producción

HashMap

Es la implementación de la interfaz Map respaldada por la tabla hash. Almacena los pares clave-valor. No permite valores nulos. No está sincronizado. Nunca garantiza el orden de inserción. Proporciona un rendimiento en tiempo constante para métodos como get y put . Su rendimiento depende de dos factores: capacidad inicial y factor de carga . La capacidad es la cantidad de depósitos en la tabla hash, por lo que la capacidad inicial es la cantidad de depósitos asignados en el momento de la creación. El factor de carga es la medida de cuánto se puede llenar una tabla hash antes de aumentar su capacidad. El método de repetición se utiliza para aumentar la capacidad y principalmente duplica la cantidad de cubos.

Ejemplo

import java.util.*;  
public class HashMapExample{  
    public static void main(String args[]){  
        //creating a HashMap
        HashMap<Integer,String> map=new HashMap<Integer,String>();    
        //putting elements into the map
        map.put(1,"England");    
        map.put(2,"USA");    
        map.put(3,"China");
        
        //get element at index 2
        System.out.println("Value at index 2 is: "+map.get(2));
        System.out.println("iterating map"); 
        //iterating the map 
        for(Map.Entry m : map.entrySet()){    
            System.out.println(m.getKey()+" "+m.getValue());    
        }   
    }  
}

Producción

Algoritmos

El marco de Colecciones nos proporciona diferentes algoritmos para que diferentes operaciones se apliquen a las colecciones. Aquí veremos qué operaciones principales están cubiertas por estos algoritmos. Contiene algoritmos relacionados con:

1. Clasificación
2. buscando
3. Arrastramiento
4. Manipulación de datos de rutina
5. Composición
6. Encontrar valores extremos

Para una mejor comprensión, analizaremos el algoritmo de clasificación.

Clasificación

El algoritmo de clasificación reordena una lista según una relación de ordenación. Se proporcionan dos formas de relaciones.

1. Ordenamiento natural
2. Orden de comparación

Ordenamiento natural

En el ordenamiento natural, una lista se ordena según sus elementos.

Orden de comparación

En esta forma de ordenar, se pasa un parámetro adicional, que es un comparador, junto con la lista. Para la clasificación se utiliza un algoritmo de clasificación por fusión ligeramente optimizado, que es rápido y estable ya que garantiza el tiempo de ejecución n log(n) y no reordena elementos iguales. Usaremos el mismo ejemplo de ArrayList para demostrar la clasificación.

Ejemplo

import java.util.*;  
public class SortingExample{  
    public static void main(String args[]){  
        //Creating arraylist
        ArrayList<String> books=new ArrayList<String>(); 
        //Adding a book to the arraylist
        books.add("A Time to Kill");
        //Adding a book to the arraylist
        books.add("Absalom, Absalom!");
        //Adding a book to the arraylist
        books.add("The House of Mirth");  
        //Adding a book to the arraylist
        books.add("East of Eden");
        //Traversing list through Iterator before sorting
        Iterator itrBeforeSort=books.iterator();  
        while(itrBeforeSort.hasNext()){  
            System.out.println(itrBeforeSort.next());  
        }
        //sorting the books
        Collections.sort(books);
        System.out.println("After sorting the books");
        //Traversing list through Iterator after sorting  
        Iterator itr=books.iterator();  
        while(itr.hasNext()){  
            System.out.println(itr.next());  
        }  
    }  
}

Producción

Conclusión

Esperamos que ahora comprenda qué es el marco de colecciones de Java, cuáles son sus interfaces y clases y cómo implementar sus diferentes clases. Siempre puedes utilizar este marco para reducir tus esfuerzos en Java. Siéntete libre de practicar y volver aquí cuando necesites más ayuda. ¡Feliz aprendizaje!