Tu chuleta de supervivencia. Guárdala a mano en una pestaña del navegador cuando programes en Eclipse.
El "tren de vagones". Puedes añadir o quitar vagones sobre la marcha. Ideal para almacenar datos cuando no sabes cuántos vas a tener, pero necesitas acceder a ellos rápidamente por su posición.
Crear, añadir y medir:
// La etiqueta <String> obliga a que solo entren textos
ArrayList<String> listaCompra = new ArrayList<>();
// Se colocan uno detrás de otro
listaCompra.add("Leche");
listaCompra.add("Pan");
// En colecciones usamos .size(), no .length
int totalArticulos = listaCompra.size(); Recuperar y borrar:
// Saca el vagón número 1 (el "Pan", recuerda que empezamos a contar en 0)
String articulo = listaCompra.get(1);
// Borrar. Los demás vagones se juntan solos automáticamente
listaCompra.remove("Leche"); // Borra por nombre
listaCompra.remove(0); // Borra por posiciónEl "hermano gemelo" del ArrayList. Por fuera se usan igual, pero por dentro están construidos de otra forma. Úsalo si tu programa va a estar constantemente borrando e insertando datos en medio de la lista (es más eficiente para eso).
LinkedList<String> colaDelCine = new LinkedList<>();
colaDelCine.add("Juan");
colaDelCine.add("María");
// LinkedList tiene métodos extra muy útiles para trabajar en los extremos:
colaDelCine.addFirst("Vip"); // Se cuela el primero
colaDelCine.removeLast(); // Echan al últimoEl "Álbum de cromos". Su superpoder es que no admite repetidos. El problema es que es caótico: no guarda el orden en el que metes las cosas.
HashSet<String> cromos = new HashSet<>();
cromos.add("Messi");
cromos.add("Pelé");
cromos.add("Messi"); // ¡Esta línea se ignora automáticamente! No hay duplicados.
// No puedes usar .get(0) porque no hay posiciones fijas. Debes recorrerlo:
for (String cromo : cromos) {
System.out.println(cromo);
}Si necesitas que tu conjunto sin duplicados mantenga un orden, usa estas variantes.
El Conjunto Alfabético (TreeSet): Se ordena solo automáticamente (de la A a la Z, o de menor a mayor).
TreeSet<String> ranking = new TreeSet<>();
ranking.add("Zeta");
ranking.add("Alfa");
// Al recorrerlo, siempre saldrá "Alfa" primero.El Conjunto por orden de llegada (LinkedHashSet):
Respeta estrictamente el orden en el que hiciste los .add().
LinkedHashSet<String> filaDelPan = new LinkedHashSet<>();
filaDelPan.add("Abuela");
filaDelPan.add("Chavalero");
// Al recorrerlo, siempre saldrá primero la "Abuela".Funciona por pares: una Clave (única) que abre un Valor. Tampoco garantiza el orden.
Guardar y recuperar:
// Clave: DNI (String) -> Valor: Nombre (String)
HashMap<String, String> agenda = new HashMap<>();
// Guardar en el Mapa (put en lugar de add)
agenda.put("111A", "Ana");
agenda.put("222B", "Luis");
// Buscar por la Clave (get)
String persona = agenda.get("111A"); // Devuelve "Ana"Recorrer todo el Mapa (Pedir el llavero keySet):
for (String llaveDni : agenda.keySet()) {
// Abrimos la taquilla con cada llave para sacar el valor
String nombre = agenda.get(llaveDni);
System.out.println("El DNI " + llaveDni + " pertenece a " + nombre);
}(Nota: Al igual que con los Sets, tienes TreeMap para ordenar por la clave alfabéticamente, y LinkedHashMap para mantener el orden de inserción).
El secreto para escribir código escalable y profesional.
List, Set y Map son INTERFACES (solo son el plano o el contrato). Por tanto, ¡nunca puedes construirlas directamente con new! Lo correcto es declarar la interfaz a la izquierda y la implementación concreta a la derecha.
// BIEN: A la izquierda la Interfaz (general), a la derecha la Clase (concreta)
List<String> miLista = new ArrayList<>();
Set<Integer> misNumeros = new HashSet<>();
Map<String, String> miDiccionario = new HashMap<>();
// MAL (Da error de compilación porque List no es instanciable):
// List<String> error = new List<>(); Imagina una cinta transportadora. El Iterator es la forma 100% segura de recorrer una colección y borrar elementos al mismo tiempo sin que Java sufra un cortocircuito (ConcurrentModificationException). Nunca borres elementos dentro de un bucle for-each normal.
List<String> cajas = new ArrayList<>();
cajas.add("Vaso");
cajas.add("Libro roto");
cajas.add("Plato");
// 1. Llamamos al inspector (Iterator)
Iterator<String> inspector = cajas.iterator();
// 2. Mientras la cinta transportadora siga teniendo cajas...
while (inspector.hasNext()) {
// 3. Miramos la siguiente caja y la cinta avanza
String cajaActual = inspector.next();
// 4. Si la caja está defectuosa, la retiramos de la colección de forma segura
if (cajaActual.equals("Libro roto")) {
inspector.remove();
System.out.println("Se ha retirado un elemento defectuoso.");
}
}