::. Moleculax - Programming free online - Data Base NoSQL - OOP - Deep Web- Dark Web - BigData - PostgreSQL - MySQL - Programming - OOP freebitcoin.:: Moleculax - TECHNOLOGY AND KNOWLEDGE Information technology, Structured programming

En Java, las colecciones son un conjunto de clases e interfaces que permiten almacenar, manipular y acceder a grupos de objetos de manera flexible y eficiente.

Forman parte del Java Collections Framework (JCF), que se encuentra en el paquete java.util.

1. Clasificación general

El framework de colecciones de Java se organiza principalmente en interfaces, implementaciones y algoritmos.

A. Interfaces principales

Estas definen el contrato que las implementaciones deben seguir:

Interface	Descripción	Ejemplos de implementación
`Collection<E>`	Base de todas las colecciones.	`ArrayList`, `HashSet`
`List<E>`	Colección ordenada que permite elementos duplicados.	`ArrayList`, `LinkedList`
`Set<E>`	Colección que no permite duplicados.	`HashSet`, `LinkedHashSet`, `TreeSet`
`Queue<E>`	Maneja elementos en orden FIFO (primero en entrar, primero en salir).	`LinkedList`, `PriorityQueue`
`Deque<E>`	Cola doble: permite inserción y eliminación por ambos extremos.	`ArrayDeque`, `LinkedList`
`Map<K,V>`	Estructura de pares clave–valor.	`HashMap`, `TreeMap`, `LinkedHashMap`

B. Implementaciones comunes

Cada interface tiene diferentes implementaciones con ventajas y desventajas:

Implementación	Características
`ArrayList`	Lista dinámica basada en arrays, acceso rápido por índice, pero costoso al insertar en el medio.
`LinkedList`	Lista doblemente enlazada, buena para inserciones/eliminaciones, lenta para acceso por índice.
`HashSet`	Basado en `HashMap`, no garantiza orden, acceso rápido.
`LinkedHashSet`	Igual que `HashSet` pero mantiene el orden de inserción.
`TreeSet`	Basado en un árbol rojo-negro, ordena automáticamente los elementos.
`HashMap`	Mapea claves a valores, acceso rápido por clave, no garantiza orden.
`LinkedHashMap`	Igual que `HashMap` pero mantiene orden de inserción.
`TreeMap`	Ordena las claves de forma natural o con un `Comparator`.

2. Ejemplo de uso

java

import java.util.*;

public class EjemploColecciones {
    public static void main(String[] args) {
        // Lista
        List<String> lista = new ArrayList<>();
        lista.add("Manzana");
        lista.add("Banana");
        lista.add("Pera");
        lista.add("Banana"); // permite duplicados
        System.out.println("Lista: " + lista);

        // Set
        Set<String> set = new HashSet<>(lista); // elimina duplicados
        System.out.println("Set: " + set);

        // Map
        Map<Integer, String> mapa = new HashMap<>();
        mapa.put(1, "Rojo");
        mapa.put(2, "Verde");
        mapa.put(3, "Azul");
        System.out.println("Mapa: " + mapa);
        System.out.println("Color clave 2: " + mapa.get(2));
    }
}

Salida posible:

yaml

Lista: [Manzana, Banana, Pera, Banana]
Set: [Pera, Banana, Manzana]
Mapa: {1=Rojo, 2=Verde, 3=Azul}
Color clave 2: Verde

3. Algoritmos en colecciones

La clase Collections proporciona métodos útiles:

java
Collections.sort(lista);
Collections.reverse(lista);
Collections.shuffle(lista);
Collections.max(lista);
Collections.min(lista);

4. Ventajas de usar colecciones

Flexibilidad en el tamaño (no como los arrays fijos).
Métodos utilitarios listos (sort, search, shuffle…).
Diferentes estructuras para diferentes necesidades (listas, colas, conjuntos, mapas).
Mejor legibilidad y mantenibilidad del código.

Buscar en moleculax

Java Collections Framework (JCF)