Cadenas en Java: crear, concatenar y usar métodos de String

Qué es una cadena (String)

Un String contiene una secuencia de caracteres: texto como un nombre, una frase o una línea leída de un archivo. Viste String listado entre los tipos por referencia en la página anterior; aquí trabajarás de verdad con uno. Escribes un literal de cadena con comillas dobles (las comillas simples están reservadas para un único char):

public class Main {
    public static void main(String[] args) {
        String greeting = "Hello, world";
        String empty = "";
        String name = "Ada";

        System.out.println(greeting);
        System.out.println("Name has " + name.length() + " characters");
    }
}

name.length() devuelve la cantidad de caracteres: 3 para "Ada". Es una llamada a un método, así que necesita los paréntesis.

Unir cadenas

El operador + pega cadenas entre sí. Si cualquiera de los lados de + es una cadena, el otro lado se convierte a texto automáticamente, así que puedes mezclar números y booleanos sin ningún trabajo extra:

public class Main {
    public static void main(String[] args) {
        String first = "Ada";
        String last = "Lovelace";

        String full = first + " " + last;
        System.out.println(full);

        int age = 36;
        System.out.println(full + " is " + age + " years old");
    }
}

Un detalle a tener en cuenta: como + se evalúa de izquierda a derecha, "" + 1 + 2 produce "12" (cadena + int, luego cadena + int), pero 1 + 2 + "" produce "3" (los dos enteros se suman primero y luego se convierten en texto). Cuando tengas dudas, encierra la aritmética entre paréntesis.

Las cadenas son inmutables

Esto es lo más importante que hay que entender sobre las cadenas en Java: un String nunca cambia después de creado. Cada método que "modifica" una cadena en realidad devuelve una cadena completamente nueva y deja la original intacta. Así que si olvidas capturar el valor de retorno, no ocurre nada:

public class Main {
    public static void main(String[] args) {
        String s = "hello";

        s.toUpperCase();              // resultado descartado - ¡error!
        System.out.println(s);        // sigue siendo "hello"

        s = s.toUpperCase();          // captura la nueva cadena
        System.out.println(s);        // ahora "HELLO"
    }
}

La primera llamada calcula "HELLO" y lo descarta de inmediato. Solo la segunda línea, que asigna de vuelta a s, tiene algún efecto visible. Esto le pasa a casi todo el mundo alguna vez.

Comparar cadenas

Usa .equals() para comparar el contenido de dos cadenas. Recurrir a == es el error clásico de principiante: == pregunta "¿son el mismo objeto en memoria?", no "¿contienen el mismo texto?":

public class Main {
    public static void main(String[] args) {
        String a = "code";
        String b = new String("code");

        System.out.println(a == b);            // false - different objects
        System.out.println(a.equals(b));       // true  - same characters

        System.out.println("Hi".equalsIgnoreCase("hi"));  // true
    }
}

a == b es false aquí porque new String(...) fuerza la creación de un objeto separado. Compara siempre los valores de las cadenas con .equals() (o .equalsIgnoreCase() para ignorar las mayúsculas y minúsculas). Un truco útil para evitar un fallo cuando un lado podría ser null es llamar a .equals sobre el literal: "yes".equals(input) nunca lanza una excepción aunque input sea null.

Métodos de String del día a día

Como las cadenas son inmutables, cada uno de estos devuelve una nueva cadena (o un valor) en lugar de modificar la original. Estos son los que usarás constantemente:

public class Main {
    public static void main(String[] args) {
        String s = "  Coddy Java  ";

        System.out.println(s.trim());              // "Coddy Java"
        System.out.println(s.trim().toUpperCase()); // "CODDY JAVA"
        System.out.println(s.contains("Java"));    // true
        System.out.println(s.indexOf("Java"));     // 8
        System.out.println("Coddy".charAt(0));     // 'C'
        System.out.println("a,b,c".split(",").length); // 3
        System.out.println("hello".replace("l", "L")); // "heLLo"
    }
}

Fíjate en el encadenamiento: s.trim().toUpperCase() funciona porque trim() devuelve una cadena, sobre la que luego llamas a toUpperCase(). substring es otro caballo de batalla: recibe un índice de inicio (inclusivo) y un índice de fin opcional (exclusivo):

public class Main {
    public static void main(String[] args) {
        String date = "2026-06-04";

        System.out.println(date.substring(0, 4));  // "2026"
        System.out.println(date.substring(5));     // "06-04"
    }
}

Los índices empiezan en cero, así que substring(0, 4) toma los caracteres del 0 al 3. Pedir un índice más allá del final lanza una StringIndexOutOfBoundsException.

Construir cadenas en un bucle

Concatenar con + está bien para unas pocas piezas, pero hacerlo dentro de un bucle grande es lento: cada + crea una nueva cadena y lo copia todo. Cuando ensambles texto en un bucle, usa StringBuilder, que muta un búfer en su lugar y produce la cadena final una sola vez al terminar:

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= 5; i++) {
            sb.append(i).append(" ");
        }
        String result = sb.toString().trim();
        System.out.println(result);   // "1 2 3 4 5"
    }
}

append devuelve el mismo builder, de modo que las llamadas se encadenan. Llama a .toString() para obtener un String normal al final. Para uniones puntuales, quédate con +; para acumular muchas piezas, StringBuilder es la herramienta adecuada.

Siguiente: Formato de cadenas

La concatenación se vuelve un lío en cuanto necesitas columnas alineadas, decimales fijos o números con relleno. String.format y printf de Java usan una plantilla con marcadores % para manejar todo eso de forma limpia: ese es el tema de la siguiente página.