HashMap y colecciones en Java

Un mapa almacena una relación entre cada clave y un valor. En un mapa de existencias, el nombre de un producto es la clave y su cantidad es el valor. Dos productos pueden tener la misma cantidad, pero una clave de producto no puede tener dos entradas separadas.

Crea el mapa

import java.util.HashMap;

HashMap<String, Integer> stock = new HashMap<>();

El primer tipo, String, describe las claves. El segundo, Integer, describe los valores. El diamante <> de la derecha permite que Java infiera esos tipos. Los argumentos de tipo deben ser tipos de referencia: utiliza Integer, Double, Character o Boolean en lugar de int, double, char o boolean. Java empaqueta un int normal cuando lo almacena como Integer y desempaqueta un Integer cuando se necesita un int.

Sigue cada cambio

stock.put("apple", 12);
stock.put("pear", 7);
Integer previous = stock.put("apple", 15);

La primera llamada crea apple=12; la segunda añade pear=7. La tercera encuentra la clave existente "apple" y reemplaza su valor. El mapa tiene ahora dos entradas y previous contiene 12. Un put para una clave sin asociación previa devuelve null.

stock.get("apple") devuelve ahora 15. stock.remove("pear") devuelve 7 y elimina esa entrada. Volver a eliminar "pear" devuelve null. size() cuenta las entradas, isEmpty() comprueba si no hay ninguna y clear() elimina todas las entradas.

Gestiona una clave ausente

stock.get("kiwi") devuelve null y stock.containsKey("kiwi") devuelve false. Esta sentencia se compila, pero falla al ejecutarse:

int quantity = stock.get("kiwi");

Java intenta desempaquetar null como un int, lo que provoca una NullPointerException. Para un mapa de cantidades no nulas, utiliza un valor predeterminado:

int quantity = stock.getOrDefault("kiwi", 0);

Esto proporciona 0 sin añadir "kiwi" al mapa. También puedes comprobar containsKey antes de leer. containsValue(15) pregunta si alguna entrada tiene ese valor; puede recorrer todos los valores, por lo que es diferente de buscar una clave conocida.

Un HashMap también permite una clave null y valores null. Si una clave está asociada explícitamente a null, getOrDefault devuelve ese null almacenado, no el valor predeterminado. containsKey distingue ese caso de una clave ausente. Los mapas de cantidades son más sencillos cuando todas las cantidades almacenadas son números reales.

Compara correctamente claves y valores

Las claves de tipo String distinguen mayúsculas y minúsculas: "apple", "Apple" y "apple " son diferentes. Aplica la misma limpieza antes de almacenar y buscar, por ejemplo, name.trim().toLowerCase(). Limpiar solo una clave de búsqueda no puede corregir claves almacenadas de forma inconsistente.

Compara los valores empaquetados por contenido con equals. Si dos entradas contienen cada una 1000, sus referencias Integer pueden ser distintas, por lo que == puede ser falso aunque sus contenidos numéricos coincidan. Después de comprobar que ambos valores son distintos de null, a.equals(b) compara sus contenidos.

Un mapa puede responder a una búsqueda individual o proporcionar todos sus datos a un bucle. Elige la vista que proporcione las partes que necesita el bucle. Las vistas están vinculadas al mapa, por lo que los cambios realizados a través de ellas también pueden cambiar el mapa.

Elige claves, valores o entradas

Utiliza keySet() para visitar las claves. Una búsqueda dentro de ese bucle puede recuperar cada valor:

for (String name : phoneBook.keySet()) {
    System.out.println(name + ": " + phoneBook.get(name));
}

Utiliza values() cuando las claves no importen. Para las cantidades en existencias apple 15, pear 7 y fig 3:

int total = 0;
for (int quantity : stock.values()) {
    total += quantity;
}

El total pasa a ser 25. Los valores repetidos siguen siendo contribuciones separadas: una vista de valores no es un conjunto.

Una entrada contiene una clave y su valor juntos. Importa java.util.Map y utiliza Map.Entry<K, V> con getKey() y getValue(). Esto evita una segunda búsqueda:

String best = null;
int bestScore = Integer.MIN_VALUE;
for (Map.Entry<String, Integer> entry : scores.entrySet()) {
    if (best == null || entry.getValue() > bestScore) {
        best = entry.getKey();
        bestScore = entry.getValue();
    }
}

Para Ana 82, Ben 91 y Cai 77, el resultado es Ben con 91. La comprobación best == null también gestiona una primera puntuación igual al menor int posible. Un mapa vacío deja best como null.

Elige el orden de forma explícita

Un HashMap no garantiza ningún orden de iteración. No se puede dar por supuesto el orden de inserción, el orden ordenado ni el orden impreso hoy. Un LinkedHashMap conserva el orden de inserción; un TreeMap visita las claves ordenadas. Si dos puntuaciones empatan, el bucle anterior conserva la primera que visita. Con un HashMap, cualquiera de los nombres empatados podría ganar. Añade una regla de desempate explícita cuando el resultado deba ser predecible.

Elimina entradas mediante el iterador

Llamar a stock.remove(key) dentro de un bucle for-each sobre stock.keySet() cambia las claves que recorre el bucle. Puede provocar una ConcurrentModificationException. La detección no está garantizada; una ejecución sin excepción no hace válido ese patrón.

Utiliza el método de eliminación del propio iterador:

Iterator<Map.Entry<String, Integer>> it =
    stock.entrySet().iterator();
while (it.hasNext()) {
    if (it.next().getValue() == 0) {
        it.remove();
    }
}

Importa java.util.Iterator. Para apple 15, pear 0, fig 0 y kiwi 4, esto elimina pear y fig. Otro método seguro registra las claves en una lista, termina el bucle y después elimina esas claves.

