Bloques de Texto en Java: Literales de Cadena Multilínea

Un bloque de texto es un literal de cadena multilínea que te libra del desorden de saltos de línea escapados y concatenaciones. Introducido como vista previa en Java 13 y consolidado definitivamente en Java 15, te permite pegar HTML, JSON, SQL o cualquier bloque de texto formateado directamente en tu código fuente y que se lea como el contenido real.

Antes de los bloques de texto, unas pocas líneas de marcado incrustado significaban una pared de escapes \n y operadores +. Un bloque de texto se abre con tres comillas dobles (""") seguidas de un salto de línea, y todo hasta el cierre """ se convierte en la cadena — con los espacios en blanco iniciales gestionados de forma inteligente.

La Sintaxis de Triple Comilla

Un bloque de texto comienza con """ y un terminador de línea. El contenido empieza en la línea siguiente; el delimitador de apertura no puede compartir línea con texto. El bloque termina con otro """.

// Old way: escapes and concatenation
String json = "{\n" +
              "  \"name\": \"Ada\"\n" +
              "}";

// Text block: paste it as-is
String block = """
    {
      "name": "Ada"
    }
    """;

Advertencia

El error de compilación más común es escribir contenido en la línea de apertura, por ejemplo String s = """{. El """ de apertura debe ir seguido inmediatamente de un terminador de línea — solo el """ de cierre puede compartir su línea con texto.

Los dos producen cadenas casi idénticas, pero el bloque de texto es legible de un vistazo y las comillas dobles incrustadas no necesitan escapado. Un bloque de texto es un String como cualquier otro — no existe un tipo separado —, por lo que todos los métodos de String funcionan sobre él, y un bloque de texto sigue siendo inmutable una vez creado.

Espacios en Blanco Incidentales vs. Esenciales

El compilador distingue los espacios en blanco incidentales (sangría añadida solo para mantener el código fuente ordenado) de los espacios en blanco esenciales (sangría que realmente quieres en el valor). Encuentra la línea con menos espacios en blanco al inicio — incluida la línea del """ de cierre — y elimina esa cantidad común de todas las líneas.

String html = """
        <p>Hi</p>
    """;
// The closing """ is indented 4 spaces, the <p> 8 spaces.
// Common minimum is 4, so the result keeps 4 leading spaces: "    <p>Hi</p>\n"

Mover el delimitador de cierre cambia la cantidad eliminada. Poner """ en el extremo izquierdo no elimina ninguna sangría; ponerlo bajo la línea más profunda elimina toda. Esto te da un control preciso sin contar espacios a mano.

Escapes y el Salto de Línea Final

Los bloques de texto admiten las secuencias de escape habituales, más dos que existen solo para ellos:

Escape	Efecto
`\n`, `\t`, `\"`	Escapes estándar, siguen siendo válidos
`\` (al final de línea)	Continuación de línea — suprime el salto de línea que le seguiría
`\s`	Un espacio simple que nunca se elimina como espacio en blanco incidental

Un bloque de texto cuyo contenido termina en su propia línea incluye un salto de línea final; colocar el """ de cierre en la misma línea que el último texto lo omite.

String withNewline = """
    last line
    """;          // ends with "\n"

String noNewline = """
    last line""";  // no trailing newline

Casos de Uso Habituales

Los bloques de texto brillan donde aparece texto formateado y multilínea en el código:

// SQL kept readable instead of one long escaped string
String query = """
    SELECT id, name, price
    FROM products
    WHERE price < ?
    ORDER BY name
    """;

// JSON payload with quotes that need no escaping
String payload = """
    {
      "user": "ada",
      "roles": ["admin", "editor"]
    }
    """;

Dado que el texto refleja su forma final, copiar y pegar un fragmento de un archivo .sql o .json simplemente funciona, y los revisores pueden detectar errores de formato de inmediato.

Bloques de Texto en Acción

El ejemplo siguiente ejercita todas las características: eliminación de espacios en blanco incidentales, formatted() para marcadores de posición, el stream lines(), los escapes \s y \ al final de línea, la sangría controlada por el delimitador y las comillas dobles incrustadas sin escapar. Lee los comentarios — cada línea corresponde a una regla de las anteriores.

java— editable, runs on the server

public class TextBlockDemo {
    public static void main(String[] args) {
        // A text block: opening """ must be followed by a line terminator.
        String html = """
            <html>
                <body>
                    <p>Hello, %s!</p>
                </body>
            </html>
            """;

// Incidental indentation is stripped relative to the closing """.
        System.out.println("--- raw text block ---");
        System.out.print(html);

// Text blocks are just String instances; all String methods apply.
        String formatted = html.formatted("World");
        System.out.println("--- formatted ---");
        System.out.print(formatted);

// The line count proves the trailing newline from the closing line.
        long lines = html.lines().count();
        System.out.println("Line count: " + lines);

// \ at end of line suppresses the newline (line continuation).
        String oneLine = """
            Roses are red, \
            violets are blue.""";
        System.out.println("Continuation: " + oneLine);

// \s is a space escape that preserves trailing whitespace.
        String padded = """
            ends here:\s
            next line""";
        System.out.println("Has trailing space: "
            + (padded.split("\n")[0].endsWith(" ")));

// Closing delimiter position controls how much indent is removed.
        String indented = """
                kept
              base""";
        System.out.println("--- indentation control ---");
        System.out.println(indented);

// No special escaping needed for embedded double quotes.
        String json = """
            {"name": "Ada", "active": true}""";
        System.out.println("JSON: " + json);
    }
}

Lo que debes extraer de la ejecución:

El bloque sin procesar imprime <html> alineado al margen izquierdo aunque estaba sangrado en el código fuente, porque los espacios en blanco incidentales comunes se eliminaron relativamente al """ de cierre.
formatted("World") sustituye el marcador de posición %s, demostrando que un bloque de texto es un String ordinario que puedes pasar a métodos de formateo.
Line count: 5 proviene de html.lines() al recorrer las cinco líneas de contenido; el salto de línea final añadido por el """ de cierre en su propia línea termina la última línea en vez de crear una sexta línea vacía.
Has trailing space: true muestra que \s forzó a un espacio a sobrevivir que el compilador de otro modo habría eliminado como incidental.
Continuation: Roses are red, violets are blue. demuestra que un \ al final de línea unió las dos líneas fuente en una, y {"name": "Ada", "active": true} se imprimió sin una sola comilla escapada.

Práctica

En un bloque de texto de Java, ¿qué determina cuántos espacios en blanco iniciales se eliminan de cada línea?

La línea con menos sangría, incluida la línea de cierre con triple comillaSiempre exactamente cuatro espacios, independientemente de cómo esté sangrado el bloqueLa sangría del delimitador de apertura con triple comillaNunca se elimina nada; los bloques de texto preservan todos los espacios en blanco literalmente