Colecciones

## Objetivos de Aprendizaje - Dominar las interfaces List, Set, Map - Comprender la jerarquía de colecciones - Elegir tipos de colección apropiados - Trabajar con iteradores ## Jerarquía de Colecciones ```text Iterable ├── Collection │ ├── List (ordenada, duplicados) │ │ ├── ArrayList │ │ ├── LinkedList │ │ └── Vector │ ├── Set (sin orden, sin duplicados) │ │ ├── HashSet │ │ ├── LinkedHashSet │ │ └── TreeSet │ └── Queue (FIFO) │ ├── LinkedList │ ├── PriorityQueue │ └── Deque └── Map (pares clave-valor) ├── HashMap ├── LinkedHashMap ├── TreeMap └── Hashtable ``` ## Interfaz List ### ArrayList (Más Común) ```java import java.util.ArrayList; ArrayList list = new ArrayList<>(); list.add("Apple"); list.add("Banana"); list.add("Orange"); // Acceso System.out.println(list.get(0)); // Apple System.out.println(list.size()); // 3 System.out.println(list.contains("Apple")); // true // Modificar list.set(1, "Mango"); list.remove("Apple"); ``` ### LinkedList ```java import java.util.LinkedList; LinkedList list = new LinkedList<>(); list.add("First"); list.addFirst("BeforeFirst"); list.addLast("Last"); String first = list.getFirst(); String last = list.getLast(); list.removeFirst(); list.removeLast(); ``` ### Métodos Comunes de List ```java list.add(element); // Agregar list.add(index, element); // Insertar en posición list.get(index); // Obtener elemento list.set(index, element); // Reemplazar list.remove(index); // Remover por índice list.remove(Object); // Remover por valor list.size(); // Número de elementos list.contains(Object); // Contiene elemento list.indexOf(Object); // Primera ocurrencia list.lastIndexOf(Object); // Última ocurrencia list.clear(); // Remover todos ``` ## Interfaz Set ### HashSet (Más Común) ```java import java.util.HashSet; HashSet set = new HashSet<>(); set.add("Apple"); set.add("Banana"); set.add("Apple"); // Duplicado - ignorado System.out.println(set.size()); // 2 System.out.println(set.contains("Apple")); // true set.remove("Banana"); ``` ### LinkedHashSet Preserva el orden de inserción: ```java LinkedHashSet set = new LinkedHashSet<>(); set.add("First"); set.add("Second"); set.add("Third"); // Iteración: First, Second, Third ``` ### TreeSet Orden sorted: ```java TreeSet set = new TreeSet<>(); set.add(3); set.add(1); set.add(2); // Iteración: 1, 2, 3 // Métodos set.lower(2); // 1 (mayor < 2) set.higher(2); // 3 (menor > 2) set.floor(2); // 2 (mayor <= 2) set.ceiling(2); // 2 (menor >= 2) ``` ## Interfaz Map ### HashMap (Más Común) ```java import java.util.HashMap; HashMap map = new HashMap<>(); map.put("Alice", 25); map.put("Bob", 30); map.put("Charlie", 35); System.out.println(map.get("Alice")); // 25 System.out.println(map.size()); // 3 System.out.println(map.containsKey("Bob")); // true map.put("Alice", 26); // Actualizar valor map.remove("Charlie"); ``` ### TreeMap Ordenado por claves: ```java TreeMap map = new TreeMap<>(); map.put("Charlie", 35); map.put("Alice", 25); map.put("Bob", 30); // Iteración: Alice(25), Bob(30), Charlie(35) ``` ### Métodos de Map ```java map.put(key, value); // Agregar/actualizar map.get(key); // Obtener valor map.remove(key); // Remover map.containsKey(key); // Existe clave map.containsValue(value); // Existe valor map.size(); // Número de entradas map.keySet(); // Conjunto de claves map.values(); // Colección de valores map.entrySet(); // Conjunto de pares clave-valor map.getOrDefault(key, default); // Obtener o valor por defecto ``` ### Iterar Map ```java // Claves for (String key : map.keySet()) { System.out.println(key); } // Valores for (Integer value : map.values()) { System.out.println(value); } // Entradas for (Map.Entry entry : map.entrySet()) { System.out.println(entry.getKey() + ": " + entry.getValue()); } // Java 8+ forEach map.forEach((key, value) -> { System.out.println(key + ": " + value); }); ``` ## Interfaz Queue ### LinkedList como Queue ```java import java.util.LinkedList; import java.util.Queue; Queue queue = new LinkedList<>(); queue.offer("First"); queue.offer("Second"); queue.offer("Third"); System.out.println(queue.peek()); // First (ver) System.out.println(queue.poll()); // First (remover) System.out.println(queue.size()); // 2 ``` ### PriorityQueue ```java PriorityQueue pq = new PriorityQueue<>(); pq.offer(3); pq.offer(1); pq.offer(2); System.out.println(pq.poll()); // 1 (más pequeño) System.out.println(pq.poll()); // 2 System.out.println(pq.poll()); // 3 ``` ## Interfaz Deque ### Cola de Doble Final ```java import java.util.ArrayDeque; ArrayDeque deque = new ArrayDeque<>(); deque.addFirst("First"); deque.addLast("Last"); System.out.println(deque.getFirst()); // First System.out.println(deque.getLast()); // Last deque.removeFirst(); deque.removeLast(); ``` ## Elegir Colección | Necesidad | Colección | |-----------|-----------| | Búsqueda rápida por índice | ArrayList | | Agregar/remover de ambos extremos | LinkedList | | Elementos únicos, sin orden | HashSet | | Elementos únicos, orden de inserción | LinkedHashSet | | Elementos únicos, ordenados | TreeSet | | Pares clave-valor | HashMap | | Pares clave-valor, claves ordenadas | TreeMap | | Cola FIFO | Queue / LinkedList | | Procesamiento por prioridad | PriorityQueue | | Pila (LIFO) | Deque / ArrayDeque | ## Arreglos vs Colecciones ```java // Arreglos: tamaño fijo, primitivos OK String[] array = new String[10]; array[0] = "Apple"; // Colecciones: tamaño dinámico, solo objetos ArrayList list = new ArrayList<>(); list.add("Apple"); list.add("Banana"); ``` ## Convirtiendo ### Arreglo a Lista ```java String[] array = {"A", "B", "C"}; List list = Arrays.asList(array); List list2 = new ArrayList<>(Arrays.asList(array)); ``` ### Lista a Arreglo ```java List list = new ArrayList<>(); list.add("A"); list.add("B"); String[] array = list.toArray(new String[0]); ``` ## Resumen - **List**: Ordenada, duplicados - ArrayList más común - **Set**: Sin orden, únicos - HashSet más común - **Map**: Clave-valor - HashMap más común - **Queue**: FIFO - LinkedList o PriorityQueue - **Deque**: Ambos extremos - ArrayDeque - Usar generics: `ArrayList`, `HashMap` - Elegir basándose en: orden, unicidad, necesidades de rendimiento