Reemplazar un valor existente no añade ni elimina una clave. Durante un bucle sobre entradas, entry.setValue(entry.getValue() * 2) puede duplicar las cantidades de forma segura. No añadas claves nuevas a través del mapa durante ese bucle.

Distingue una vista de una copia

stock.keySet().remove("apple") elimina la entrada correspondiente del mapa. Una lista independiente creada con new ArrayList<>(stock.keySet()) es una copia de las claves actuales. Ordenar esa lista no cambia el orden del mapa, y eliminar un nombre de la lista no elimina su asociación.

Un identificador de producto almacenado como String ya tiene reglas de igualdad útiles. Una clave creada a partir de tu propia clase requiere una decisión: ¿representan dos objetos separados con los mismos datos la misma clave?

Los códigos hash acotan la búsqueda; la igualdad la confirma

Un HashMap utiliza hashCode() para ayudar a localizar una clave y equals() para comprobar una coincidencia. Las claves iguales deben tener códigos hash iguales. Las claves distintas pueden compartir un código hash; la igualdad sigue permitiendo distinguirlas. Las clases estándar de valores como String e Integer ya cumplen este contrato.

Sin sobrescrituras, una clase hereda de Object una igualdad basada en la identidad. Dos puntos creados por separado con coordenadas 2 y 3 son claves distintas aunque sus campos coincidan:

labels.put(new Point(2, 3), "door");
String label = labels.get(new Point(2, 3));

Con igualdad por identidad, label es null. La búsqueda creó un segundo objeto, distinto del utilizado para la inserción.

Sobrescribe el par conjuntamente

Aquí las coordenadas de un punto definen su contenido:

import java.util.Objects;

final class Point {
    private final int x;
    private final int y;

    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public boolean equals(Object other) {
        if (this == other) {
            return true;
        }
        if (!(other instanceof Point)) {
            return false;
        }
        Point point = (Point) other;
        return x == point.x && y == point.y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }
}

La comprobación de identidad gestiona rápidamente el caso del mismo objeto. La comprobación de tipo rechaza null y los objetos de otros tipos. La comparación final comprueba ambas coordenadas. Objects.hash(x, y) construye el código hash a partir de esos mismos campos. Con esta clase, la búsqueda anterior devuelve "door".

Sobrescribir solo equals deja el cálculo del código hash heredado, que no garantiza códigos iguales para objetos separados con campos iguales. Un mapa puede entonces no encontrar una clave igual. Un código hash constante conservaría la corrección, pero haría lenta la búsqueda. Generar ambas sobrescrituras en un editor ayuda a evitar que se utilicen campos distintos.

Utiliza la firma exacta del método

public boolean equals(Point other) sobrecarga el método; no reemplaza equals(Object). La búsqueda en un mapa utiliza equals(Object), por lo que la nueva sobrecarga no proporciona al mapa igualdad por contenido. La anotación @Override convierte una firma incorrecta en un error del compilador en lugar de un error oculto de búsqueda.

Mantén estable la identidad de la clave

No cambies los campos que determinan la igualdad o el código hash de una clave mientras esté almacenada. Si un punto almacenado cambia de (2, 3) a (5, 3), puede que el mapa ya no lo encuentre con ninguno de los dos valores aunque size() no haya cambiado. Elimínalo antes de cambiarlo y luego vuelve a insertarlo. Declarar los campos de la clave como final, como arriba, evita este error.

Estas reglas también determinan la pertenencia a un HashSet. Un ArrayList utiliza equals para búsquedas por contenido como contains; no necesita códigos hash para esa búsqueda.

Una tabla de frecuencias tiene una clave por cada elemento distinto y un número que indica cuántas veces aparece. La primera aparición inicia un recuento; cada aparición posterior actualiza esa misma entrada.

Construye un recuento elemento por elemento

HashMap<String, Integer> counts = new HashMap<>();
for (String word : text.split(" ")) {
    int oldCount = counts.getOrDefault(word, 0);
    counts.put(word, oldCount + 1);
}

Para el texto «el gato vio el perro y el gato corrió», la primera «el» no está en el mapa, por lo que su recuento anterior es 0 y el nuevo es 1. Sus dos apariciones siguientes cambian esa entrada a 2 y luego a 3. «gato» termina en 2; «vio», «perro», «y» y «corrió» terminan en 1 cada una. En el texto original, las claves correspondientes son "the", "cat", "saw", "dog", "and" y "ran".

Hay 6 palabras distintas, por lo que counts.size() es 6. Los valores suman 9, el número de apariciones de palabras. Estas medidas son diferentes: el tamaño del mapa no es la longitud de la secuencia original.

La actualización puede escribirse en una línea:

counts.put(word, counts.getOrDefault(word, 0) + 1);

Una forma equivalente más larga comprueba containsKey, incrementa un recuento existente y almacena 1 para una clave nueva. Todos los recuentos almacenados en este patrón son distintos de null.

Conserva el resultado anterior

Llamar a counts.put(word, 1) para cada palabra sobrescribe repetidamente cada recuento con 1. Registra que una palabra existe, pero pierde su frecuencia. Llamar a counts.get(word) + 1 sin gestionar la primera aparición intenta desempaquetar null y falla. El valor predeterminado pertenece al paso de lectura; después hay que volver a almacenar el recuento incrementado.

Decide qué se considera el mismo elemento

La igualdad de cadenas es exacta. "The" y "the" son claves distintas, al igual que "cat" y "cat,". Si la tarea las trata como la misma palabra, limpia cada unidad de entrada antes de contarla. Convierte el texto a minúsculas y elimina la puntuación que el programa trate como separadores. Utiliza una regla consistente para que los resultados no dependan de qué forma escrita apareció primero.

