Hytale Modding
Conceptos básicos de Java

10 - ArrayList y Collections

Aprende a usar colecciones flexibles y redimensiónales en Java.

Los arrays tienen un tamaño fijo, pero ¿qué pasa si necesitas añadir o eliminar elementos? Ahí es donde entra ArrayList: una colección redimensiónale que crece y se reduce automáticamente.

Conceptos básicos de ArrayList

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        // Crear un ArrayList de Strings
        ArrayList<String> jugadores = new ArrayList<>();
        
        // Agregar elementos
        jugadores.add("Alice");
        jugadores.add("Bob");
        jugadores.add("Charlie");
        
        System.out.println(jugadores);  // [Alice, Bob, Charlie]
    }
}
ArrayList vs Array
ArrayArrayList
Tamaño fijoRedimensionable (crece o se reduce)
Puede contener tipos primitivos (int, double, etc.)Solo puede contener objetos (Integer, Double, String, etc.)
Acceso más rápidoMás funcionalidades (agregar, eliminar, etc.)
int[] numbers = new int[10];ArrayList<Integer> numbers = new ArrayList<>();

Creación de ArrayLists

import java.util.ArrayList;

// ArrayList vacío
ArrayList<String> elementos = new ArrayList<>();

// Con valores iniciales (Java 9+)
ArrayList<String> colores = new ArrayList<>(List.of("Rojo", "Verde", "Azul"));

// Diferentes tipos
ArrayList<Integer> numeros = new ArrayList<>();
ArrayList<Double> precios = new ArrayList<>();
ArrayList<Boolean> banderas = new ArrayList<>();
Tipos primitivos en ArrayList

No se pueden usar tipos primitivos directamente. Usa sus clases envolventes:

// Incorrecto
ArrayList<int> numeros = new ArrayList<>(); // ❌ No permitido

// Correcto - Usar clase envolvente
ArrayList<Integer> numeros = new ArrayList<>(); // ✅ Permitido

Clases envolventes:

  • int → Integer
  • double → Double
  • boolean → Boolean
  • char → Character

Métodos comunes de ArrayList

Añadir elementos

ArrayList<String> items = new ArrayList<>();

items.add("Espada");           // Agregar al final
items.add("Escudo");
items.add(0, "Casco");        // Agregar en un índice específico

System.out.println(items);    // [Casco, Espada, Escudo]

Acceso a los elementos

ArrayList<String> items = new ArrayList<>();
items.add("Espada");
items.add("Escudo");

String primero = items.get(0);   // "Espada"
String segundo = items.get(1);   // "Escudo"

int tamaño = items.size();       // 2

Eliminar elementos

ArrayList<String> items = new ArrayList<>();
items.add("Espada");
items.add("Escudo");
items.add("Poción");

items.remove(1);               // Eliminar por índice (Escudo)
items.remove("Poción");        // Eliminar por valor

System.out.println(items);     // [Espada]

Comprobación de contenidos

ArrayList<String> items = new ArrayList<>();
items.add("Espada");
items.add("Escudo");

boolean tieneEspada = items.contains("Espada");   // true
boolean tieneHacha = items.contains("Hacha");     // false

boolean estaVacia = items.isEmpty();              // false
int tamaño = items.size();                        // 2

Modificación de elementos

ArrayList<String> items = new ArrayList<>();
items.add("Espada de Madera");

items.set(0, "Espada de Hierro");    // Reemplazar en el índice 0

System.out.println(items);           // [Espada de Hierro]

Borrar todos los elementos

ArrayList<String> items = new ArrayList<>();
items.add("Espada");
items.add("Escudo");

items.clear();                 // Eliminar todo
System.out.println(items);     // []

Recorriendo un ArrayList

Usando bucle for

ArrayList<String> jugadores = new ArrayList<>();
jugadores.add("Alicia");
jugadores.add("Bob");
jugadores.add("Carlos");

for (int i = 0; i < jugadores.size(); i++) {
    System.out.println(jugadores.get(i));
}

Usando bucle for mejorado

for (String jugador : jugadores) {
    System.out.println(jugador);
}

Usando forEach (Java 8+)

```java
jugadores.forEach(jugador -> System.out.println(jugador));
```

Ejemplos prácticos

Sistema de inventario del jugador

import java.util.ArrayList;

public class Inventario {
    private ArrayList<String> items;
    private int tamañoMaximo;
    
    public Inventario(int tamañoMaximo) {
        this.items = new ArrayList<>();
        this.tamañoMaximo = tamañoMaximo;
    }
    
    public boolean agregarItem(String item) {
        if (items.size() >= tamañoMaximo) {
            System.out.println("¡Inventario lleno!");
            return false;
        }
        
        items.add(item);
        System.out.println("Agregado: " + item);
        return true;
    }
    
    public boolean eliminarItem(String item) {
        if (items.remove(item)) {
            System.out.println("Eliminado: " + item);
            return true;
        }
        
        System.out.println("¡Objeto no encontrado!");
        return false;
    }
    
