Strings en Java

Un String representa una secuencia de caracteres y es, después de int, el tipo que más utilizarás. Es una clase (no un primitivo), pero Java le otorga una sintaxis especial — literales entre comillas dobles, el operador + para la concatenación — por lo que se siente casi como un primitivo al usarlo. El hecho más importante sobre los strings: son inmutables.

Este capítulo cubre cómo crear strings, por qué importa la inmutabilidad, cómo medir e indexar en ellos, cómo compararlos correctamente, los métodos más usados, la concatenación, los bloques de texto multilínea y el formateo.

Crear un string

La forma más sencilla es usar un literal de string entre comillas dobles:

String greeting = "Hello, World!";
String empty = "";
String multi = "Line 1\nLine 2";   // \n is a newline

También puedes construir uno con new, aunque rara vez hay razón para hacerlo:

String fromLiteral = "Hello";
String fromNew = new String("Hello");

new String(...) siempre asigna un objeto nuevo. Los literales se almacenan en un pool — dos literales con los mismos caracteres son el mismo objeto. Esto importa para las comparaciones con ==, pero no mucho más; de todos modos siempre debes usar .equals() para comparar contenidos.

Los strings son inmutables

Una vez que se crea un String, su contenido nunca cambia. Cada método que "modifica" un string en realidad devuelve un nuevo string:

String s = "hello";
s.toUpperCase();
System.out.println(s);   // "hello" — unchanged

s = s.toUpperCase();
System.out.println(s);   // "HELLO" — new string assigned

La inmutabilidad tiene varios beneficios:

• Es seguro compartirlos entre hilos — no se necesita sincronización.
• El código hash puede ser cacheado.
• Los strings pueden usarse de forma segura como claves de mapa.

La contrapartida: construir un string largo en un bucle con + crea muchos strings intermedios. Para eso, usa StringBuilder (Concatenación de Strings).

Longitud e indexación

length() devuelve el número de caracteres:

String s = "hello";
System.out.println(s.length());   // 5

charAt(i) devuelve el carácter en el índice i (basado en cero):

System.out.println(s.charAt(0));   // 'h'
System.out.println(s.charAt(4));   // 'o'
// s.charAt(5);  // StringIndexOutOfBoundsException

Nota: length() es el número de unidades de código UTF-16, no siempre el número de caracteres percibidos por el usuario. Para la mayoría del texto ASCII y BMP son lo mismo, pero los emojis y algunos scripts no latinos usan pares sustitutos y cuentan como 2.

Comparar strings

Usa .equals() para igualdad de contenido, nunca ==:

String a = new String("hi");
String b = new String("hi");

System.out.println(a == b);         // false
System.out.println(a.equals(b));    // true

equalsIgnoreCase ignora las mayúsculas y minúsculas:

"HELLO".equalsIgnoreCase("hello");  // true

Para ordenar, usa compareTo. Compara strings lexicográficamente (por código de carácter) y devuelve un número negativo cuando el primer string va antes que el segundo, 0 cuando son iguales, y un número positivo cuando va después:

"apple".compareTo("banana");        // negative (a < b)
"apple".compareTo("apple");         // 0  — equal
"banana".compareTo("apple");        // positive (b > a)

Como la comparación es por código de carácter, las letras mayúsculas (A–Z, códigos 65–90) van antes que las minúsculas (a–z, códigos 97–122). Usa compareToIgnoreCase para orden sin distinción de mayúsculas.

Operaciones comunes

Los métodos más utilizados, con ejemplos:

String s = "  Hello, World!  ";

s.length();                  // 17
s.trim();                    // "Hello, World!" (whitespace removed)
s.strip();                   // "Hello, World!" (Unicode-aware, Java 11+)
s.toUpperCase();             // "  HELLO, WORLD!  "
s.toLowerCase();             // "  hello, world!  "
s.contains("World");         // true
s.startsWith("  Hello");     // true
s.endsWith("!  ");           // true
s.indexOf("World");          // 9
s.indexOf("xyz");            // -1
s.replace(",", ";");         // "  Hello; World!  "
s.substring(2, 7);           // "Hello"
s.split(", ");               // ["  Hello", "World!  "]
s.isEmpty();                 // false  — length() == 0?
s.isBlank();                 // false  — only whitespace? (Java 11+)

Para la referencia completa, consulta Métodos de String en Java.

Concatenación

El operador + une strings y convierte otros tipos a string según sea necesario:

String name = "Ada";
int age = 36;
String msg = "Name: " + name + ", Age: " + age;
// "Name: Ada, Age: 36"

Dentro de un bucle, prefiere StringBuilder:

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10; i++) {
    sb.append(i).append(",");
}
String result = sb.toString();

Bloques de texto — strings multilínea

Desde Java 15, los bloques de texto te permiten escribir strings multilínea sin escapes:

String json = """
        {
          "name": "Ada",
          "age": 36
        }
        """;

El compilador elimina el espacio en blanco inicial común de cada línea, de modo que la indentación en el código fuente no se traslada al string.

Formateo

String.format construye un string con marcadores de posición estilo printf:

String s = String.format("Name: %s, Age: %d", "Ada", 36);

Los marcadores de posición son los mismos que en System.out.printf — consulta Salida en Java.

Una demostración

Qué sigue

Métodos de String en Java — una referencia de todos los métodos que usarás regularmente.

Práctica