Listas, arreglos y cadenas en Java

Un ArrayList almacena valores en orden. Crece cuando añades un elemento y se reduce cuando eliminas uno. Cada elemento tiene un índice, que comienza en 0. Importa la clase antes de usarla: import java.util.ArrayList;.

Crea una lista con un tipo

ArrayList<String> drinks = new ArrayList<>();
drinks.add("tea");
drinks.add("milk");

El tipo dentro de <String> indica qué almacena la lista. El diamante <> de la derecha permite que Java infiera ese mismo tipo. La lista comienza vacía, con tamaño 0; después de estas dos llamadas contiene [tea, milk] y tiene tamaño 2. Imprimir la lista directamente muestra sus elementos: System.out.println(drinks);.

El tipo de elemento de una lista debe ser un tipo de clase. Para números, utiliza una clase envoltorio: Integer para int, Double para double, Boolean para boolean o Character para char. ArrayList<int> no compilará. Con ArrayList<Integer> numbers = new ArrayList<>();, numbers.add(5) funciona porque Java empaqueta el int en un Integer. Al leerlo en int n = numbers.get(0); se desempaqueta el valor.

Sigue cada cambio de índice

String old = drinks.set(0, "coffee");
drinks.add(1, "water");
String last = drinks.get(2);

set(0, "coffee") sustituye el primer elemento y devuelve el valor anterior, por lo que old es "tea". El tamaño sigue siendo 2. Insertar "water" en el índice 1 desplaza "milk" a la derecha. La lista es ahora [coffee, water, milk]; last es "milk" y el tamaño es 3.

El índice adicional permitido para la inserción es la posición justo después del último elemento actual. En esta lista, add(3, "juice") añade al final, pero get(3) fallaría antes de esa inserción. Un índice no válido causa una IndexOutOfBoundsException. Utiliza get(size() - 1) para el último elemento, después de comprobar que la lista no está vacía.

Comienza con datos o recopila entradas

Con import java.util.List;, new ArrayList<>(List.of("red", "green", "blue")) crea una lista modificable que contiene esos valores. List.of(...) por sí solo crea una lista no modificable: add, set y remove lanzan UnsupportedOperationException. También verás List<String> names = new ArrayList<>();; la variable de tipo general List sigue admitiendo estos métodos de lista.

Para recopilar líneas hasta encontrar una vacía, utiliza un Scanner llamado scanner y una lista vacía llamada lines:

while (true) {
    String line = scanner.nextLine();
    if (line.isEmpty()) {
        break;
    }
    lines.add(line);
}

La línea que detiene el bucle se comprueba antes de añadirla, por lo que no se almacena. lines.size() cuenta las líneas almacenadas. lines.isEmpty() comprueba si no hay ninguna y lines.clear() las elimina todas cuando necesitas reutilizar la lista.

Eliminar un elemento cambia tanto el tamaño como los índices de los elementos posteriores. Una búsqueda te indica si existe un valor o dónde está ahora. Ten clara la diferencia entre un valor y su posición, especialmente en una lista de enteros.

Dos significados de remove

Para [coffee, water, milk], remove(0) devuelve "coffee" y deja [water, milk]. El antiguo índice 2 de "milk" ya no es válido; ese valor se ha desplazado al índice 1. Un índice guardado solo es útil mientras las modificaciones no hayan cambiado las posiciones que describe.

Eliminar por valor no significa eliminar todas las coincidencias. Partiendo de [a, b, a], remove("a") deja [b, a]. Una segunda llamada elimina el "a" restante. Eliminar un valor ausente devuelve false y deja la lista sin cambios, por lo que puedes utilizar el resultado directamente:

boolean removed = names.remove("Lena");
if (removed) {
    System.out.println("Name removed");
}

El problema de la sobrecarga con enteros

Un argumento int selecciona la forma por índice, incluso cuando la lista almacena enteros:

ArrayList<Integer> numbers = new ArrayList<>(List.of(10, 20, 30));
int removed = numbers.remove(1);
boolean found = numbers.remove(Integer.valueOf(10));

La primera llamada elimina el elemento del índice 1, por lo que removed es 20 y la lista pasa a ser [10, 30]. La segunda llamada proporciona explícitamente un objeto Integer. Elimina el valor 10, hace que found sea true y deja [30]. Llamar a remove(10) sobre la lista original de tres elementos intentaría acceder al índice 10 y lanzaría IndexOutOfBoundsException.

Elige un resultado de búsqueda

Para colors = [red, green, blue, green], contains("green") es true, indexOf("green") es 1 y lastIndexOf("green") es 3. contains da una respuesta de sí o no. Los dos métodos de índice dan la primera o la última posición que coincide. Un valor ausente produce false o -1, respectivamente.

Estos métodos utilizan equals para comparar elementos. El contenido de las cadenas debe coincidir exactamente, incluidas las mayúsculas y minúsculas: indexOf("Green") es -1 para esta lista. Para una búsqueda que no distinga mayúsculas de minúsculas, un bucle puede comparar cada nombre con equalsIgnoreCase.

Una coincidencia en el índice 0 sigue siendo una coincidencia. La prueba indexOf(x) > 0 la pierde. Si necesitas la posición, comprueba explícitamente el indicador de ausencia:

int index = colors.indexOf("red");
if (index != -1) {
    colors.remove(index);
}