La clave también puede ser un carácter. Con HashMap<Character, Integer>, un bucle sobre "banana".toCharArray() produce a=3, n=2 y b=1 mediante el mismo patrón de leer, incrementar y almacenar.

Acumula cantidades en lugar de apariciones

Para obtener totales por categoría, suma la cantidad actual en lugar de 1:

HashMap<String, Double> totals = new HashMap<>();
double oldTotal = totals.getOrDefault(category, 0.0);
totals.put(category, oldTotal + amount);

Comida 12,50, transporte 3,20 y comida 7,25 dan comida 19,75 y transporte 3,20. El valor predeterminado es 0.0, que coincide con el tipo de valor Double. El mapa sigue teniendo una entrada por categoría, independientemente de cuántas cantidades contribuyan a ella.

Interpreta la tabla completa

Recorre las entradas para encontrar el mayor recuento o total, recordando la mejor clave y su valor. Especifica una regla de desempate si es necesario. Para un informe alfabético, new TreeMap<>(counts) copia las asociaciones en orden de clave. Los valores de los recuentos permanecen sin cambios; ordenar las claves no ordena las categorías por sus totales.

El valor de un mapa puede ser una colección. Cuando varios estudiantes pertenecen a un curso, el curso es una clave y la lista asociada contiene a todos sus estudiantes. La regla de claves únicas del mapa sigue vigente: la lista es el único valor de ese curso.

Crea un grupo antes de añadir elementos

HashMap<Character, ArrayList<String>> groups = new HashMap<>();
for (String fruit : fruits) {
    char letter = fruit.charAt(0);
    if (!groups.containsKey(letter)) {
        groups.put(letter, new ArrayList<>());
    }
    groups.get(letter).add(fruit);
}

Para «apple», «banana», «avocado», «cherry» y «blueberry», la primera fruta crea la lista de a y añade «apple». «Banana» crea la lista de b. «Avocado» encuentra la lista existente de a y se añade al final. El resultado es a → [apple, avocado], b → [banana, blueberry] y c → [cherry]. Cada lista conserva su propio orden de inserción aunque el HashMap no ordene sus claves.

La comprobación puede abreviarse:

groups.putIfAbsent(letter, new ArrayList<>());
groups.get(letter).add(fruit);

putIfAbsent conserva una lista existente distinta de null. El get siguiente devuelve esa lista, lista para la adición.

Conserva la lista que ya has construido

Un groups.put(letter, new ArrayList<>()) incondicional dentro del bucle reemplaza la lista anterior en cada aparición. Solo queda la última fruta de cada letra después del siguiente add. El error contrario es omitir la creación por completo: groups.get(letter).add(fruit) lanza una NullPointerException para una clave nueva porque aún no existe ninguna lista.

Comprende la referencia

get devuelve la referencia a la lista almacenada. Añadir elementos a ella modifica esa misma lista, por lo que no hay que volver a insertarla. Esto también explica un error al compartir:

ArrayList<String> shared = new ArrayList<>();
courses.put("Art", shared);
courses.put("Music", shared);
courses.get("Art").add("Jin");

Ambas claves conducen ahora a [Jin]. Dos claves no crearon dos listas. Crea una lista nueva para cada grupo nuevo cuando los grupos deban ser independientes.

Elige listas o conjuntos dentro de los grupos

Una lista conserva las adiciones repetidas. Un conjunto evita duplicados dentro de ese grupo. Por tanto, un HashMap<String, HashSet<String>> puede recopilar las inscripciones en cursos de cada estudiante sin contar dos veces al mismo estudiante en un curso. La regla del conjunto se aplica dentro de cada valor; el mapa externo sigue teniendo una entrada por curso.

Para leer un grupo que podría faltar, comprueba containsKey o utiliza groups.getOrDefault(letter, new ArrayList<>()). Una clave ausente produce entonces una lista vacía para esa llamada. La lista predeterminada no se inserta automáticamente; añadir elementos a ella no crea un grupo almacenado.

Eliminar el último elemento de un grupo deja la clave asociada a una colección vacía. Si el programa debe dejar de listar grupos vacíos, comprueba isEmpty() y elimina también esa clave. Cuenta los grupos con el tamaño del mapa externo y los elementos con los tamaños de las colecciones internas.

Un índice asocia una clave identificadora con un objeto. Una biblioteca puede encontrar un libro por ISBN sin recorrer todos los libros de una lista. Una tabla de consulta utiliza la misma estructura para relacionar un código con un valor sencillo, como el precio de un producto.

Elige una clave identificadora

Un HashMap<String, Book> puede asociar un ISBN con su libro. Cada búsqueda solo necesita la clave. El nombre de una persona suele ser una mala clave única: almacenar a otra persona llamada «Sam Lee» bajo esa misma cadena reemplaza a la persona anterior. Utiliza un identificador único o un mapa de agrupación si un nombre debe conducir a varias personas.

Mantén un índice dentro de la clase responsable de los datos:

class Library {
    private HashMap<String, Book> byIsbn;

    Library() {
        byIsbn = new HashMap<>();
    }

    void addBook(Book book) {
        byIsbn.put(book.getIsbn(), book);
    }

    Book findByIsbn(String isbn) {
        return byIsbn.get(isbn);
    }
}

Aquí Book proporciona un método getIsbn(). Quienes llaman utilizan addBook y findByIsbn; no necesitan saber qué implementación de mapa se almacena. El campo privado también proporciona a la clase un único lugar donde mantener sus reglas para añadir y reemplazar libros.

Comprueba si falta un resultado

Si findByIsbn devuelve null, no se encontró ningún libro. Comprueba el resultado antes de llamar a un método sobre él:

Book found = library.findByIsbn("978-0-00-000000-2");
if (found != null) {
    found.setOnLoan(true);
}

