0Pricing
Java Academy · Lección

Bloques de texto y String.format

Escriba cadenas multilínea con bloques de texto y formatee datos con patrones de String.format.

Bloques de texto y String.format es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

Bloques de texto y String.format

Los bloques de texto (Java 15 o posterior) permiten usar literales de cadena multilínea sin secuencias de escape. Combinados con String.format y formatted(), hacen que los resultados de texto complejos sean claros y legibles.

¿Qué son los bloques de texto?

Un bloque de texto es un literal de cadena delimitado por tres comillas dobles """. Conserva los saltos de línea y la indentación automáticamente, eliminando las secuencias de escape en el contenido multilínea.

// Traditional multi-line string
String old = "SELECT id, name, email\n" +
             "FROM users\n" +
             "WHERE active = true\n" +
             "ORDER BY name;";

// Text block (Java 15+) — much cleaner
String sql = """
    SELECT id, name, email
    FROM users
    WHERE active = true
    ORDER BY name;
    """;

System.out.println(sql);

Gestión de la indentación

Los bloques de texto eliminan automáticamente los espacios en blanco iniciales comunes. La posición de las """ de cierre controla la indentación.

// Leading spaces up to the closing """ are stripped
String json = """
        {
            "name": "Alice",
            "role": "admin"
        }
        """;
// Output has no leading spaces (stripped by common indent)
System.out.println(json);
// {
//     "name": "Alice",
//     "role": "admin"
// }

Comillas insertadas

Los bloques de texto pueden contener comillas dobles sin escaparlas, siempre que no aparezcan tres comillas consecutivas. Una sola " y dos "" son válidas.

String html = """
    <div class="container">
        <p class="title">Hello, World!</p>
        <a href="https://example.com">Click here</a>
    </div>
    """;
System.out.println(html);
// Note: no need to escape " inside the block

Bloques de texto para plantillas JSON

Los bloques de texto son especialmente útiles para plantillas JSON, HTML, XML y SQL utilizadas en pruebas o configuración.

String request = """
    {
        "email": "alice@example.com",
        "password": "secret123",
        "plan": "PRO"
    }
    """;

// In tests: compare expected JSON
String expected = """
    {
      "status": "created",
      "id": 42
    }
    """;
// Perfect for MockMvc test assertions
System.out.println(request);

formatted() con bloques de texto

Combine los bloques de texto con formatted() (Java 15 o posterior) para crear plantillas parametrizadas.

String name = "Alice";
long orderId = 1234L;
double total = 149.99;

String email = """
    Dear %s,

    Your order #%d has been confirmed.
    Total charged: $%.2f

    Thank you for shopping with us!
    """.formatted(name, orderId, total);

System.out.println(email);
// Dear Alice,
// Your order #1234 has been confirmed.
// Total charged: $149.99

Secuencias de escape en bloques de texto

Los bloques de texto admiten \n, \t y las secuencias de escape de Java 14 o posterior: \ (continuación de línea) y \s (conservación de los espacios finales).

// \s forces a space (preserves trailing whitespace on line)
String padded = """
    line one  \s
    line two   \s
    """;

// \ (backslash at end of line) joins lines in source but keeps them as one
String poem = """
    Roses are red, \
    violets are blue.
    """;
System.out.println(poem); // Roses are red, violets are blue.

Referencia de String.format

Especificadores de formato principales de String.format:

  • %s — String
  • %d — entero
  • %f — coma flotante
  • %.2f — 2 decimales
  • %n — salto de línea de la plataforma
  • %x — hexadecimal
  • %10d — alineación a la derecha en 10 caracteres
System.out.printf("%s | %d | %.2f | %X%n", "Item", 42, 9.99, 255);
// Item | 42 | 9.99 | FF

String formatted = String.format("%-20s %6.2f%n", "Mechanical Keyboard", 129.95);
System.out.print(formatted);
// Mechanical Keyboard 129.95

// Named format with text block
System.out.printf("""
    Order: %s
    Total: $%.2f
    Status: %s%n""", "ORD-001", 99.99, "SHIPPED");

stripIndent y translateEscapes en bloques de texto

Dos métodos de String funcionan con bloques de texto: stripIndent() elimina los espacios en blanco iniciales comunes y translateEscapes() procesa las secuencias de escape en una cadena durante la ejecución.

String raw = "  hello\\n  world";
System.out.println(raw);                    // hello\n  world
System.out.println(raw.translateEscapes()); // hello (newline) world

// stripIndent removes common leading whitespace
String indented = "    line 1\n    line 2\n    line 3";
System.out.println(indented.stripIndent()); // line 1\nline 2\nline 3

En la práctica: plantilla de correo electrónico HTML

Crear una plantilla parametrizada de correo electrónico HTML con un bloque de texto.

static String buildWelcomeEmail(String name, String activationLink) {
    return """
        <!DOCTYPE html>
        <html>
          <body>
            <h1>Welcome, %s!</h1>
            <p>Click the link below to activate your account:</p>
            <a href="%s">Activate Account</a>
          </body>
        </html>
        """.formatted(name, activationLink);
}

System.out.println(buildWelcomeEmail("Alice",
    "https://app.example.com/activate?token=abc123"));

Bloques de texto frente a String.join

Para listas de elementos, String.join o Collectors.joining ofrecen más flexibilidad que un bloque de texto. Utilice bloques de texto para contenido multilínea fijo y join para listas dinámicas.

import java.util.*;
import java.util.stream.*;

List<String> features = List.of("Unlimited storage", "Priority support", "AI assistant");

// Dynamic list: join
String bullet = features.stream()
    .map(f -> "  • " + f)
    .collect(Collectors.joining("\n"));
System.out.println(bullet);
// • Unlimited storage
// • Priority support
// • AI assistant

// Fixed template: text block + formatted
String plan = """
    PRO Plan — $29/month
    Features:
    %s
    """.formatted(bullet);
System.out.println(plan);

Comprobación rápida

¿Qué controla la posición de las """ de cierre en un bloque de texto?

Resumen: bloques de texto y String.format

Conclusiones principales:

  • Los bloques de texto (Java 15 o posterior) utilizan tres comillas y conservan la estructura multilínea sin secuencias de escape
  • Los espacios en blanco iniciales comunes se eliminan automáticamente según la posición de las \"\"\" de cierre
  • Las comillas dobles dentro de los bloques de texto no necesitan escaparse
  • Utilice .formatted() en un bloque de texto para crear plantillas parametrizadas
  • Especificadores de String.format: %s, %d, %.2f, %n, %x y marcas de anchura y alineación
  • Utilice \s al final de una línea para conservar los espacios finales y \ al final de una línea para unir líneas

Preguntas frecuentes

¿La lección «Bloques de texto y String.format» es gratis?

Sí — el texto completo de «Bloques de texto y String.format» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Bloques de texto y String.format»?

Escriba cadenas multilínea con bloques de texto y formatee datos con patrones de String.format. Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Bloques de texto y String.format»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Inmutabilidad de String y el pool de cadenas
  2. StringBuilder para una concatenación eficiente
  3. Bloques de texto y String.format
  4. Expresiones regulares con Pattern y Matcher
← Volver a Java Academy