Estructuras de Datos en Java: Listas, Pilas, Colas y Conjuntos (con Ejemplos)

Estructuras de Datos en Java: Referencia Rápida

📌 Interfaces e implementaciones

List<T> lista = new ArrayList<>();
List<T> lista = new LinkedList<>();

✅ Métodos básicos

🔁 Recorrer una lista

// for clásico
for (int i = 0; i < lista.size(); i++) {
    System.out.println(lista.get(i));
}

// for-each
for (T elem : lista) {
    System.out.println(elem);
}

🧪 Ejemplo exprés

List<String> nombres = new ArrayList<>();
nombres.add("Ana");
nombres.add("Luis");
nombres.add(1, "Pedro");
nombres.set(0, "María");
nombres.remove(2);
System.out.println(nombres.get(0)); // María
System.out.println(nombres.size()); // 2

🎓 PILAS (Stack<E>)

Crear pila:

Stack<T> pila = new Stack<>();

Métodos:

• push(E e): apila (mete un elemento).

• pop(): desapila (saca el elemento superior).

• peek(): consulta el elemento superior sin eliminarlo.

• isEmpty(): verifica si la pila está vacía.

• search(E e): devuelve la posición (1 es la cima) o -1 si no está.

Recorrer con Iterator:

Iterator<T> it = pila.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

Ejemplo:

Stack<Integer> pila = new Stack<>();
pila.push(1);
pila.push(2);
System.out.println(pila.pop()); // 2
System.out.println(pila.peek()); // 1

🚶 COLAS (Queue<E>, LinkedList<E>, Deque<E>)

Crear cola:

Queue<T> cola = new LinkedList<>();
Deque<T> colaDoble = new LinkedList<>();

Métodos:

• add(E e) / offer(E e): añadir.

• poll(): eliminar y devolver cabeza.

• peek(): ver cabeza sin eliminar.

• isEmpty(): vacía o no.

Recorrer cola:

for (T elem : cola) {
    System.out.println(elem);
}

Recorrer cola inversa:

Iterator<T> it = ((LinkedList<T>) cola).descendingIterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

🔹 LISTAS (List<E>, ArrayList, LinkedList)

Crear lista:

List<T> lista = new ArrayList<>();

Métodos clave:

• add(e) / add(i, e)

• get(i), set(i, e), remove(i)

• size(), isEmpty()

• contains(e), indexOf(e)

• clear()

Ordenar:

Collections.sort(lista); // si los elementos son comparables
lista.sort(Comparator.comparing(Alumno::getNota).reversed());

Recorrer:

for (T e : lista) {
    System.out.println(e);
}

🔍 CONJUNTOS (Set<E>, HashSet, TreeSet)

Crear conjunto:

Set<T> conjunto = new HashSet<>(); // no ordenado
Set<T> conjuntoOrdenado = new TreeSet<>(); // ordenado

Métodos:

• add(e), remove(e)

• contains(e), isEmpty(), size()

• clear(), addAll(otroSet)

• Operaciones de conjuntos: retainAll(), removeAll(), etc.

✍️ SINTAXIS BÁSICA PARA ARCHIVOS

BufferedReader br = new BufferedReader(new FileReader("archivo.txt"));
String linea;
while ((linea = br.readLine()) != null) {
    // Procesar la linea
}
br.close();

⚡ COMPARADORES

Y CLASES PERSONALIZADAS

Clase ejemplo:

class Alumno {
    String nombre;
    double nota;

    // Constructor, getters, setters...
}

Ordenar por nota descendente:

lista.sort((a, b) -> Double.compare(b.getNota(), a.getNota()));

🔥 COSAS CLAVE

• Usa Stack para problemas tipo "último en entrar, primero en salir" (p. ej. paréntesis, inversiones).

• Usa Queue para procesos secuenciales (colas de espera, turnos).

• Usa Deque para recorridos en ambas direcciones.

• Usa Set para eliminar duplicados y comparar ingredientes.

• Ordena listas con Comparator o Comparable según el caso.