Llamar a setOnLoan directamente sobre un resultado ausente lanzaría una NullPointerException. Un método como hasBook(isbn) es otra forma de permitir que quienes llaman comprueben si existe una clave.

Sigue los objetos compartidos entre índices

Un mapa almacena una referencia a un objeto, no una copia nueva de ese objeto. Si el mismo libro está en una lista de todos los libros, un mapa por ISBN y una agrupación por autor, setOnLoan(true) cambia el único libro al que hacen referencia los tres. Esto evita que tres objetos de libro separados dejen de coincidir.

Las propias estructuras de las colecciones siguen necesitando mantenimiento. Eliminar un libro del mapa por ISBN no elimina su referencia de la lista de un autor. Si una biblioteca mantiene ambos índices, sus métodos de adición y eliminación deben actualizar los dos. Centralizar esos cambios en métodos como addBook y removeBook ayuda a mantener la coherencia de las búsquedas.

Utiliza una tabla en un cálculo

Supón que una tabla de precios contiene café 2,50, té 2,00 y magdalena 3,25 u.m. Para dos cafés y una magdalena:

double cost = 2 * prices.get("coffee") + prices.get("muffin");

El subtotal del café es 5,00; sumar 3,25 da 8,25 u.m. Las claves identifican productos y los valores proporcionan los importes. Un producto ausente requiere una decisión explícita antes del cálculo: un valor predeterminado de cero lo trataría como gratuito sin avisar. Por tanto, la misma técnica de búsqueda puede necesitar una regla para claves ausentes diferente de la de una tabla de frecuencias.

Un conjunto contiene cada valor como máximo una vez. Es adecuado para preguntas como «¿ha aparecido antes este valor?» o «¿cuántos valores diferentes aparecen?». Un HashSet permite comprobaciones de pertenencia rápidas en promedio sin garantizar un orden de presentación.

Añade y comprueba valores

import java.util.HashSet;

HashSet<String> visited = new HashSet<>();
boolean first = visited.add("Oslo");
boolean second = visited.add("Lima");
boolean third = visited.add("Oslo");
visited.add("Pune");

Los tres booleanos almacenados son true, true y false. El segundo «Oslo» coincide con un elemento existente, por lo que no se añade. El tamaño del conjunto es 3. Una adición duplicada no reemplaza una posición numerada porque un conjunto no tiene índices.

visited.contains("Lima") devuelve true. visited.remove("Lima") lo elimina y devuelve true; repetir esa eliminación devuelve false. Utiliza un bucle for-each para visitar los valores. No existe get(0) para obtener el primer valor de un HashSet.

Elimina duplicados de una lista

ArrayList<Integer> values = new ArrayList<>();
values.add(3);
values.add(1);
values.add(3);
values.add(2);
values.add(1);
HashSet<Integer> distinct = new HashSet<>(values);

El conjunto tiene tres valores: {1, 2, 3}. Su orden de iteración real no está especificado. La lista original sigue teniendo cinco elementos porque el constructor crea una colección independiente.

Utiliza new LinkedHashSet<>(values) para conservar el orden de la primera aparición, lo que da 3, 1, 2. Utiliza new TreeSet<>(values) para obtener los valores ordenados, 1, 2, 3. Aquí los conjuntos se escriben entre llaves para destacar la pertenencia; el toString() estándar de los conjuntos de Java utiliza corchetes.

Detecta la primera repetición

El resultado de add puede realizar conjuntamente la comprobación de pertenencia y la inserción:

HashSet<Integer> seen = new HashSet<>();
for (int number : numbers) {
    if (!seen.add(number)) {
        System.out.println(number);
        break;
    }
}

Para [4, 7, 2, 7, 4], el bucle imprime 7. Es el primer valor encontrado por segunda vez, aunque 4 apareció antes en la secuencia. Antes de que se repita 7, el conjunto contiene 4, 7 y 2. La inserción fallida provoca la detención.

Identifica lo que un conjunto no puede decirte

Comprobar contains antes de cada add es innecesario porque add ya gestiona los duplicados. Una lista con una comprobación de contains también puede mantener valores únicos, pero cada búsqueda en la lista puede recorrer todos los elementos almacenados. Un HashSet expresa la regla directamente.

La igualdad importa para tus propios objetos. Un HashSet<Point> necesita un equals basado en el contenido y un hashCode coherente para reunir puntos creados por separado con coordenadas iguales. Sin esas sobrescrituras, las instancias separadas permanecen como elementos distintos.

Por último, size() mide valores distintos, no apariciones. Las nueve palabras de «el gato vio el perro y el gato corrió» producen seis palabras distintas. Un conjunto ya no te indica que «el» apareció tres veces; utiliza un mapa de frecuencias cuando esos recuentos importen.

Los conjuntos pueden describir grupos y comparar su pertenencia. Si dos listas de eventos contienen varias veces a la misma persona, un conjunto reduce primero cada lista a las personas que asistieron. Las operaciones de conjuntos responden después a preguntas sobre cualquiera de los dos eventos, ambos o solo uno.

Combina dos grupos

Sean los asistentes del lunes {Ana, Ben, Cai, Dee} y los del martes {Ben, Dee, Eva}.

Estas operaciones son la unión, la intersección y la diferencia. Modifican el conjunto receptor y devuelven un booleano que indica si cambió. No devuelven un conjunto nuevo con el resultado.

Conserva el original

Haz una copia antes de cambiar la pertenencia si aún necesitas el conjunto del lunes:

HashSet<String> both = new HashSet<>(monday);
both.retainAll(tuesday);

