0Pricing
Java Academy · Lekcja

Bloki tekstowe i String.format

Zapisuj wielowierszowe łańcuchy znaków za pomocą bloków tekstowych i formatuj dane wzorcami String.format.

Bloki tekstowe i String.format to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 4 lekcji w sumie.

Bloki tekstowe i String.format

Bloki tekstowe (Java 15+) umożliwiają definiowanie wielowierszowych literałów String bez znaków ucieczki. W połączeniu z String.format i formatted() pozwalają tworzyć złożony tekst w przejrzysty i czytelny sposób.

Czym są bloki tekstowe

Blok tekstowy to literał String ujęty w potrójne cudzysłowy """. Automatycznie zachowuje znaki nowego wiersza i wcięcia, eliminując konieczność używania sekwencji ucieczki w treściach wielowierszowych.

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

Obsługa wcięć

Bloki tekstowe automatycznie usuwają wspólne początkowe białe znaki. Pozycja zamykającego """ określa wcięcie.

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

Osadzone cudzysłowy

Bloki tekstowe mogą zawierać cudzysłowy bez znaków ucieczki, o ile nie występują w nich trzy kolejne cudzysłowy. Pojedynczy " i podwójny "" cudzysłów są dozwolone.

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

Bloki tekstowe jako szablony JSON

Bloki tekstowe świetnie sprawdzają się w szablonach JSON, HTML, XML i SQL używanych w testach lub konfiguracji.

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() z blokami tekstowymi

Połącz bloki tekstowe z formatted() (Java 15+), aby tworzyć sparametryzowane szablony.

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

Sekwencje ucieczki w blokach tekstowych

Bloki tekstowe obsługują \n, \t oraz wprowadzone w Javie 14: \ (kontynuacja wiersza) i \s (zachowanie końcowych białych znaków).

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

Opis String.format

Najważniejsze specyfikatory formatu dla String.format:

  • %s — String
  • %d — liczba całkowita
  • %f — liczba zmiennoprzecinkowa
  • %.2f — 2 miejsca po przecinku
  • %n — znak nowego wiersza zależny od platformy
  • %x — zapis szesnastkowy
  • %10d — wyrównanie do prawej w polu o szerokości 10 znaków
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 i translateEscapes dla bloków tekstowych

Dwie metody String współpracują z blokami tekstowymi: stripIndent() usuwa wspólne początkowe białe znaki, a translateEscapes() przetwarza sekwencje ucieczki w łańcuchu znaków podczas działania programu.

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

Praktyczny przykład: szablon wiadomości e-mail w HTML

Budowanie sparametryzowanego szablonu wiadomości e-mail w HTML za pomocą bloku tekstowego.

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

Bloki tekstowe a String.join

W przypadku list elementów String.join lub Collectors.joining jest elastyczniejsze niż blok tekstowy. Bloków tekstowych należy używać dla stałej zawartości wielowierszowej, a metod join dla list dynamicznych.

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

Szybkie sprawdzenie

Co określa pozycja zamykającego """ w bloku tekstowym?

Podsumowanie: bloki tekstowe i String.format

Najważniejsze informacje:

  • Bloki tekstowe (Java 15+) używają potrójnych cudzysłowów i zachowują strukturę wielowierszową bez znaków ucieczki
  • Wspólne początkowe białe znaki są automatycznie usuwane na podstawie pozycji zamykającego \"\"\"
  • Cudzysłowy wewnątrz bloków tekstowych nie wymagają znaków ucieczki
  • Na bloku tekstowym należy używać .formatted() do tworzenia sparametryzowanych szablonów
  • Specyfikatory String.format: %s, %d, %.2f, %n, %x oraz flagi szerokości i wyrównania
  • Należy używać \s na końcu wiersza, aby zachować końcowe spacje, oraz \ na końcu wiersza, aby połączyć wiersze

Często zadawane pytania

Czy lekcja „Bloki tekstowe i String.format” jest bezpłatna?

Tak — pełny tekst „Bloki tekstowe i String.format” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Bloki tekstowe i String.format”?

Zapisuj wielowierszowe łańcuchy znaków za pomocą bloków tekstowych i formatuj dane wzorcami String.format. Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Java Academy?

Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Bloki tekstowe i String.format”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?

Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Niezmienność String i pula stringów
  2. StringBuilder do wydajnego łączenia
  3. Bloki tekstowe i String.format
  4. Wyrażenia regularne z Pattern i Matcher
← Powrót do Java Academy