0Pricing
Java Academy · Aula

Blocos de Texto e String.format

Escreva strings com várias linhas usando blocos de texto e formate dados com padrões de String.format.

Blocos de Texto e String.format é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Blocos de texto e String.format

Os blocos de texto (Java 15+) permitem literais de string com várias linhas sem caracteres de escape. Combinados com String.format e formatted(), eles tornam a saída complexa de strings limpa e legível.

O que são blocos de texto

Um bloco de texto é um literal de string delimitado por três aspas duplas """. Ele preserva automaticamente quebras de linha e indentação, eliminando sequências de escape para conteúdo com várias linhas.

// 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);

Tratamento da indentação

Os blocos de texto removem automaticamente os espaços em branco comuns no início das linhas. A posição do """ de fechamento controla a indentação.

// 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"
// }

Aspas incorporadas

Os blocos de texto podem conter aspas duplas sem caracteres de escape, desde que não apareçam três aspas consecutivas. Uma única " ou "" não apresenta problema.

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

Blocos de texto para modelos JSON

Os blocos de texto são especialmente úteis para modelos JSON, HTML, XML e SQL usados em testes ou configurações.

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() com blocos de texto

Combine blocos de texto com formatted() (Java 15+) para criar modelos parametrizados.

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

Sequências de escape em blocos de texto

Os blocos de texto aceitam \n, \t e os recursos do Java 14+: \ (continuação de linha) e \s (preservação de espaços em branco finais).

// \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.

Referência de String.format

Principais especificadores de formato de String.format:

  • %s — String
  • %d — inteiro
  • %f — ponto flutuante
  • %.2f — 2 casas decimais
  • %n — nova linha da plataforma
  • %x — hexadecimal
  • %10d — alinhamento à direita em 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 e translateEscapes em blocos de texto

Dois métodos de String funcionam com blocos de texto: stripIndent() remove os espaços em branco comuns no início, e translateEscapes() processa sequências de escape em uma string durante a execução.

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

Prático: modelo de e-mail HTML

Construção de um modelo parametrizado de e-mail HTML com um bloco 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"));

Blocos de texto versus String.join

Para listas de itens, String.join ou Collectors.joining são mais flexíveis do que um bloco de texto. Use blocos de texto para conteúdo fixo com várias linhas; use 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);

Verificação rápida

O que a posição do """ de fechamento controla em um bloco de texto?

Recapitulação: blocos de texto e String.format

Principais conclusões:

  • Os blocos de texto (Java 15+) usam três aspas e preservam a estrutura de várias linhas sem caracteres de escape
  • Os espaços em branco comuns no início são removidos automaticamente com base na posição do \"\"\" de fechamento
  • As aspas duplas dentro dos blocos de texto não precisam de caracteres de escape
  • Use .formatted() em um bloco de texto para criar modelos parametrizados
  • Especificadores de String.format: %s, %d, %.2f, %n, %x, sinalizadores de largura/alinhamento
  • Use \s no fim da linha para preservar espaços finais; use \ no fim da linha para unir linhas

Perguntas Frequentes

A aula “Blocos de Texto e String.format” é grátis?

Sim — o texto completo de “Blocos de Texto e String.format” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Blocos de Texto e String.format”?

Escreva strings com várias linhas usando blocos de texto e formate dados com padrões de String.format. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Blocos de Texto e String.format”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Imutabilidade de String e o Pool de Strings
  2. StringBuilder para Concatenação Eficiente
  3. Blocos de Texto e String.format
  4. Expressões Regulares com Pattern e Matcher
← Voltar para Java Academy