both empieza con los cuatro nombres del lunes. retainAll elimina a Ana y Cai porque no están el martes. El conjunto del lunes permanece sin cambios. Para encontrar a quienes asistieron solo el martes, empieza con una copia del martes y elimina los nombres del lunes; el resultado es {Eva}. La diferencia tiene un sentido; invertirlo cambia la pregunta.

Comprueba subconjuntos e igualdad

monday.containsAll(group) pregunta si todos los valores de group están presentes el lunes. Para {Ben, Dee}, devuelve true: ese grupo es un subconjunto del lunes. No exige que el conjunto del lunes contenga solo a esas dos personas.

Dos conjuntos son iguales cuando sus elementos coinciden, independientemente del orden de inserción o de la implementación. Un HashSet que contiene «x» e «y» es igual a un TreeSet que contiene «y» y «x». La pertenencia determina la igualdad de conjuntos, por lo que el orden por sí solo no puede hacerlos distintos.

Elige un orden para el recorrido

Los tres evitan duplicados. Utiliza LinkedHashSet cuando importe la primera vez que apareció cada nombre. Utiliza TreeSet cuando cada recorrido deba estar ya ordenado. Para las cadenas, la ordenación natural sigue los códigos de carácter: las formas en minúsculas y mayúsculas no se comportan como un único alfabeto que no distingue entre ellas.

Un TreeSet con su constructor predeterminado necesita elementos que tengan una comparación natural, como cadenas, números u objetos que implementen Comparable. En ese conjunto, un resultado de comparación igual a cero indica un duplicado. Una clase que no proporciona una comparación natural provoca una ClassCastException al insertarse. Proporcionar un comparador explícito es otra forma de definir el orden de una colección basada en árboles; los ejemplos predeterminados utilizan el orden natural.

Una interfaz describe las operaciones que proporciona una clase que la implementa. Permite que una variable describa lo que necesita el código y deja la elección del almacenamiento a una clase concreta. List, Set y Map son interfaces relacionadas con colecciones en java.util.

Interpreta los dos lados de una declaración

List<String> names = new ArrayList<>();
Set<String> tags = new HashSet<>();
Map<String, Integer> counts = new HashMap<>();

El lado izquierdo declara el tipo de la variable. El derecho crea un objeto de una clase que lo implementa. Importa ambos tipos, como java.util.List y java.util.ArrayList. No puedes escribir new List<>() ni new Map<>(): una interfaz no es un objeto concreto que se pueda construir.

El código que utiliza counts puede llamar a put, get y entrySet porque Map los declara. Si resulta útil tener las claves en orden alfabético, cambia la construcción a new TreeMap<>(). Las llamadas existentes siguen compilándose. Su orden puede cambiar porque las implementaciones pueden ofrecer distintas garantías de orden; la interfaz no hace que su comportamiento sea idéntico en todo.

Acepta la capacidad que necesita un método

Un método que solo cuenta palabras largas puede aceptar una Collection:

static int countLong(Collection<String> words, int min) {
    int count = 0;
    for (String word : words) {
        if (word.length() >= min) {
            count++;
        }
    }
    return count;
}

Para [«a», «tree», «house»] y un mínimo de 4, devuelve 2. El mismo método puede recibir un ArrayList, un LinkedList, un HashSet o List.of(...) porque solo lee los elementos. Un conjunto puede haber eliminado ya los duplicados, por lo que puede proporcionar datos de entrada distintos de los de una lista.

Utilizar un parámetro de tipo interfaz evita exigir una clase de almacenamiento concreta cuando el método no la necesita. Si se necesitan posiciones, acepta List. Si se necesita buscar por clave, acepta Map.

Conoce los límites del tipo declarado

List<String> names = new ArrayList<>();
names.ensureCapacity(100);  // does not compile

El objeto es un ArrayList, pero List no declara ensureCapacity. El compilador comprueba el tipo declarado de la variable. Utiliza un tipo de clase concreta cuando realmente necesites su operación especial; no cambies los parámetros de lista habituales solo para que coincidan con la clase de quien los llama.

Sitúa Map junto a Collection

List y Set extienden Collection, que describe un grupo de elementos. Declara métodos como add, remove, contains, size, isEmpty, addAll y clear. Que se admita una modificación depende de la colección real.

Map no extiende Collection. Almacena asociaciones y proporciona vistas que son colecciones: keySet() es un Set, values() es una Collection y entrySet() es un Set de entradas. Pasa counts.values() a un método que necesite una colección de valores, no counts directamente.

Una clase puede implementar varias interfaces. LinkedList implementa tanto List como Deque, una interfaz de cola de doble extremo. Tu propia clase indica las interfaces que se compromete a implementar después de implements, como en class Member implements Comparable<Member>.

Elige una interfaz según las reglas que necesiten tus datos. Que su contenido parezca similar no hace intercambiables una lista, un conjunto y un mapa: cada uno da un significado diferente a las posiciones, las repeticiones y la igualdad.

Compara las garantías

ArrayList y LinkedList implementan List. HashSet, LinkedHashSet y TreeSet implementan Set. HashMap, LinkedHashMap y TreeMap implementan Map. Las versiones basadas en hash no garantizan ningún orden de recorrido; las versiones enlazadas conservan el orden de inserción; las versiones basadas en árboles mantienen ordenados los elementos o las claves. Volver a insertar una clave existente en un LinkedHashMap normal con orden de inserción conserva la posición de esa clave.

Examina con cuidado la eliminación en listas de enteros

Una List<Integer> tiene dos métodos sobrecargados relevantes:

List<Integer> numbers = new ArrayList<>(List.of(1, 5, 7));
numbers.remove(1);

El argumento 1 es un int, por lo que Java elimina el elemento del índice 1: el valor 5. El resultado es [1, 7]. Si vuelves a empezar con [1, 5, 7], numbers.remove(Integer.valueOf(1)) selecciona la eliminación por valor y deja [5, 7]. El objeto envoltorio deja claro qué método sobrecargado se pretende utilizar.