    public void mostrarInventario() {
        System.out.println("=== Inventario (" + items.size() + "/" + tamañoMaximo + ") ===");
        for (int i = 0; i < items.size(); i++) {
            System.out.println((i + 1) + ". " + items.get(i));
        }
    }
    
    public int contarItems() {
        return items.size();
    }
    
    public boolean estaLleno() {
        return items.size() >= tamañoMaximo;
    }
}

// Uso
public class Main {
    public static void main(String[] args) {
        Inventario inv = new Inventario(5);
        
        inv.agregarItem("Espada");
        inv.agregarItem("Escudo");
        inv.agregarItem("Poción");
        inv.mostrarInventario();
        
        inv.eliminarItem("Escudo");
        inv.mostrarInventario();
    }
}

Sistema de misiones

import java.util.ArrayList;

public class GestorMisiones {
    private ArrayList<String> misionesActivas;
    private ArrayList<String> misionesCompletadas;
    
    public GestorMisiones() {
        this.misionesActivas = new ArrayList<>();
        this.misionesCompletadas = new ArrayList<>();
    }
    
    public void iniciarMision(String nombreMision) {
        if (!misionesActivas.contains(nombreMision)) {
            misionesActivas.add(nombreMision);
            System.out.println("Misión iniciada: " + nombreMision);
        } else {
            System.out.println("¡La misión ya está activa!");
        }
    }
    
    public void completarMision(String nombreMision) {
        if (misionesActivas.remove(nombreMision)) {
            misionesCompletadas.add(nombreMision);
            System.out.println("Misión completada: " + nombreMision);
        } else {
            System.out.println("¡Misión no encontrada entre las activas!");
        }
    }
    
    public void mostrarMisiones() {
        System.out.println("\n=== Misiones Activas ===");
        if (misionesActivas.isEmpty()) {
            System.out.println("No hay misiones activas");
        } else {
            for (String mision : misionesActivas) {
                System.out.println("- " + mision);
            }
        }
        
        System.out.println("\n=== Misiones Completadas ===");
        if (misionesCompletadas.isEmpty()) {
            System.out.println("No hay misiones completadas");
        } else {
            for (String mision : misionesCompletadas) {
                System.out.println("- " + mision);
            }
        }
    }
    
    public int obtenerTotalCompletadas() {
        return misionesCompletadas.size();
    }
}

Sistema de clasificación

import java.util.ArrayList;
import java.util.Collections;

public class TablaPosiciones {
    private ArrayList<Integer> puntajes;
    private ArrayList<String> jugadores;
    
    public TablaPosiciones() {
        this.puntajes = new ArrayList<>();
        this.jugadores = new ArrayList<>();
    }
    
    public void agregarPuntaje(String jugador, int puntaje) {
        jugadores.add(jugador);
        puntajes.add(puntaje);
        System.out.println(jugador + " obtuvo " + puntaje + " puntos!");
    }
    
    public void mostrarTop(int cantidad) {
        System.out.println("\n=== Top " + cantidad + " Jugadores ===");
        
        // Crear copias para ordenar
        ArrayList<Integer> puntajesOrdenados = new ArrayList<>(puntajes);
        ArrayList<String> jugadoresOrdenados = new ArrayList<>(jugadores);
        
        // Ordenamiento burbuja (simple para aprendizaje)
        for (int i = 0; i < puntajesOrdenados.size() - 1; i++) {
            for (int j = 0; j < puntajesOrdenados.size() - i - 1; j++) {
                if (puntajesOrdenados.get(j) < puntajesOrdenados.get(j + 1)) {
                    // Intercambiar puntajes
                    int tempPuntaje = puntajesOrdenados.get(j);
                    puntajesOrdenados.set(j, puntajesOrdenados.get(j + 1));
                    puntajesOrdenados.set(j + 1, tempPuntaje);
                    
                    // Intercambiar jugadores
                    String tempJugador = jugadoresOrdenados.get(j);
                    jugadoresOrdenados.set(j, jugadoresOrdenados.get(j + 1));
                    jugadoresOrdenados.set(j + 1, tempJugador);
                }
            }
        }
        
        // Mostrar los mejores puntajes
        int limite = Math.min(cantidad, puntajesOrdenados.size());
        for (int i = 0; i < limite; i++) {
            System.out.println((i + 1) + ". " + jugadoresOrdenados.get(i) + 
                             " - " + puntajesOrdenados.get(i) + " puntos");
        }
    }
}

Seguimiento de jugadores en línea

import java.util.ArrayList;

public class SeguidordeJugadoresOnline{
    private ArrayList<String> jugadoresOnline;
    
    public SeguidordeJugadoresOnline() {
        this.jugadoresOnline = new ArrayList<>();
    }
    
