Java Text Blocks: strings multilínea sin escapes

Qué son los text blocks y por qué existen

Los text blocks (bloques de texto) son una forma de escribir literales de cadena multilínea en Java. Fueron introducidos en Java 13 como característica en preview y estabilizados en Java 15. Resuelven un problema clásico: construir strings con saltos de línea, comillas o indentación era engorroso y propenso a errores.

Antes de los text blocks, escribir un JSON literal en Java obligaba a concatenar líneas con \n y escapar cada comilla:

String json = "{\n" +
" \"nombre\": \"Ana\",\n" +
" \"edad\": 30\n" +
"}";

Con text blocks, el mismo JSON se escribe de forma directa y legible:

String json = """
{
    "nombre": "Ana",
    "edad": 30
}
""";

Sintaxis básica

Un text block se abre con tres comillas dobles seguidas de un salto de línea ("""\n) y se cierra con otras tres comillas dobles:

String saludo = """
Hola, mundo.
Esto es un text block.
""";

Reglas clave de sintaxis:

El opening delimiter (""") debe ir seguido de un salto de línea. No se puede escribir """Hola""" en una sola línea.
El closing delimiter (""") puede ir en su propia línea o pegado al último carácter del contenido.
Las comillas dobles no necesitan escape dentro de un text block (basta con no poner tres seguidas).
Los saltos de línea son literales: cada línea del código produce un \n en la cadena resultante (excepto el salto que sigue al opening delimiter).

Indentación incidental

La regla más importante de los text blocks es cómo Java trata la indentación incidental. El compilador identifica el mínimo común de espacios en blanco al inicio de cada línea (incluida la línea del closing delimiter) y los elimina de todas las líneas.

String texto = """
línea 1
línea 2
""";
// Resultado: "línea 1\nlínea 2\n"

La posición del closing delimiter controla la indentación que se conserva:

String texto = """
línea 1
línea 2
""";
// Las " " iniciales se eliminan; quedan 2 espacios al principio de cada línea:
// " línea 1\n línea 2\n"

Esto permite escribir text blocks perfectamente alineados con el código sin que la indentación del código fuente ensucie el string.

Secuencias de escape especiales

Los text blocks introducen dos secuencias de escape específicas:

\<newline>: suprimir salto de línea: al final de una línea, una barra invertida anula el salto y une la siguiente línea al final:

String frase = """
Esta es una frase muy larga que queremos \
escribir en dos líneas del código fuente pero \
que en el string resultante sea una sola línea.
""";
// Resultado: "Esta es una frase muy larga que queremos escribir en dos líneas del código fuente pero que en el string resultante sea una sola línea.\n"

\s: espacio explícito: inserta un espacio que no se elimina por el trimming de espacios en blanco al final de línea:

String tabla = """
Nombre Edad\s
Ana 30\s
Bob 25\s
""";
// Conserva los espacios al final de cada línea

Casos de uso habituales

JSON

String payload = """
{
    "usuario": {
        "id": 42,
        "nombre": "Ana",
        "roles": ["admin", "editor"]
    }
}
""";

SQL

String query = """
SELECT p.id, p.nombre, c.nombre AS categoria
FROM productos p
INNER JOIN categorias c ON p.categoria_id = c.id
WHERE p.precio BETWEEN ? AND ?
ORDER BY p.nombre
""";

HTML

String plantilla = """
<!DOCTYPE html>
<html lang="es">
<head>
<meta charset="UTF-8">
<title>Mi página</title>
</head>
<body>
<h1>Bienvenido</h1>
</body>
</html>
""";

Interpolación con `formatted()`

Los text blocks se combinan con el método formatted(Object... args) para sustituir placeholders, equivalente a String.format(tb, args) pero más fluido:

String nombre = "Ana";
int edad = 30;

String saludo = """
Hola, %s.
Tienes %d años.
""".formatted(nombre, edad);

Diferencias con la concatenación tradicional

| Aspecto | Concatenación + "\n" | Text block | |---------|------------------------|------------| | Legibilidad | Baja en cadenas largas | Alta | | Escape de comillas | Necesario \" | No necesario | | Indentación | Gestión manual | Automática (incidental) | | Rendimiento | Compilador la convierte a StringBuilder | Literal directo | | Uso en switch/return | Funciona igual | Funciona igual |

Limitaciones y buenas prácticas

Un text block es un String normal: todos los métodos de String (length(), contains(), split(), etc.) funcionan exactamente igual.
Si necesitas que el string no termine en salto de línea, pon el closing delimiter en la misma línea del último contenido: """...línea final""".
Para representar texto que comienza o termina con espacios significativos, usa \s explícito o acerca el closing delimiter.
Los text blocks son equivalentes a cadenas compiladas: "a\nb" y su text block equivalente producen exactamente el mismo objeto String tras intern().

Alan Sastre

Ingeniero de Software y formador, CEO en CertiDevs

Ingeniero de software especializado en Full Stack y en Inteligencia Artificial. Como CEO de CertiDevs, Java es una de sus áreas de expertise. Con más de 15 años programando, 6K seguidores en LinkedIn y experiencia como formador, Alan se dedica a crear contenido educativo de calidad para desarrolladores de todos los niveles.

Más tutoriales de Java

Explora más contenido relacionado con Java y continúa aprendiendo con nuestros tutoriales gratuitos.

Ver más tutoriales de Java Explorar todas las tecnologías

Aprendizajes de esta lección

Declarar cadenas multilínea con la sintaxis '. Comprender el tratamiento de indentación incidental. Usar secuencias de escape especiales: \\\\s, \\\\<newline>, \\\\'. Aplicar text blocks en casos reales: JSON, SQL, HTML, XML. Combinar text blocks con String.formatted() y String.format(). Diferenciar text blocks de concatenación tradicional y String.join.