Compara el contenido con la regla adecuada

Dos listas son iguales cuando los mismos elementos aparecen en el mismo orden. Un ArrayList [1, 2] es igual a un LinkedList [1, 2], pero no a una lista [2, 1]. Dos conjuntos comparan la pertenencia e ignoran el orden. Dos mapas comparan las asociaciones, por lo que el orden de inserción no afecta a la igualdad de mapas. Sus clases concretas pueden ser distintas aunque sus contenidos sean iguales según la regla de la interfaz.

Reconoce las colecciones no modificables

List<String> labels = List.of("a", "b");
Set<Integer> levels = Set.of(1, 2, 3);
Map<String, Double> prices = Map.of("tea", 2.0, "coffee", 2.5);

Estas fábricas devuelven colecciones no modificables. Los intentos de añadir, eliminar, reemplazar u ordenar su contenido lanzan UnsupportedOperationException. Map.of acepta hasta diez pares clave-valor.

Las tres rechazan elementos, claves o valores null con NullPointerException. Set.of rechaza elementos duplicados y Map.of rechaza claves duplicadas con IllegalArgumentException. List.of permite duplicados porque una lista puede repetir un elemento. El orden de iteración de los conjuntos y mapas creados por estas fábricas no está especificado.

Haz una copia cuando necesites modificar

new ArrayList<>(labels) crea una lista modificable con los mismos elementos. new HashSet<>(someList) y new HashMap<>(someMap) también crean estructuras de colección independientes.

Estas copias son superficiales: contienen las mismas referencias a elementos. Eliminar un elemento de una copia deja intacta la estructura original, pero modificar un objeto mutable a través de cualquiera de las dos colecciones cambia el objeto compartido. Una colección no modificable impide editar su estructura; no congela todos los objetos almacenados en ella.

Una lista conserva un orden, pero ese orden puede simplemente reflejar cómo llegaron los valores. La ordenación reorganiza la lista mediante una regla de comparación. Java ya proporciona un orden natural para números y cadenas.

Ordena una lista modificable in situ

List<Double> values = new ArrayList<>(List.of(3.5, -1.0, 2.25));
Collections.sort(values);

Importa java.util.Collections. La misma lista contiene ahora [-1,0; 2,25; 3,5]. La ordenación devuelve void, por lo que values = Collections.sort(values) no se compila. values.sort(null) también ordena en orden natural. Para un arreglo, utiliza Arrays.sort(array); un arreglo que contiene 5, 2 y 8 pasa a contener 2, 5 y 8.

Predice el orden de las cadenas carácter por carácter

La comparación de cadenas examina el primer carácter diferente. Si una cadena es prefijo de otra, la más corta va primero. Así, «apple» precede a «apples».

La lista [«pear», «Banana», «apple», «10», «9»] se ordena como [«10», «9», «Banana», «apple», «pear»]. Para estos caracteres, los dígitos preceden a las letras mayúsculas y las mayúsculas preceden a las minúsculas. «10» precede a «9» porque «1» va antes que «9»; el orden de cadenas no interpreta las cadenas de dígitos como números enteros. Almacena los datos numéricos como números cuando necesites un orden numérico.

Utiliza órdenes alternativos ya disponibles

names.sort(String.CASE_INSENSITIVE_ORDER);
values.sort(Collections.reverseOrder());

La primera llamada ordena [«pear», «Banana», «apple»] como [«apple», «Banana», «pear»] sin cambiar las mayúsculas y minúsculas almacenadas. La segunda utiliza el orden natural descendente. Los números 4, 9 y 1 pasan a ser 9, 4 y 1. Estos argumentos son comparadores, objetos que proporcionan un orden alternativo.

Collections.reverse(list) solo invierte la secuencia actual. Produce un orden descendente si esa secuencia ya estaba ordenada de forma ascendente; por sí solo no ordena una lista cualquiera.

Conserva la estabilidad de los empates

La ordenación de listas es estable: los elementos que se comparan como iguales conservan su orden relativo anterior. Si una comparación basada solo en la puntuación empata a dos personas, se mantiene el orden que tenían en la lista. La estabilidad conserva ese orden de entrada; no inventa un criterio de desempate alfabético.

Reconoce fallos y métodos útiles

Una lista creada con List.of(...) no se puede ordenar in situ. Cópiala primero a un ArrayList. Para una clase que no implementa Comparable, Collections.sort(list) no supera la comprobación de tipos durante la compilación. Llamar a list.sort(null) sobre esos objetos falla en tiempo de ejecución con ClassCastException cuando se necesita comparar.

Collections.max(collection) y Collections.min(collection) encuentran los elementos mayor y menor en orden natural sin reorganizar la colección. Lanzan NoSuchElementException para una colección vacía.

Para obtener las claves de un mapa ordenadas, copia map.keySet() a un ArrayList y ordena la copia, o utiliza un TreeMap. Ordenar una lista de claves copiada deja sin cambios el orden de iteración del propio mapa.

Java no puede adivinar si un miembro debe ir primero por nombre, altura u otro campo. Implementa Comparable para dotar a la clase de un orden natural. El código de ordenación puede entonces pedir a cada objeto que se compare con otro objeto de esa clase.

Escribe el método de comparación

class Member implements Comparable<Member> {
    private String name;
    private int height;

    Member(String name, int height) {
        this.name = name;
        this.height = height;
    }

    @Override
    public int compareTo(Member other) {
        return Integer.compare(this.height, other.height);
    }
}

La altura se mide en centímetros. Comparable<Member> especifica que el otro objeto es un Member; no se necesita una conversión explícita. public int compareTo(Member other) es el método requerido. La interfaz estándar Comparable está en java.lang, por lo que no necesita importación.