    public void jugadorseUne(String nombreJugador) {
        if (!jugadoresOnline.contains(nombreJugador)) {
            jugadoresOnline.add(nombreJugador);
            broadcast(nombreJugador + " se ha unido a la partida");
            actualizaContadordeJugadores();
        }
    }
    
    public void (String nombreJugador) {
        if (jugadoresOnline.remove(nombreJugador)) {
            broadcast(nombreJugador + " salió de la partida");
            actualizaContadordeJugadores();
        }
    }
    
    public boolean isOnline(String nombreJugador) {
        return jugadoresOnline.contains(nombreJugador);
    }
    
    public int consigueNumeroJugadores() {
        return jugadoresOnline.size();
    }
    
    public void listaJugadores() {
        System.out.println("\n=== Jugadores Online (" + consigueNumeroJugadores() + ") ===");
        for (String jugador : jugadoresOnline) {
            System.out.println("• " + jugador);
        }
    }
    
    private void anuncia(String mensaje) {
        System.out.println("[Servidor] " + mensaje);
    }
    
    private void actualizaContadordeJugadores() {
        System.out.println("Jugadores en línea: " + consigueNumeroJugadores());
    }
}

Array de objetos personalizados

Puedes guardar tus propias clases en ArrayLists:

public class Jugador{
    private String nombre;
    private int nivel;
    
    public Player(String nombre, int nivel) {
        this.nombre= nombre;
        this.nivel= nivel;
    }
    
    public String consigueNombre() {
        return nombre;
    }
    
    public int consigueNivel() {
        return nivel;
    }
    
    @Override
    public String toString() {
        return nombre + " (Nv. " + nivel + ")";
    }
}

public class Main {
    public static void main(String[] args) {
        ArrayList<Jugador> jugadores = new ArrayList<>();
        
        jugadores.add(new Player("Alice", 10));
        jugadores.add(new Player("Bob", 15));
        jugadores.add(new Player("Charlie", 8));
        
        // Mostrar a todos los jugadores
        for (Jugador jugador : jugadores) {
            System.out.println(jugador);
        }
        
        // Encontrar a jugador por el nombre
        for (Jugador jugador: jugadores) {
            if (jugador.getName().equals("Bob")) {
                System.out.println("Encontrado a: " + player);
            }
        }
    }
}

Operaciones útiles de la ArrayList

Convertir a Array

ArrayList<String> lista = new ArrayList<>();
lista.add("A");
lista.add("B");

String[] array = lista.toArray(new String[0]);

Convertir Array a ArrayList

String[] array = {"A", "B", "C"};
ArrayList<String> lista = new ArrayList<>(Arrays.asList(array));

Copiar una ArrayList

ArrayList<String> original = new ArrayList<>();
original.add("A");
original.add("B");

// Copia Superficial (comparte referencia y objeto)
ArrayList<String> copia = new ArrayList<>(original);

Encontrar índice de un elemento

ArrayList<String> items = new ArrayList<>();
items.add("Espada");
items.add("Escudo");

int indice = items.indexOf("Escudo");  // 1
int noEncontrado = items.indexOf("Hacha");  // -1

Ejercicios prácticos

  1. Cesta de compra: Cree un sistema de cesta de compra:

    • Añadir artículos
    • Eliminar artículos
    • Calcular el total de artículos
    • Vaciar carrito

  2. Lista de amigos: Crea un sistema de gestión de amigos:

    • Añadir amigo
    • Eliminar amigo
    • Compruebe si alguien es un amigo
    • Muestre a todos los amigos

  3. Tarea de tareas: Construya una lista de tareas:

    • Añada una tarea
    • Marque las tareas como completas (muévalas a la lista de completadas)
    • Muestre las tareas activas
    • Muestre las tareas completadas

  4. Récord de puntajes: Cree un sistema de récord de puntajes:

    • Añada puntajes
    • Muestre el top 5 de puntajes en orden
    • Remueva el puntaje más bajo si ya existen más de 10 puntajes
Edit on GitHub

09 - Trabajando con cadenas

Domina la manipulación de texto y las operaciones con strings en Java.

11 - Almacenamiento de HashMap y clave-valor

Aprende a almacenar y recuperar datos usando pares clave-valor.

On this page

Conceptos básicos de ArrayList
Creación de ArrayLists
Métodos comunes de ArrayList
Añadir elementos
Acceso a los elementos
Eliminar elementos
Comprobación de contenidos
Modificación de elementos
Borrar todos los elementos
Recorriendo un ArrayList
Usando bucle for
Usando bucle for mejorado
Usando forEach (Java 8+)
Ejemplos prácticos
Sistema de inventario del jugador
Sistema de misiones
Sistema de clasificación
Seguimiento de jugadores en línea
Array de objetos personalizados
Operaciones útiles de la ArrayList
Convertir a Array
Convertir Array a ArrayList
Copiar una ArrayList
Encontrar índice de un elemento
Ejercicios prácticos