Aquí la búsqueda devuelve 0, la comprobación se cumple y eliminar el índice 0 deja [green, blue, green]. Para evitar nombres duplicados, comprueba antes de añadir: if (!names.contains(name)) { names.add(name); }. Para eliminar todas las apariciones, puedes repetir la eliminación mientras contains sea true o utilizar un bucle seguro en orden inverso. Un bucle hacia delante que siempre incrementa después de eliminar puede omitir un elemento desplazado.

Una variable de lista contiene una referencia a un objeto. No contiene todos los elementos dentro de la propia variable. Esto explica por qué modificar una lista mediante un nombre puede afectar a otro y por qué asignar un parámetro tiene un efecto diferente al de modificar sus elementos.

Sigue las referencias

ArrayList<String> original = new ArrayList<>(List.of("tea"));
ArrayList<String> alias = original;
ArrayList<String> copy = new ArrayList<>(original);
alias.add("milk");
copy.add("juice");

original y alias apuntan a una misma lista. Después de añadir mediante alias, ambos muestran [tea, milk]. La copia es una lista independiente, creada antes de esa adición, por lo que contiene [tea, juice]. Dos nombres para un mismo objeto son alias. La asignación copia una referencia; el constructor de copia crea una lista nueva y copia los elementos en ella.

La lista copiada contiene referencias a los mismos objetos de elementos. Con cadenas y valores de clases envoltorio, esos objetos no pueden cambiar, por lo que sustituir una posición en una lista no cambia la posición de la otra. Copiar una lista basta para que ambas puedan añadir, eliminar y sustituir elementos de forma independiente.

Un método recibe una copia de la referencia

Java pasa los argumentos por valor. Para una lista, ese valor es una referencia. Quien llama al método y el parámetro apuntan inicialmente a la misma lista:

static void addBonus(ArrayList<Integer> scores, int bonus) {
    for (int i = 0; i < scores.size(); i++) {
        scores.set(i, scores.get(i) + bonus);
    }
}

Llamar a addBonus(scores, 5) sobre [70, 85] cambia la lista de quien llama a [75, 90]. El método no necesita devolver una lista porque modifica el objeto compartido. Pero asignar scores = new ArrayList<>(); dentro del método solo hace que su parámetro local apunte a otra lista. La variable de quien llama sigue apuntando a la lista anterior.

Un parámetro int recibe una copia del número. Modificar ese parámetro no puede cambiar la variable int de quien llama. En ambos casos el parámetro es local; lo que cambia es si su valor conduce a un objeto modificable compartido.

Devuelve datos nuevos cuando esa sea la tarea

static ArrayList<String> longWords(ArrayList<String> words, int minLength) {
    ArrayList<String> result = new ArrayList<>();
    for (String word : words) {
        if (word.length() >= minLength) {
            result.add(word);
        }
    }
    return result;
}

El método lee words y escribe solo en result, por lo que la entrada permanece sin cambios. Un método que modifica un argumento debe comunicar ese comportamiento, como hace addBonus. Un método que devuelve datos nuevos facilita la comprobación de la salida por separado de la entrada.

Compara el contenido y gestiona la ausencia de resultados

a == b comprueba si dos referencias de lista apuntan al mismo objeto. a.equals(b) comprueba que los tamaños sean iguales y que los elementos sean iguales en el mismo orden. Dos listas [1, 2] construidas por separado tienen el mismo contenido pero distinta identidad; [2, 1] no tiene el mismo contenido en el orden de la lista.

Una lista vacía es un objeto real de tamaño 0. Un bucle sobre ella se ejecuta cero veces, pero get(0) falla porque no hay índices de elementos. null significa que no hay ningún objeto de lista; entonces incluso size() lanza NullPointerException. Un método sin coincidencias puede devolver una lista de resultados vacía, lo que permite a quien lo llama recorrer el resultado normalmente.

Un arreglo almacena un número fijo de elementos de un mismo tipo. Eliges su longitud al crearlo. Los elementos pueden cambiar, pero el número de posiciones de ese arreglo no. Los arreglos pueden almacenar valores primitivos directamente.

Crea y llena posiciones

int[] scores = new int[5];
scores[0] = 90;
int first = scores[0];
int[] primes = {2, 3, 5, 7, 11};

new int[5] crea cinco posiciones. Sus índices son 0, 1, 2, 3 y 4. Los corchetes permiten leer y escribir una posición, por lo que first pasa a ser 90. El inicializador de primes crea y llena cinco posiciones. Cuando se necesita un arreglo con valores como expresión, por ejemplo como argumento de un método, utiliza new int[] {2, 3, 5}.

La longitud es un campo: scores.length, sin paréntesis. Cuenta todas las posiciones, incluidas las que no has asignado tú mismo. Añadir un valor a la posición 0 no cambia la longitud de 5 a 1.

Estos nombres no son intercambiables. Un arreglo no tiene método size() y una cadena necesita paréntesis después de length.

Conoce los valores iniciales

Las posiciones de un arreglo nuevo reciben valores predeterminados. Los arreglos de números primitivos comienzan con cero: 0 para int, 0,0 para double. Un boolean[] comienza con false; un char[] comienza con el carácter cuyo código es cero, escrito '\u0000'. Los arreglos de tipos de clase, incluido String[], comienzan con referencias null.

String[] words = new String[3];
words[0] = "sun";
System.out.println(words[0].length());