Para a.compareTo(b), un resultado negativo coloca a antes que b, cero los sitúa en la misma posición de comparación y un resultado positivo coloca a después de b. Solo importa el signo: -35 es un resultado negativo tan válido como -1.

Sigue el orden

Con la comparación por altura, Ana 172, Ben 165 y Cai 180 se ordenan como Ben 165, Ana 172 y Cai 180. Para colocar primero a los miembros más altos, intercambia los argumentos:

return Integer.compare(other.height, this.height);

Cambia la regla de forma deliberada. Invertir los argumentos invierte el sentido de ese campo; no cambia lo que significa la altura ni modifica los datos de ningún miembro.

Compara valores numéricos completos de forma segura

La resta parece cómoda, pero puede devolver el signo incorrecto cuando un int se desborda. Para -2 000 000 000 y 2 000 000 000, restar el segundo del primero produce por desbordamiento 294 967 296, un resultado positivo. Integer.compare devuelve correctamente un resultado negativo.

Para campos decimales, utiliza Double.compare(this.price, other.price). Convertir explícitamente una diferencia a int pierde información: (int) (1.8 - 1.5) es 0, por lo que precios distintos se convierten en un empate de comparación. Un método de comparación conserva el orden sin truncar la diferencia.

Compara texto y reutiliza la regla

Para ordenar por nombre, devuelve this.name.compareTo(other.name). Sigue el orden por unidades de código de la cadena. compareToIgnoreCase proporciona una comparación de texto que no distingue mayúsculas y minúsculas cuando esa es la regla prevista para el campo.

Una vez que una clase define su orden natural, operaciones como Collections.sort, Collections.max y las comparaciones predeterminadas de TreeSet o TreeMap pueden utilizarlo. Una clase también puede implementar otras interfaces, separadas por comas después de implements.

La clase tiene un único orden natural; no se selecciona un compareTo diferente para cada lista. Utiliza objetos comparadores separados cuando un contexto necesite ordenar por nombre y otro por altura. Una comparación solo por altura también empata todas las alturas iguales; decidir si ese empate es aceptable es especialmente importante en los conjuntos ordenados.

Una comparación principal a menudo deja empates. Dos películas pueden compartir año o dos jugadores pueden compartir puntuación. Un criterio de desempate da paso al siguiente campo solo cuando los campos anteriores se comparan como iguales.

Compara los campos por orden de prioridad

@Override
public int compareTo(Film other) {
    int byYear = Integer.compare(this.year, other.year);
    if (byYear != 0) {
        return byYear;
    }
    return this.title.compareTo(other.title);
}

El año es el criterio principal. El título solo importa cuando los años empatan. Up (2009), Avatar (2009) y Alien (1979) se ordenan como Alien (1979), Avatar (2009), Up (2009). Comparar primero los títulos les daría prioridad sobre el año y resolvería una tarea de ordenación diferente.

Los sentidos pueden ser distintos según el campo. Para poner primero los puntos más altos y ordenar los nombres de la A a la Z, empieza con Integer.compare(other.points, this.points). Si el resultado es cero, devuelve this.name.compareTo(other.name). Invertir toda la lista final también invertiría los nombres dentro de las puntuaciones empatadas.

Comprende la regla de duplicados de un conjunto ordenado

Un TreeSet<Member> predeterminado utiliza la comparación natural tanto para ordenar elementos como para decidir cuándo un elemento ya está presente. Si Member.compareTo utiliza solo la altura, Ana 172 y Dee 172 se comparan como cero. Añadir a Ana devuelve true; añadir a Dee devuelve false. Ana permanece como elemento almacenado aunque equals considere diferentes a las dos personas.

Una lista puede conservar ambos objetos empatados; un conjunto basado en árbol les asigna una sola posición de comparación. Añade el criterio de desempate necesario si deben ser distintos en el conjunto.

Alinea la comparación con la igualdad

Un orden es consistente con equals cuando la comparación devuelve cero si y solo si equals devuelve verdadero. Para una clase cuya igualdad utiliza altura y nombre, comparar la altura y luego el nombre puede cumplir esta regla. Si la igualdad utiliza una identidad diferente, como un identificador de miembro, añadir solo el nombre como criterio de desempate no establece la consistencia.

La comparación también debe comportarse como un orden correcto. Si a va antes que b, la comparación inversa debe colocar b después de a. Si a va antes que b y b antes que c, a debe ir antes que c. Utilizar métodos que comparan campos completos en un orden fijo de prioridad ayuda a cumplir estas reglas. Un método inconsistente puede ordenar mal los resultados o hacer que una ordenación lance IllegalArgumentException.

Mantén también ordenadas las claves de los mapas

Un TreeMap ordena las claves, no los valores. Para los recuentos de palabras de «el gato vio el perro y el gato corrió», la primera clave es «corrió» y la última es «y». firstKey() y lastKey() proporcionan esos extremos. Declara un TreeMap o una interfaz de mapa ordenado adecuada cuando llames a métodos que Map no declara.

La comparación de claves también define qué claves coinciden. Una segunda clave que se compare como cero actualiza la asociación existente, aunque equals distinga los objetos. Las colecciones basadas en árboles predeterminadas requieren elementos o claves comparables naturalmente; insertar un objeto sin una comparación adecuada lanza ClassCastException. Un comparador proporcionado explícitamente puede definir otro orden.

El coste de una operación describe cómo crece su trabajo con el número de elementos almacenados. Ayuda a identificar código que es rápido para un ejemplo pequeño, pero lento cuando la colección crece.

Compara el crecimiento, no los segundos

