String

En Java, la clase String es una de las clases más utilizadas y forma parte del paquete java.lang. Representa cadenas de texto y, aunque String se comporta como un tipo de datos primitivo, realmente es una clase que proporciona muchas funcionalidades para trabajar con texto.

Características

• Inmutabilidad: Una vez que una instancia de String es creada, no puede ser modificada. Cualquier operación que aparentemente modifique una cadena (como concatenación) crea una nueva instancia de String, y la antigua permanece inalterada. Por ejemplo:

  String texto = "Hola";
  texto = texto + " Mundo"; // Crea una nueva instancia "Hola Mundo"

  El contenido original Hola no se altera; la variable texto ahora referencia una nueva cadena Hola Mundo.

• Almacenamiento en el String Pool: Java utiliza un pool de cadenas (String Pool) para guardar instancias de String. Un pool es una zona de memoria compartida donde se guardan objetos reutilizables, para evitar crear nuevas instancias idénticas una y otra vez. Cuando se crea una cadena literal, Java comprueba si ya existe una cadena igual en el pool y, si es así, la reutiliza. Esto ayuda a ahorrar memoria, especialmente cuando se reutilizan cadenas idénticas.

  String s1 = "Hola";
  String s2 = "Hola";
  System.out.println(s1 == s2); // Salida: true (comparten la misma referencia)

Métodos más utilizados

La clase String proporciona muchos métodos útiles para manipular cadenas de texto.

A continuación, se muestran los más comunes.

Crear un string

String sb = new String(); // Cadena vacía
String sbCoTexto = new String("Hola Mundo"); // Cadena inicial

Obtener un carácter en una posición concreta

char caracter = texto.charAt(4); // Se obtiene el carácter de la posición 4

Concatenar cadenas

concat(String str)

String parte1 = "Hola";
String parte2 = " Mundo";
String resultado = parte1.concat(parte2); // Retorna "Hola Mundo"

Comprobar si un string contiene una determinada substring

boolean contains(CharSequence subcadena)

String texto = "Hola, bienvenido a Java!";
System.out.println(texto.contains("bienvenido")); // true
System.out.println(texto.contains("Python"));  // false

Comprobar si un string termina con una determinada substring

boolean endsWith(String sufijo)

String fichero = "documento.pdf";
System.out.println(fichero.endsWith(".pdf"));  // true
System.out.println(fichero.endsWith(".txt"));  // false

Comparar cadenas

boolean equals(String str)
boolean equalsIgnoreCase(String str)

String a = "Hola";
String b = "hola";
boolean igual = a.equals(b); // Retorna false
boolean igualIgnorandoMayusculas = a.equalsIgnoreCase(b); // Retorna true

Buscar caracteres o subcadenas

int indexOf(int caracter)
int indexOf(int caracter, int desdeIndice)
int indexOf(int caracter, int desdeIndice, int hastaIndice)
int indexOf(String cadena)
int indexOf(String cadena, int desdeIndice)
int indexOf(String cadena, int desdeIndice, int hastaIndice)

String texto = "Bienvenido al curso de Java";
int indice = texto.indexOf("curso"); // Retorna 21

Obtener la longitud de la cadena

int length()

String texto = "Ejemplo";
int largo = texto.length(); // Retorna 7

Reemplazar caracteres o subcadenas

String replace(char caracter, char caracterNuevo)
String replace(String subcdea, String subcadenaNueva)

String texto = "Java es divertido";
String resultado = texto.replace("divertido", "increíble"); // Retorna "Java es increíble"

Dividir cadenas

String[] split(String regex)

String texto = "Hola, Mundo";
String[] partes = texto.split(", "); // Retorna un array ["Hola", "Mundo"]

Comprobar si una cadena comienza con una determinada subcadena

boolean startsWith(String prefijo)

String fichero = "documento.pdf";
System.out.println(fichero.startsWith("doc"));  // true
System.out.println(fichero.startsWith("txt"));  // false

Subcadenas

String substring(int indiceComienzo)
String substring(int indiceComienzo, int indiceFinalSinIncluir)

String texto = "Bienvenido";
String subcadena = texto.substring(3); // Retorna "venido"

Conversiones a mayúsculas o minúsculas

String toUpperCase()
String toLowerCase()

String texto = "Hola Mundo";
String mayusculas = texto.toUpperCase(); // Retorna "HOLA MUNDO"

Eliminar espacios en blanco al principio y final

String trim()

String texto = "   Hola   ";
String sinEspacios = texto.trim(); // Retorna "Hola"

Conversión a String

