📌 1.
¿Qué es realmente un ArrayList
por dentro?
Un ArrayList en Java es una estructura basada en un array interno dinámico.
👉 Internamente funciona así:
● Java crea un array “oculto”
● Cuando se llena, crea otro más grande (normalmente ×1.5)
● Copia los elementos al nuevo array
● Borra el antiguo
📌 Por eso:
● Es dinámico
● Pero más lento que un array en algunos casos
📌 2. Capacidad vs tamaño
Esto es MUY preguntado.
✔ Tamaño (size)
👉 Elementos que tienes realmente dentro
✔ Capacidad (capacity)
👉 Espacio reservado en memoria
Ejemplo conceptual:
Capacidad: 10
Elementos: 3
📌 3. Constructor de ArrayList
✔ Vacío
ArrayList<String> lista = new ArrayList<>();
✔ Con capacidad inicial (optimización)
ArrayList<String> lista = new ArrayList<>(20);
👉 No cambia el tamaño, solo mejora rendimiento
📌 4. Complejidad (IMPORTANTE para
teoría)
Operación Tiempo
Acceder (get) O(1)
Añadir al final (add) O(1) amortizado
Insertar en medio O(n)
Eliminar O(n)
👉 Conclusión:
● Muy rápido para leer
● Más lento para insertar/borrar en medio
📌 5. Inserción en posiciones
[Link](0, "Inicio");
👉 Inserta desplazando todos los elementos
Ejemplo:
ArrayList<String> lista = new ArrayList<>();
[Link]("B");
[Link]("C");
[Link](0, "A");
Resultado:
A, B, C
📌 6. Eliminación con cuidado
[Link](1);
👉 IMPORTANTE:
● Si eliminas, los índices se reorganizan automáticamente
📌 7. Null en ArrayList
Un ArrayList SÍ puede guardar null:
[Link](null);
👉 Pero no es recomendable porque:
● Puede dar errores en comparaciones
● Complica búsquedas
📌 8. Ordenación de ArrayList
✔ Orden natural (números / strings)
import [Link];
[Link](lista);
Ejemplo:
ArrayList<Integer> nums = new ArrayList<>();
[Link](5);
[Link](1);
[Link](3);
[Link](nums);
Resultado:
1, 3, 5
📌 9. Ordenación personalizada
(IMPORTANTE)
Con objetos:
import [Link];
[Link](lista, new Comparator<String>() {
public int compare(String a, String b) {
return [Link]() - [Link]();
});
👉 Ordena por longitud
📌 10. ArrayList con objetos (más
profundo)
Ejemplo:
class Alumno {
String nombre;
int nota;
Alumno(String nombre, int nota) {
[Link] = nombre;
[Link] = nota;
Lista:
ArrayList<Alumno> alumnos = new ArrayList<>();
[Link](new Alumno("Ana", 8));
[Link](new Alumno("Luis", 5));
Recorrido:
for (Alumno a : alumnos) {
[Link]([Link] + " " + [Link]);
📌 11. Búsqueda en ArrayList
✔ contains()
[Link]("Ana");
👉 Usa equals() internamente
✔ indexOf()
[Link]("Ana");
👉 Devuelve:
● posición si existe
● -1 si no existe
📌 12. Diferencia importante: equals vs
==
❌ MAL:
if ([Link](0) == "Ana")
✔ BIEN:
if ([Link](0).equals("Ana"))
👉 Porque ArrayList trabaja con objetos
📌 13. Iteradores (nivel más avanzado)
import [Link];
Iterator<String> it = [Link]();
while ([Link]()) {
[Link]([Link]());
👉 Sirve para recorrer de forma segura
📌 14. Eliminar mientras recorres
(IMPORTANTE)
❌ MAL:
for (String s : lista) {
[Link](s); // ERROR
✔ BIEN:
Iterator<String> it = [Link]();
while ([Link]()) {
if ([Link]().equals("Ana")) {
[Link]();
}
📌 15. Conversión Array ↔ ArrayList
Array → ArrayList
String[] array = {"A", "B"};
ArrayList<String> lista = new ArrayList<>([Link](array));
ArrayList → Array
String[] array = [Link](new String[0]);
📌 16. Resumen conceptual final
✔ ArrayList = array dinámico
✔ Internamente usa arrays
✔ Más flexible que array normal
✔ Mejor para añadir/eliminar
✔ Peor en rendimiento en inserciones intermedias
✔ Muy usado con objetos
✔ Tiene métodos propios (add, remove, get...)
¿Qué es un ArrayList?
Un ArrayList es una estructura de datos de Java que permite almacenar listas dinámicas
de elementos.
👉 Es como un array, pero con ventajas:
● Crece y se reduce automáticamente
● No necesitas decir su tamaño al crearlo
● Permite añadir, borrar y modificar elementos fácilmente
📌 Importación
Antes de usarlo:
import [Link];
📌 Declaración de un ArrayList
ArrayList<String> lista = new ArrayList<>();
👉 Aquí:
● String = tipo de datos que guardas
● lista = nombre del ArrayList
También puedes usar otros tipos:
ArrayList<Integer> numeros = new ArrayList<>();
ArrayList<Double> precios = new ArrayList<>();
📌 Métodos principales (MUY
IMPORTANTE)
1. ➕ Añadir elementos → add()
[Link]("Ana");
[Link]("Luis");
👉 Añade elementos al final.
2. 📍 Acceder a un elemento → get()
[Link]([Link](0)); // Ana
👉 IMPORTANTE: empieza en índice 0
3. ✏️ Modificar → set()
[Link](0, "Carlos");
👉 Cambia el valor de una posición
4. ❌ Eliminar → remove()
[Link](0); // elimina el primer elemento
[Link]("Luis"); // elimina por valor
5. 📏 Tamaño → size()
[Link]([Link]());
👉 Devuelve cuántos elementos hay
6. 🔍 Buscar → contains()
[Link]("Ana");
👉 Devuelve true o false
7. 🧹 Vaciar lista → clear()
[Link]();
👉 Borra todos los elementos
📌 Recorrer un ArrayList
1. Con for clásico
for (int i = 0; i < [Link](); i++) {
[Link]([Link](i));
}
2. Con foreach (más usado)
for (String nombre : lista) {
[Link](nombre);
}
📌 Ejemplo completo
import [Link];
public class Main {
public static void main(String[] args) {
ArrayList<String> alumnos = new ArrayList<>();
// Añadir
[Link]("Ana");
[Link]("Luis");
[Link]("Carlos");
// Mostrar
for (String a : alumnos) {
[Link](a);
}
// Modificar
[Link](1, "Lucía");
// Eliminar
[Link]("Ana");
// Tamaño
[Link]("Total: " + [Link]());
// Buscar
if ([Link]("Carlos")) {
[Link]("Está Carlos");
}
}
}
📌 Array vs ArrayList (MUY preguntado)
Array ArrayList
Tamaño fijo Dinámico
Más rápido Más flexible
length size()
Difícil de modificar Fácil de modificar
📌 ArrayList con objetos (IMPORTANTE
EN EXÁMENES)
Ejemplo con clase:
class Coche {
String marca;
int km;
Coche(String marca, int km) {
[Link] = marca;
[Link] = km;
}
}
Uso:
ArrayList<Coche> coches = new ArrayList<>();
[Link](new Coche("BMW", 10000));
[Link](new Coche("Audi", 5000));
Recorrer:
for (Coche c : coches) {
[Link]([Link] + " - " + [Link]);
}
📌 Errores típicos
❌ Acceder a posición que no existe:
[Link](10); // ERROR si no hay 10 elementos
❌ No usar genéricos:
ArrayList lista = new ArrayList(); // malo (sin tipo)
✔ Correcto:
ArrayList<String> lista = new ArrayList<>();