El tiempo constante, O(1), se mantiene aproximadamente independiente del tamaño de la colección. El tiempo lineal, O(n), puede crecer en proporción al número de elementos. El tiempo logarítmico, O(log n), crece lentamente al aumentar el tamaño. Estas etiquetas describen el crecimiento, no tiempos de ejecución exactos en un equipo concreto.

Una búsqueda en un ArrayList puede comprobar todos los elementos; las modificaciones al principio desplazan los elementos posteriores. Un LinkedList debe recorrer la lista hasta llegar a una posición, por lo que acceder repetidamente por índice puede ser costoso. ArrayList es una opción predeterminada útil para el trabajo habitual con listas.

Detecta el recorrido repetido

Supón que un programa comprueba 10 000 nombres frente a una lista que contiene 100 000 nombres. Llamar a list.contains(name) para cada nombre puede requerir hasta 1 000 000 000 de comprobaciones de igualdad. Una llamada a un método que parece rápida sigue siendo una búsqueda completa cuando se utiliza de esta forma.

Construye una vez un conjunto para comprobar la pertenencia:

Set<String> allowed = new HashSet<>(allowedNames);
int matches = 0;
for (String name : incomingNames) {
    if (allowed.contains(name)) {
        matches++;
    }
}

Hay trabajo para construir el conjunto de 100 000 elementos, seguido de 10 000 comprobaciones de pertenencia de tiempo constante en promedio. Contando ambas etapas, el total crece aproximadamente con la suma de los tamaños de las dos entradas, en lugar de con su producto. Volver a construir el conjunto dentro del bucle repetiría el trabajo de preparación y perdería esa ventaja.

Interpreta correctamente las garantías promedio

Las operaciones basadas en hash dependen de claves cuyos códigos hash distribuyan bien los valores. Devolver un código hash constante para todos los objetos puede seguir cumpliendo los requisitos de igualdad, pero hace lenta la búsqueda. No es una forma gratuita de evitar escribir un método hash útil.

Las colecciones basadas en árboles mantienen el orden con operaciones básicas de tiempo logarítmico. Duplicar el número de elementos añade solo una pequeña cantidad de trabajo de búsqueda. Para 100 000 elementos, un logaritmo en base dos es aproximadamente 16,6; esto sugiere la escala de la búsqueda, no una garantía exacta de 17 comparaciones en cada búsqueda en un árbol de Java.

Ten en cuenta toda la tarea

Construir un conjunto adicional cuesta tiempo y memoria. Para unos pocos elementos o una sola búsqueda, la lista original puede ser suficiente. Para comprobaciones de pertenencia repetidas, un conjunto reutilizable suele eliminar el coste principal. Empieza por el comportamiento requerido y después examina las operaciones que se repiten con más frecuencia.

La colección adecuada conserva la información que necesita el programa y facilita expresar sus preguntas principales. Decide las reglas de los datos antes de elegir el nombre de una clase conocida.

Pregunta qué identifica un elemento

Un double[12] puede contener la precipitación en milímetros cuando cada posición corresponde a un mes conocido. Un mapa cuyas claves son solo las posiciones 0, 1, 2 y así sucesivamente añade una capa que una lista o un arreglo ya proporciona.

Elige el orden que necesitas

Para mapas y conjuntos, utiliza HashMap o HashSet cuando no se requiera un orden, LinkedHashMap o LinkedHashSet para el orden de inserción y TreeMap o TreeSet para claves o elementos ordenados. Para una lista de uso general, empieza con ArrayList.

Los recuentos de palabras impresos en orden alfabético se ajustan a un TreeMap<String, Integer>. Una lista de etiquetas distintas en el orden en que aparecieron por primera vez se ajusta a un LinkedHashSet<String>. Las canciones repetidas necesitan una lista aunque también estén almacenadas en otro lugar en un conjunto: descartar las repeticiones cambiaría la lista de reproducción.

Combina colecciones cuando los datos tienen capas

Los estudiantes por curso pueden representarse con Map<String, List<String>>; cada valor es una lista ordenada de inscripciones. Las etiquetas por artículo pueden representarse con Map<String, Set<String>>; cada artículo obtiene etiquetas distintas. Una clasificación puede ser una List<Player> ordenada según la comparación natural del jugador.

Las elecciones externas e internas responden a preguntas diferentes. Si los cursos deben listarse en orden alfabético y los estudiantes deben conservarse en orden de inscripción, utiliza un TreeMap por fuera y una lista por dentro. Ordenar las claves no ordena las listas. Si deben ignorarse los registros de inscripción duplicados, utiliza un conjunto para los grupos internos.

Mantén juntos los datos relacionados

Dos listas paralelas, una para nombres y otra para números de teléfono, dependen de que las posiciones coincidan. Eliminar un nombre sin su número desajusta todos los pares posteriores. Si los nombres identifican de forma única a las personas, un mapa puede contener la asociación. Si los nombres se repiten o varios campos pertenecen a una persona, conserva objetos de persona en una lista o indéxalos mediante un identificador único.

Buscar una y otra vez en una lista por un campo es otra señal para considerar un índice basado en un mapa. Conserva también la lista si importan el orden de presentación y las entradas repetidas, pero mantén ambas estructuras coordinadas cuando se añadan o eliminen datos.

Comprueba las reglas de los elementos y el tipo declarado

Utiliza una declaración de interfaz como Map<String, Double> prices = new HashMap<>(); para que quienes llaman dependan de las operaciones de mapa que necesitan. Las colecciones basadas en hash necesitan una igualdad significativa y códigos hash coherentes para claves o elementos propios. Las colecciones basadas en árboles predeterminadas necesitan una comparación natural que distinga exactamente los valores que la colección debe conservar. Estas reglas forman parte de conseguir que la colección elegida represente los datos previstos.