El método valueOf() de la clase String en Java es un método estático que convierte diferentes tipos de datos en cadenas de texto (String).

public static String valueOf(tipo valor)

La clase String sobrecarga valueOf() para admitir diferentes tipos de datos:

Método	Conversión	Ejemplo
String.valueOf(int i)	int → String	String.valueOf(42)
String.valueOf(double d)	double → String	String.valueOf(3.14)
String.valueOf(boolean b)	boolean → String	String.valueOf(true)
String.valueOf(char c)	char → String	String.valueOf('A')
String.valueOf(char[] data)	char[] → String	String.valueOf(new char[]{'H', 'o'})

Conversión desde String

Para convertir un String a otros tipos de datos en Java, utilizamos los métodos de conversión proporcionados por las clases envolventes (wrapper classes) de los tipos primitivos.

Conversión	Método
String → int	Integer.parseInt(str) o Integer.valueOf(str)
String → double	Double.parseDouble(str) o Double.valueOf(str)
String → boolean	Boolean.parseBoolean(str) o Boolean.valueOf(str)
String → char[]	str.toCharArray()

A diferencia de parseX(), valueOf() devuelve objetos envolventes como Integer, Double, Boolean, etc., mientras que parseX() devuelve tipos primitivos como int, double, etc.

Importante: Todas las conversiones numéricas lanzan una NumberFormatException si el String no contiene un valor válido.

Método Integer.valueOf(char)

Si utilizamos el método Integer.valueOf(char) por ejemplo con el carácter '9', este método no devolverá el entero 9, sino que devolverá su código ASCII correspondiente 57.

int numero = Integer.valueOf('9');
System.out.println(numero); // Imprime 57

La solución es, o pasarlo el carácter a un String:

String numeroS = String.valueOf('9');
int numero = Integer.valueOf(numeroS);
System.out.println(numero); // Imprime 9

Comparaciones de cadenas

En Java, comparar cadenas de texto (String) puede hacerse de varias formas, dependiendo de qué quieres comprobar exactamente (si las cadenas son iguales, si una es lexicográficamente mayor que la otra, etc.). Aquí te explico las principales formas de comparar String en Java:

• El método boolean equals(Object otro) compara el valor de las cadenas, es decir, el contenido de las cadenas.

  String a = "Java";
  String b = "Java";
  String c = "java";
  
  System.out.println(a.equals(b)); // true
  System.out.println(a.equals(c)); // false

• boolean equalsIgnoreCase(String otro) este método compara las cadenas sin tener en cuenta si son mayúsculas o minúsculas.

  String a = "Java";
  String b = "java";
  
  System.out.println(a.equalsIgnoreCase(b)); // true

• Si necesitas comparar cadenas para ver si son mayores, menores o iguales en orden lexicográfico, usa int compareTo(String otro). Retorna un número negativo, cero o positivo dependiendo de si la cadena actual es lexicográficamente menor, igual o mayor que la cadena de comparación.

  String a = "Java";
  String b = "Python";
  String c = "Java";
  
  System.out.println(a.compareTo(b)); // Valor negativo (porque "Java" es lexicográficamente menor que "Python")
  System.out.println(a.compareTo(c)); // 0 (porque son iguales)
  System.out.println(b.compareTo(a)); // Valor positivo (porque "Python" es lexicográficamente mayor que "Java")

• Para no distinguir entre mayúsculas y minúsculas, usa int compareToIgnoreCase(String otro).

  String a = "java";
  String b = "Java";
  
  System.out.println(a.compareToIgnoreCase(b)); // 0 (porque no importa la mayúscula/minúscula)

Comparación ==

El operador == compara las referencias de los objetos, no sus valores. Esto significa que compara si las cadenas son el mismo objeto en memoria, no si tienen el mismo contenido.

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

System.out.println(a == b); // true (porque "Java" está en el área de memoria del "String pool")
System.out.println(a == c); // false (porque "c" es un nuevo objeto en memoria)

Bloques de texto

Los bloques de texto (o text blocks) en Java fueron introducidos en Java 13 (como funcionalidad previa) y estabilizados en Java 15. Estos bloques facilitan el trabajo con cadenas de texto (String) largas o complejas, como código HTML, JSON, SQL, u otros textos multilínea, ofreciendo una sintaxis más limpia y mejor lectura.

Un bloque de texto es una cadena delimitada por tres comillas dobles (""") que puede abarcar múltiples líneas de código. Permite evitar caracteres de escape como \n para saltos de línea y proporciona un formato más natural.

String bloqueTexto = """
    Esta es una cadena de texto
    que se extiende por múltiples líneas