Métodos de String en Java

La clase String incluye decenas de métodos. Este capítulo es una referencia práctica de los que realmente usarás, agrupados por función: inspección, comparación, búsqueda, extracción, transformación, división/unión, conversión y formato.

Recuerda: las cadenas son inmutables. Cada método que se muestra a continuación devuelve una nueva cadena (u otro valor); nunca modifica la cadena sobre la que se llama. Eso significa que una llamada como s.toUpperCase(); por sí sola no hace nada útil; debes capturar el resultado:

String s = "hello";
s.toUpperCase();        // result discarded — s is still "hello"
s = s.toUpperCase();    // s is now "HELLO"

Los índices son de base cero y cuentan unidades de código UTF-16, no caracteres percibidos por el usuario, lo cual importa para los emoji y otros caracteres suplementarios.

Inspeccionar una cadena

"hello".length();      // 5
"".isEmpty();          // true
"   ".isBlank();       // true
"hello".charAt(1);     // 'e'

Comparar cadenas

"hi".equals("hi");                  // true
"HI".equalsIgnoreCase("hi");        // true
"apple".compareTo("banana");        // negative

Siempre prefiere .equals() sobre == para comparar contenido (Operadores de comparación). == compara referencias a objetos — si dos variables apuntan al mismo objeto — no los caracteres internos. Como Java internaliza los literales de cadena, == a veces parece funcionar, pero falla en el momento en que una cadena se construye en tiempo de ejecución:

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

a == b;          // true  — both point to the same interned literal
a == c;          // false — c is a different object
a.equals(c);     // true  — same contents

compareTo es lo que necesitas para ordenar: devuelve un número negativo, cero o un número positivo, por lo que encaja directamente en Collections.sort o en cadenas de Comparator.

Buscar

String s = "abc-xyz-abc";
s.contains("xyz");       // true
s.indexOf("abc");        // 0
s.lastIndexOf("abc");    // 8
s.startsWith("abc");     // true
s.endsWith("xyz");       // false

Extraer subcadenas

String s = "Hello, World!";
s.substring(7);        // "World!"
s.substring(7, 12);    // "World"

Los índices negativos no están permitidos; lanzan StringIndexOutOfBoundsException.

Transformar

"  hello  ".strip();                 // "hello"
"banana".replace("a", "_");          // "b_n_n_"
"hello".repeat(3);                   // "hellohellohello"
"abc 123".replaceAll("\\d", "*");    // "abc ***"

Dividir y unir

"a,b,c".split(",");                     // ["a","b","c"]
String.join("-", "a", "b", "c");        // "a-b-c"
String.join(",", List.of("a","b"));     // "a,b"
"line1\nline2\nline3".lines().count();  // 3

split acepta una regex, no una cadena simple, por lo que debes escapar los metacaracteres de regex: usa split("\\.") para dividir por un punto literal, no split(".") (que coincide con cualquier carácter y devuelve un array vacío). Las cadenas vacías al final se descartan por defecto; pasa un limit negativo (p. ej. split(",", -1)) para conservarlas.

Conversión

String.valueOf(42);              // "42"
Integer.parseInt("42");          // 42
Double.parseDouble("3.14");      // 3.14
"hello".toCharArray();           // {'h','e','l','l','o'}

Los métodos parse* lanzan NumberFormatException si el texto no es un número válido, así que envuelve la entrada del usuario en un try/catch o valídala primero. A diferencia de parseInt, String.valueOf(null) es seguro — devuelve la cadena "null" en lugar de lanzar una excepción.

Formato

String.format("%s is %d", "Ada", 36);     // "Ada is 36"
"%s is %d".formatted("Ada", 36);          // "Ada is 36"

Una demostración combinada

¿Qué sigue?

Concatenación de String en Java profundiza en +, concat y StringBuilder, incluido cuándo usar cada uno.

Práctica