Esto imprime 3 porque la posición 0 ahora hace referencia a "sun". Las posiciones 1 y 2 siguen conteniendo null. Llamar a words[1].length() lanza NullPointerException: todavía no hay ninguna cadena ahí. Una posición con el valor predeterminado null es diferente de una cadena vacía "", que es un objeto de longitud 0.

Interpreta la salida y mantente dentro del arreglo

Importa java.util.Arrays y utiliza System.out.println(Arrays.toString(scores)); para imprimir [90, 0, 0, 0, 0]. Imprimir scores directamente muestra un código de tipo e identidad como [I@1b6d3586, no sus elementos. El código de identidad no es una representación útil de los números almacenados.

Para una semana de temperaturas en grados Celsius:

double[] temps = {12.5, 14.0, 9.5, 11.0, 15.5, 13.0, 10.5};
temps[2] = 10.0;

La lectura del tercer día cambia de 9,5 a 10,0. La primera lectura es temps[0]; la última es temps[6] o temps[temps.length - 1]. temps[7] está fuera del arreglo. Java lanza ArrayIndexOutOfBoundsException para un índice de arreglo no válido. En un bucle con índice, utiliza i < temps.length: i <= temps.length intenta acceder a una posición adicional después de la última válida. Un arreglo de longitud cero no tiene ningún índice de elemento válido.

Una variable de arreglo contiene una referencia, igual que una variable de lista. Asignar esa referencia crea otro nombre para el mismo arreglo. Una copia independiente necesita un objeto de arreglo nuevo y comparar el contenido necesita un método que compruebe las posiciones.

Asignación y copia

int[] a = {4, 9, 2};
int[] alias = a;
int[] copy = Arrays.copyOf(a, a.length);
alias[0] = 99;

Ahora a y alias muestran [99, 9, 2]; copy sigue mostrando [4, 9, 2]. Arrays.copyOf(a, a.length) crea un arreglo nuevo de la misma longitud. a.clone() también puede copiarlo. Importa java.util.Arrays para utilizar los métodos de utilidad.

Una longitud solicitada diferente cambia el arreglo nuevo, no el anterior. Arrays.copyOf(new int[] {2, 3, 5}, 4) produce [2, 3, 5, 0]. Las posiciones adicionales reciben valores predeterminados. Para que una variable haga referencia a un arreglo más grande, asigna a esa variable la copia devuelta. Cualquier alias del original sigue haciendo referencia al arreglo anterior.

Las llamadas a métodos comparten el objeto

static void doubleAll(int[] values) {
    for (int i = 0; i < values.length; i++) {
        values[i] = values[i] * 2;
    }
}

El parámetro recibe una copia de la referencia. Por tanto, el método modifica las posiciones del arreglo de quien lo llama. Reasignar values a un arreglo nuevo solo cambiaría el parámetro. En su lugar, un método puede devolver un arreglo nuevo: return new int[] {values[0], values[values.length - 1]}; produce [4, 2] para la entrada {4, 9, 2}. Esa expresión necesita una entrada no vacía porque lee dos índices.

La igualdad de contenido es diferente para los arreglos

Para los arreglos a = {1, 2} y b = {1, 2} creados por separado, tanto a == b como a.equals(b) son false: equals de un arreglo comprueba la identidad. Arrays.equals(a, b) es true porque los elementos correspondientes coinciden. Esto difiere de ArrayList, cuyo equals compara el contenido ordenado.

Guarda un valor antes de sobrescribirlo

Para intercambiar dos posiciones, conserva un valor anterior en una variable temporal:

int temp = a[0];
a[0] = a[2];
a[2] = temp;

Partiendo de {4, 9, 2}, la primera línea guarda 4. La segunda produce [2, 9, 2]. La tercera restablece el 4 guardado en el índice 2 y completa [2, 9, 4]. Sin temp, asignar a[2] = a[0] después de la segunda línea copiaría de nuevo el 2 y perdería el 4 original.

Elige una estructura adecuada para los datos

Los arreglos también aparecen en main(String[] args) y como resultado de String.split. Para un String[] words, new ArrayList<>(Arrays.asList(words)) crea una lista que puede crecer. Para un int[], crea un ArrayList<Integer> y añade cada entero en un bucle. Arrays.asList aplicado al arreglo primitivo trata el arreglo completo como un solo elemento, por lo que no crea una lista de sus números individuales.

Un bucle permite que una parte del código procese cada elemento. La elección depende de lo que necesite el cuerpo: solo un valor, su posición o una forma de escribir de nuevo en la colección. Tanto los arreglos como los ArrayLists admiten bucles con índice y bucles for-each.

Visita los valores en orden

for (String task : tasks) {
    System.out.println(task);
}

Léelo como «para cada tarea en tasks». Con [shop, cook, clean], imprime las tres cadenas en ese orden. La variable de bucle tiene el tipo de elemento. Para ArrayList<Integer>, utiliza int para desempaquetar cada valor o Integer para conservar la referencia al envoltorio. Para los caracteres de una cadena, for (char c : word.toCharArray()) visita los valores char.

Un bucle for-each no proporciona un índice. Si necesitas líneas numeradas, utiliza un bucle con índice:

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

El índice comienza en 0, pero el número de línea mostrado comienza en 1. Los paréntesis hacen que i + 1 sea una suma antes de convertirse en parte del texto. Para un arreglo, cambia la condición a i < tasks.length y lee tasks[i]. Un bucle while puede hacer lo mismo inicializando un contador antes del bucle e incrementándolo en el cuerpo.

Escribe mediante una posición

int[] nums = {4, 9, 2};
for (int n : nums) {
    n = n * 2;
}

Esto deja el arreglo sin cambios. Cada pasada coloca una copia de un valor primitivo en n; asignar un valor a esa variable local no escribe en la posición original. Para modificar el arreglo:

for (int i = 0; i < nums.length; i++) {
    nums[i] = nums[i] * 2;
}

El resultado es [8, 18, 4]. Para una lista de enteros, la actualización correspondiente es list.set(i, list.get(i) * 2). El índice indica a Java qué elemento almacenado debe sustituir.

Ajusta los límites al cuerpo

Para recorrer una lista en orden inverso, comienza en tasks.size() - 1, continúa mientras i >= 0 y utiliza i--. Esto visita clean, cook y después shop. Para tomar un elemento de cada dos se puede utilizar i += 2 en un bucle hacia delante.

Las comparaciones con el elemento siguiente necesitan un rango más corto. Si el cuerpo lee tanto list.get(i) como list.get(i + 1), la condición es i < list.size() - 1. La última posición inicial válida es el penúltimo elemento. Usar la condición habitual para recorrer todo intentaría leer un elemento siguiente inexistente después del último elemento.

Al procesar juntas dos listas de la misma longitud, utiliza un índice para acceder a ambas. Por ejemplo, names.get(i) y scores.get(i) describen las entradas correspondientes. Un bucle for-each es más sencillo cuando la posición no importa, como al imprimir cada nombre o añadir cada valor a un total.

Comenzar en 1 omite el primer elemento sin aviso. Usar <= size() o <= length intenta acceder a un índice adicional no válido. Una lista o un arreglo vacío no necesita una regla especial de recorrido: la condición inicial es falsa, por lo que el cuerpo se ejecuta cero veces. Cualquier código posterior que divida por el recuento o lea un elemento debe gestionar por sí mismo ese caso vacío.

Un acumulador conserva un resultado construido a lo largo de las pasadas de un bucle. Inicialízalo antes del bucle, actualízalo dentro y utilízalo después. El valor inicial depende de la tarea: una suma o un recuento comienza en 0, mientras que un máximo necesita un elemento real.

Totales y medias

int sum = 0;
for (int value : numbers) {
    sum += value;
}
if (!numbers.isEmpty()) {
    double average = (double) sum / numbers.size();
    System.out.println(average);
}

Para [4, 7, 8], sum cambia de 0 a 4, después a 11 y luego a 19. Ambos operandos de sum / numbers.size() serían enteros, lo que daría 6. Convertir sum antes de la división da aproximadamente 6,33. Convertir el cociente ya calculado solo transformaría el 6 truncado en 6,0.

Una colección vacía no tiene una media ordinaria. La división entera por cero lanza ArithmeticException; la división en coma flotante 0.0 / 0 da NaN. Decide qué significa el caso vacío para el programa antes de dividir, por ejemplo mostrar «No hay mediciones». Para las distancias decimales [5.0, 7.5, 10.0] km, un total double es 22,5 km y la media es 7,5 km.

Cuenta solo las coincidencias

Un recuento condicional comienza en 0 y se incrementa solo cuando se cumple su condición. Para las temperaturas {22, 27, 31, 24, 26} en grados Celsius, if (t > 25) { count++; } produce 3. Coloca la inicialización fuera del bucle; restablecer count en cada pasada descartaría las coincidencias anteriores.

Encuentra un valor extremo y su posición

Para un arreglo no vacío, comienza con int max = values[0];. Sustituye max cada vez que un valor visitado sea mayor. Comenzar en 0 falla con {-5, -2, -9}: indica 0 aunque ningún elemento tenga ese valor. Comenzar con -5 permite que el bucle llegue al máximo correcto, -2. Un mínimo utiliza el mismo patrón con <.

Cuando la posición importe, conserva el mejor índice:

int best = 0;
for (int i = 1; i < numbers.size(); i++) {
    if (numbers.get(i) > numbers.get(best)) {
        best = i;
    }
}

Para [4, 7, 8], best termina en 2 y numbers.get(best) es 8. El bucle comienza en 1 porque el índice 0 ya es el candidato inicial. Con >, un valor igual no sustituye al candidato actual, lo que conserva el primer máximo. Con >=, cada empate lo sustituye y conserva el último máximo. Comprueba si la colección está vacía antes de crear un candidato en el índice 0.

Recopila los valores que coinciden

El filtrado utiliza una lista de resultados vacía como acumulador. Visita cada palabra, añádela cuando word.length() > 4 y devuelve el resultado. Para [sun, planet, moon, galaxy], el resultado es [planet, galaxy]. Leer la entrada y añadir a una lista independiente deja la entrada sin cambios.

Para dos elementos Integer, == compara la identidad de los objetos. Los valores pequeños almacenados en caché pueden ocultar este error; valores mayores iguales pueden ser objetos distintos. Compara con equals o desempaqueta primero en variables int. Los operadores numéricos <, >, <= y >= desempaquetan los valores envoltorio, por lo que el código del mejor índice compara sus números.

Una búsqueda lineal comprueba los elementos en secuencia. Funciona con datos en cualquier orden. Una búsqueda de la primera coincidencia que tiene éxito puede detenerse antes; una búsqueda sin éxito debe llegar al final antes de saber que ningún elemento coincide.

Devuelve el primer índice que coincide

static int indexOfName(ArrayList<String> names, String target) {
    for (int i = 0; i < names.size(); i++) {
        if (names.get(i).equals(target)) {
            return i;
        }
    }
    return -1;
}

Si el primer nombre que coincide está en el índice 2, el método comprueba los índices 0, 1 y 2, y después devuelve 2 inmediatamente. El return -1 está después del bucle porque solo un recorrido completo establece que no se ha encontrado. Poner else { return -1; } dentro haría que se detuviera en el primer elemento que no coincide e ignorara todos los candidatos posteriores.

El indicador de ausencia -1 no puede ser un índice válido. Quien llama al método debe comprobarlo antes de leer el resultado:

int index = indexOfName(names, "Ahmed");
if (index != -1) {
    System.out.println(names.get(index));
}

La prueba index > 0 pasaría por alto una coincidencia válida en el índice 0. Usar -1 directamente en get lanzaría una excepción. En una lista vacía el cuerpo del bucle nunca se ejecuta y el método devuelve correctamente -1.

Cambia la comparación según la tarea

Para valores exactos de una lista, contains e indexOf ya realizan una búsqueda lineal. Escribe un bucle para un arreglo o una condición como «empieza por L». Utiliza equals o equalsIgnoreCase para cadenas, == para primitivos y equals para dos objetos Integer. Una comprobación de identidad de cadenas puede pasar por alto texto igual.

Para String[] cities = {"Oslo", "Lima", "Lagos", "Pune"}, comprueba cities[i].startsWith("L"). El índice 0 no cumple la condición; el índice 1 sí, por lo que el resultado de la primera coincidencia es 1. Si la tarea pide todas las coincidencias, no retornes ahí. Añade los índices que coincidan a una lista de resultados y termina el recorrido; eso da [1, 2]. Para contar coincidencias, incrementa un contador en lugar de almacenar posiciones.

Elige la forma de la respuesta

Una búsqueda de sí o no puede comenzar con boolean found = false;. Ante una coincidencia, asígnale true y sal del bucle con break. Sin break, la respuesta final sigue siendo true, pero el programa comprueba valores que ya no necesita. Un método de búsqueda también puede devolver true inmediatamente y devolver false después del bucle.

Devolver un elemento requiere un resultado distinto para «no se encontró nada». Para una String, a menudo es null; quien llama debe comprobarlo antes de llamar a un método de String. Devolver un índice con -1 hace visible el caso de ausencia sin afirmar que una cadena vacía es un dato ausente.

Cuenta el trabajo que realmente hace la búsqueda

Un valor buscado en la primera posición requiere una comparación. Un valor en la tercera posición requiere tres. Un valor ausente entre 10 000 nombres requiere las 10 000 comparaciones. La primera comparación fallida no puede establecer que el valor buscado no esté en las posiciones restantes. Una búsqueda de todas las coincidencias también comprueba cada elemento, incluso después de una coincidencia temprana, porque los valores posteriores también pueden coincidir.

Eliminar elementos de un ArrayList cambia las posiciones que un bucle intenta visitar. El patrón seguro depende de si necesitas modificar la lista original o construir un resultado independiente. Sustituir valores es más sencillo porque mantiene las posiciones en su sitio.

Observa cómo un bucle hacia delante omite un valor

Supón que un bucle elimina los números pares de [3, 8, 8, 5] y siempre incrementa i. En el índice 1 elimina el primer 8. El segundo 8 se desplaza al índice 1, pero la siguiente pasada utiliza el índice 2. El resultado es [3, 8, 5], con un número par restante. La condición era correcta; el desplazamiento tras la eliminación causó el problema.

Un bucle for-each sobre un ArrayList tampoco debe añadir ni eliminar elementos a través de la lista. Utiliza un iterador cuyo estado de recorrido deja de coincidir con la lista modificada. Java normalmente informa de una ConcurrentModificationException. Algunas modificaciones pueden terminar el bucle sin aviso y dejar un elemento sin visitar. La ausencia de una excepción no hace que esa modificación sea segura.

Elimina en orden inverso para mantener estables las posiciones no comprobadas

for (int i = numbers.size() - 1; i >= 0; i--) {
    if (numbers.get(i) % 2 == 0) {
        numbers.remove(i);
    }
}

Para [3, 8, 8, 5], el índice 3 contiene 5 y se conserva. El índice 2 contiene 8 y se elimina. El índice 1 sigue conteniendo el otro 8 y se elimina a continuación. El índice 0 contiene 3 y se conserva. El resultado es [3, 5]. Una eliminación desplaza los elementos a la derecha del índice actual, que este bucle en orden inverso ya ha comprobado.

Construye la lista de valores que se conservarán

Cuando la lista original deba permanecer sin cambios, crea una lista nueva:

ArrayList<Integer> odds = new ArrayList<>();
for (int value : numbers) {
    if (value % 2 != 0) {
        odds.add(value);
    }
}

Este bucle for-each es seguro porque lee numbers y añade a una lista diferente. Con [3, 8, 8, 5] como entrada, odds contiene [3, 5] y la entrada sigue conteniendo los cuatro valores. Un arreglo tampoco puede reducirse; filtrar sus valores también requiere un arreglo o una lista nuevos.

Deja que un iterador gestione su propia eliminación

Iterator<Integer> it = numbers.iterator();
while (it.hasNext()) {
    if (it.next() % 2 == 0) {
        it.remove();
    }
}

Importa java.util.Iterator. next() proporciona el siguiente elemento e it.remove() elimina el elemento recién devuelto mientras mantiene coherente la posición del iterador. No sustituyas esa llamada por numbers.remove(...) en este bucle.

Un bucle while hacia delante también puede funcionar si incrementa solo cuando no se ha eliminado nada. Después de una eliminación debe volver a inspeccionar el mismo índice, al que ha llegado el siguiente elemento. Esto requiere más cuidado que un bucle en orden inverso o una lista de resultados nueva.

Las sustituciones y las adiciones tienen efectos diferentes

set(i, value) es seguro en un bucle con índice porque no cambia el tamaño ni las posiciones. Añadir en cada pasada mientras se comprueba i < list.size() puede alejar continuamente el final y hacer que el bucle no termine. Guarda int originalSize = list.size(); y recorre solo hasta ese límite cuando cada elemento original deba causar la adición de un valor al final.

Una String almacena texto como una secuencia de valores char. Los índices comienzan en 0, igual que en arreglos y listas. Un objeto String no puede cambiar después de crearse, por lo que los métodos que producen texto modificado devuelven un resultado que debes conservar.

Un carácter es diferente de una cadena

"Hello".length() es 5. "Hello".charAt(0) es 'H' y charAt(4) es 'o'. Un char utiliza comillas simples y contiene una unidad de código UTF-16; una String utiliza comillas dobles y puede contener cero, una o muchas de esas unidades. "Java".charAt(0) == 'J' compara dos caracteres primitivos. Comparar ese char con "J" no compila porque los tipos son diferentes.

charAt(length()) queda fuera del final y lanza StringIndexOutOfBoundsException. Incluso charAt(0) falla para "". Comprueba isEmpty() antes de leer el primer carácter de la entrada.

length() cuenta valores char de UTF-16, que no siempre son símbolos completos visibles. "café".length() es 4; "Hi 👋".length() es 5 porque el emoji de la mano que saluda ocupa dos posiciones char. Utiliza ese recuento al razonar sobre los índices de estos métodos.

Visita y comprueba los caracteres

String text = "Programming in Java".toLowerCase();
int vowels = 0;
for (int i = 0; i < text.length(); i++) {
    char c = text.charAt(i);
    if ("aeiou".indexOf(c) >= 0) {
        vowels++;
    }
}

La conversión a minúsculas permite que la misma comprobación de pertenencia reconozca vocales mayúsculas y minúsculas. Cada indexOf(c) es no negativo cuando el carácter aparece en "aeiou". El recuento llega a 6: o, a, i, i, a, a. for (char c : text.toCharArray()) puede visitar los mismos valores sin un índice.

La clase Character proporciona comprobaciones como isLetter, isDigit, isWhitespace e isUpperCase. Character.isDigit('7') es true, mientras que Character.isLetter('7') es false. Character.toUpperCase(c) y toLowerCase(c) devuelven valores char convertidos.

Los caracteres también tienen códigos numéricos. 'a' + 1 produce el int 98; (char) ('a' + 1) convierte ese código en 'b'. Para un carácter de dígito ASCII, restar '0' da su valor: '7' - '0' es 7. Restar el código de cero funciona porque esos códigos de dígitos son consecutivos.

Lee la concatenación de izquierda a derecha

Una vez que el lado izquierdo de + es texto, el siguiente número se une como texto. Los paréntesis obligan a realizar la suma numérica antes de unir. Unas pocas uniones en una expresión son un uso claro de +.

Guarda el texto devuelto

String name = "Lena";
name.toUpperCase();
System.out.println(name);
name = name.toUpperCase();

La impresión sigue mostrando "Lena": la llamada cuyo resultado se descartó no modificó su objeto. La asignación hace después que name haga referencia a "LENA". La inmutabilidad de String significa que el texto anterior permanece sin cambios aunque otras variables hagan referencia a él. Conservar el resultado y modificar el objeto original son operaciones diferentes.

El procesamiento de texto suele seguir una secuencia breve: encontrar un marcador, comprobar que existe y extraer la parte que necesitas. Las operaciones de limpieza pueden preparar el texto antes de una búsqueda o comparación. Cada operación de String devuelve un resultado sin modificar su objeto original.

Encuentra posiciones o plantea una pregunta de sí o no

Para "banana", indexOf('a') devuelve 1, indexOf("a", 2) devuelve 3 y lastIndexOf('a') devuelve 5. El segundo argumento elige dónde comienza la búsqueda hacia delante. Una búsqueda sin coincidencias da -1, como en indexOf("x").

Utiliza contains(text) cuando solo necesites saber si aparece un texto. startsWith(prefix) comprueba el principio y endsWith(suffix) el final. "report.pdf".endsWith(".pdf") es true. Estas búsquedas distinguen mayúsculas de minúsculas: "Hello".contains("hello") es false. Los métodos de índice aceptan un char o una String; contains recibe texto.

Substring termina justo antes de su índice final

String word = "programming";
String middle = word.substring(3, 7);
String tail = word.substring(3);

middle es "gram" y utiliza las posiciones 3, 4, 5 y 6. Su longitud es 7 - 3, es decir, 4. tail es "gramming", porque omitir el argumento final hace que llegue hasta el final de la cadena. El comienzo debe ser no negativo y no mayor que el final; el final no puede superar length(). Los límites no válidos lanzan StringIndexOutOfBoundsException.

Para una dirección de correo electrónico, encuentra el separador antes de extraer:

String email = "lena.ito@example.com";
int at = email.indexOf("@");
if (at != -1) {
    String user = email.substring(0, at);
    String domain = email.substring(at + 1);
}

El separador está en el índice 8. La primera parte termina antes de él y da "lena.ito"; la segunda comienza después y da "example.com". Si el marcador no aparece, at es -1. Llamar a substring(0, at) sin la comprobación fallaría. Comenzar la segunda parte en at conservaría la @ en el dominio.

Limpia solo lo que afecta a la operación

" hello ".trim() da "hello"; los espacios interiores permanecen. strip() gestiona caracteres adicionales de espacio en blanco de Unicode, como el espacio em. Utiliza la definición de espacio en blanco de Java, que no incluye todos los caracteres que parecen un espacio. "banana".replace('a', 'o') da "bonono". "ab".repeat(3) da "ababab".

Una cadena vacía y una cadena en blanco son diferentes

isEmpty() comprueba que la longitud sea 0. isBlank() también acepta texto formado solo por caracteres de espacio en blanco de Java. Para " ", el primero es false y el segundo true. Utiliza la comprobación que corresponda a la regla de entrada. Para limpiar una respuesta como " Yes ", answer.trim().toLowerCase() devuelve "yes". Almacena ese texto devuelto si la variable debe conservar el valor limpio; una llamada aislada answer.trim(); lo descarta.

Una línea de datos puede contener varios valores separados por una coma u otro marcador. La división produce un arreglo de cadenas; después, el análisis sintáctico convierte los campos seleccionados en números. Comprueba la estructura de los datos antes de usar sus posiciones.

Divide en un arreglo

String[] fields = "Ada,36,London".split(",");

Hay tres campos: "Ada", "36" y "London". Las comas no se conservan. fields.length es 3 y fields[1] sigue siendo texto, no un número.

El separador que se pasa a split es una expresión regular, un patrón que no siempre es texto literal. Una coma se representa a sí misma, pero ., |, *, + y ? tienen significados especiales. Para dividir una cadena de versión por puntos literales, utiliza "1.5.2".split("\\."). Dos barras invertidas en la cadena Java producen la única barra invertida del patrón que hace que el punto sea literal. En cambio, split(".") coincide con caracteres individuales y produce un arreglo vacío en este ejemplo.

Gestiona espacios y partes vacías

Dividir "a b" por " " produce tres partes: "a", "" y "b". Cada separador es un espacio, por lo que los espacios contiguos dejan una parte vacía entre ellos. Para secuencias de espacios en blanco, utiliza:

String[] words = "  red   green blue ".trim().split("\\s+");

El resultado es [red, green, blue]. Eliminar primero los espacios de los extremos evita una parte inicial vacía causada por un separador al principio. Por defecto, split descarta las partes vacías finales: "a,b,,".split(",") produce solo "a" y "b". Cuenta los campos resultantes reales antes de acceder a ellos mediante índices.

Convierte cada campo a su tipo previsto

Integer.parseInt("42") devuelve el int primitivo 42. Integer.valueOf("-7") devuelve un objeto Integer. Double.parseDouble("5.2") devuelve 5,2 y utiliza un punto como separador decimal independientemente de la configuración regional del equipo. El análisis de enteros acepta texto de enteros sin separador decimal. Integer.parseInt("4.5") falla en lugar de redondear.

Elimina los espacios de los extremos de los campos antes de convertirlos, especialmente en el texto de enteros: Integer.parseInt(" 42") lanza NumberFormatException. Dividir por comas no elimina los espacios alrededor de los campos. Un número correcto de campos tampoco garantiza que un campo contenga un número válido.

Lee un registro completo

String line = "Amira,10.5,63";
String[] parts = line.split(",");
if (parts.length == 3) {
    String name = parts[0].trim();
    double distanceKm = Double.parseDouble(parts[1].trim());
    int minutes = Integer.parseInt(parts[2].trim());
    double pace = minutes / distanceKm;
    System.out.println(name + ": " + pace + " min/km");
}

La distancia es 10,5 km, el tiempo es 63 minutos y el ritmo es 6,0 min/km. La línea incompleta "Amira,10.5" tiene solo dos campos; sin la comprobación del número de campos, parts[2] lanzaría ArrayIndexOutOfBoundsException. Un programa puede omitir o comunicar ese registro incompleto antes de utilizar cualquier posición ausente.

Convierte o une de nuevo el texto

String.valueOf(42) e Integer.toString(42) dan "42". String.join(", ", List.of("Oslo", "Lima", "Pune")) da "Oslo, Lima, Pune" e inserta separadores solo entre las partes. Acepta una lista, un arreglo o argumentos de cadena separados. La unión no analiza ni calcula: combina las cadenas proporcionadas.

Dos variables pueden contener texto con los mismos caracteres sin hacer referencia al mismo objeto String. Elige una comparación según la pregunta: contenido igual, contenido igual sin distinguir mayúsculas de minúsculas o qué texto va primero en el orden de Java.

Utiliza equals para el contenido

String answer = new String("yes");
System.out.println(answer == "yes");
System.out.println(answer.equals("yes"));

El primer resultado es false: el objeto creado por separado no es el objeto del literal. El segundo es true porque los caracteres coinciden. Los literales idénticos como "yes" == "yes" comparten un objeto y pueden hacer que la comparación de identidad parezca fiable. El texto obtenido durante la ejecución puede utilizar objetos nuevos o existentes, por lo que la identidad no es la prueba adecuada para comprobar si una entrada coincide.

equalsIgnoreCase ignora las mayúsculas y minúsculas: "YES".equalsIgnoreCase("yes") es true. No elimina espacios. Para aceptar también espacios alrededor, limpia la entrada antes de comparar.

Para una variable que podría ser null, llama al método desde un literal conocido que no sea null: "yes".equals(answer) devuelve false para null. answer.equals("yes") lanza NullPointerException si answer es null, porque ningún objeto recibe la llamada.

Un bucle de comandos puede comprobar !command.equals("quit"). El ! niega la igualdad de contenido. command != "quit" comprueba referencias y puede mantener un bucle en ejecución incluso cuando los caracteres escritos dicen «quit».

Interpreta el signo de compareTo

a.compareTo(b) compara valores char de UTF-16 en secuencia. Devuelve un número negativo si a va antes que b, cero si son iguales y un número positivo si va después. Solo el signo importa para ordenar; el resultado no tiene que ser exactamente -1 o 1.

Por tanto, los números almacenados como texto no siguen el orden numérico. Conviértelos cuando la tarea sea numérica. Las letras mayúsculas inglesas sin tilde preceden a las minúsculas sin tilde, por lo que "Zebra" va antes que "apple". "Émile", con tilde, va después de "Zoe" en este orden. compareToIgnoreCase ignora las mayúsculas y minúsculas; el orden de diccionario específico de un idioma necesita java.text.Collator.

Reutiliza el patrón del mínimo para nombres

Para una lista no vacía [Mia, Ahmed, Lucia]:

String first = names.get(0);
for (String name : names) {
    if (name.compareTo(first) < 0) {
        first = name;
    }
}

"Mia" comienza como candidata. "Ahmed" va antes en la comparación y pasa a ser el candidato; "Lucia" no lo sustituye. El resultado es "Ahmed". Comprueba si la lista está vacía antes de leer su primer elemento.

Un char individual es un primitivo, por lo que word.charAt(0) == 'A' es una comparación correcta de caracteres una vez que se sabe que la palabra no está vacía. El problema con == afecta a la identidad de los objetos, no a todas las comparaciones que incluyen texto.

Un StringBuilder contiene texto modificable. Es útil cuando un bucle añade muchas partes o cuando es necesario modificar caracteres in situ. Unas pocas uniones en una expresión son claras con +, pero reconstruir repetidamente una String que crece puede copiar su contenido acumulado muchas veces.

Añade partes y termina con una String

StringBuilder sb = new StringBuilder();
for (int i = 1; i <= 5; i++) {
    if (i > 1) {
        sb.append(", ");
    }
    sb.append(i);
}
String result = sb.toString();

No se necesita ninguna importación. append añade cadenas, chars, números o booleanos al final. La primera pasada añade solo 1; la segunda añade ", " y después 2. El resultado es "1, 2, 3, 4, 5". Poner un separador después de cada número dejaría un separador no deseado al final. Para una lista de cadenas existente, String.join(", ", list) gestiona directamente los separadores.

Repetir text += piece en un bucle forma resultados String inmutables nuevos. El prefijo acumulado debe incluirse cada vez, por lo que la cantidad copiada puede crecer de forma cuadrática a medida que crece un resultado largo. Un constructor mantiene un búfer modificable y añade contenido sin reconstruir todo el prefijo en cada pasada.

Modifica posiciones y rangos

length() y charAt(i) leen el constructor como lo hacen con una String. Los índices describen su estado actual; una inserción o eliminación puede cambiar las posiciones posteriores.

Comienza con new StringBuilder("Jva"). insert(1, 'a') produce "Java"; después setCharAt(0, 'j') da "java". Para "2026-10-22", delete(4, 7) elimina las posiciones 4, 5 y 6, y deja "2026-22". Sustituir las posiciones de 7 a 9 en "I like tea" por "coffee" da "I like coffee".

Encadena solo los métodos que devuelven el constructor

new StringBuilder().append("a").append(1).append('b').toString() da "a1b". Las llamadas a append devuelven el mismo constructor, lo que permite otra llamada. Los métodos de modificación presentados aquí también devuelven el constructor, salvo setCharAt, que devuelve void y necesita una sentencia separada.

reverse() modifica el objeto receptor. Si sb contiene "stressed", entonces String r = sb.reverse().toString(); deja tanto r como el texto del constructor como "desserts". Para conservar el constructor original, invierte uno nuevo creado a partir de su texto.

Compara el contenido final

Para comprobar un palíndromo, añade la forma en minúscula de cada letra de "Was it a car or a cat I saw". El texto limpio es "wasitacaroracatisaw". Invierte un constructor nuevo que contenga ese texto, conviértelo en una String y compara con clean.equals(reversed). La comparación es true.

StringBuilder no sobrescribe equals para comparar contenido. Los constructores separados que contienen "abc" no son iguales según ese método y un constructor no es igual a una String. Convierte primero: sb1.toString().equals(sb2.toString()) compara el texto real.