Bloki tekstu – Java 15

Często zdarza się, że chcemy na ekranie albo wyświetlić wielolinijkowy blok tekstu, albo mamy do wyświetlenia jedną linię tekstu, która jest bardzo długa. Do niedawna programiści Java byli w tych przypadkach zmuszenia do łączenia kilku stringów:

public class StringKilkaLinii {
  public static void main(String[] args) {
    System.out.println(
        "To jest bardzo długi komunikat,\n" +
        "który został podzielony na kilka stringów,\n" +
        "aby był bardziej czytelny."
    );
  }
}

Ten program wypisuje na ekran komunikat w trzech liniach:

Wychodząc programistom naprzeciw, twórcy języka Java w wersji 15 dodali do niego nową funkcjonalność – bloki tekstu.

Bloki tekstu służą do wstawiania do kodu wielolinijkowych stringów, bez potrzeby używania plusa do łączenia kolejnych łańcuchów tekstu ujętych w cudzysłowy. Po-przedni przykład korzystający z tej nowej funkcjonalności wygląda następująco:

public class BlokTekstu {
  public static void main(String[] args) {
    System.out.println("""
        To jest bardzo długi komunikat,
        który został podzielony na kilka stringów,
        aby był bardziej czytelny."""
    );
  }
}

Ten program wypisuje na ekran taki sam komunikat, jak StringKilkaLinii.

Warto tutaj zauważyć trzy właściwości bloków tekstu:

• po każdej linii tekstu (poza ostatnią – więcej o tym za chwilę) dodawany jest znak nowej linii,
• początkowe znaki spacji są wycinane,
• string, który zostanie wypisany, zaczyna się od pierwszej linii następującej po znakach """, które otwierają blok tekstu.

W przeciwieństwie do zwykłych stringów, bloki tekstu zapisujemy otaczając tekst trzema znakami cudzysłowu. Dzięki blokom tekstu nie musimy powtarzać znaków cudzysłowu i plusa w każdej linii.

Zauważ, że w pierwszym przykładzie dopisałem na końcu dwóch pierwszych stringów znak nowej linii \n:

"To jest bardzo długi komunikat,\n" +
"który został podzielony na kilka stringów,\n" +
"aby był bardziej czytelny."

W blokach tekstu taki znak jest automatycznie dodawany na końcu każdej linii, więc nie musimy sami go wpisywać. Wyjątkiem jest ostatnia linia bloku tekstu – jeżeli cudzysłowy zamykające blok tekstu są w tej samej linii, co ostatnia linia tekstu, znak nowej linii nie zostanie dodany – porównaj:

System.out.println("""
    Tekst 1 - pierwsza linia.
    Tekst 1 - druga linia."""
);

System.out.println("""
    Tekst 2 - pierwsza linia.
    Tekst 2 - druga linia.
    """
);

Te instrukcje spowodują wypisanie na ekran:

Zwróć uwagę, że na końcu jest dodatkowa, pusta linia. Powodem jest to, że w drugim bloku tekstu cudzysłowy zamykające są w osobnej linii – spowoduje to dodanie na końcu drugiej linii znaku nowej linii, co skutkuje dodatkową, pustą linią.

Bloki tekst to stringi, więc ich wartości możemy przypisać bezpośrednio do zmiennej typu String. Dodatkowo, znaki cudzysłowu możemy wstawiać do bloków tekstu bez potrzeby stosowania znaku backslash:

public class PrzypisanieBlokuTekstu {
  public static void main(String[] args) {
    String blokTekstu = """
        Czwartek to "mały piątek".
        A środa to już bliżej niż dalej.""";

    System.out.println(blokTekstu);
  }
}

Ten program wypisuje na ekran:

Definiując blok tekstu po otwierających go cudzysłowach musimy przejść do nowej linii – w przeciwnym razie kod się nie skompiluje:

String pewnyString = """pewien komunikat"""; // błąd

Kompilator zgłosi poniższe błędy:

Poprawny zapis jest następujący:

String pewnyString = """
    pewien komunikat""";

Na początku opisu bloków tekstu wspomniałem, że początkowe białe znaki są wycinane z bloku tekstu. Tym zachowaniem można sterować za pomocą odpowiedniego umiejscowienia znaków """ kończących blok tekstu – spójrzmy na przykład. Zauważ, że drugi z przykładowych bloków tekstu zaprezentowany w programie BlokTekstuWciecie ma umieszczone zamykające znaki """ wcześniej, niż zaczyna się string zawarty w bloku tekstu.

public class BlokTekstuWciecie {
  public static void main(String[] args) {
    String s1 = """
        Pierwszy blok tekstu - pierwsza linia.
        Pierwszy blok tekstu - druga linia.
        """;

    String s2 = """
        Drugi blok tekstu - pierwsza linia.
        Drugi blok tekstu - druga linia.
    """;

    System.out.println(s1);
    System.out.println(s2);
  }
}

Ten program wypisuje na ekran:

Przesunięcie zamykających blok tekstu znaków """ powoduje, że pewna liczba początkowych białych znaków nie jest ignorowana. W tym przypadku wszystkie cztery białe znaki weszły w skład stringa przypisywanego do zmiennej s2.

Bloki tekstu mogą także opisywać długi tekst, który nie powinien być podzielony na osobne linie. Aby zaznaczyć, że znak nowej linii nie powinien być wstawiony na końcu aktualnej linii w bloku tekstu, stosujemy znak \ (backslash):

public class BlokiTekstuBezZnakuNowejLinii {
  public static void main(String[] args) {
    String jednaDlugaLinia = """
        Ten blok tekstu to tak naprawdę \
        jedna długa linia dzięki zastosowaniu \
        znaku backslash na końcach linii""";

    System.out.println(jednaDlugaLinia);
  }
}

Do zmiennej jednaDlugaLinia przypisany zostanie string bez znaków nowej linii:

Spacje znajdujące się na końcach linii bloków tekstu są domyślnie wycinane. Jeżeli chcemy, aby na końcu linii wyświetlona została spacja, to musimy w tej linii umieścić znacznik \s:

System.out.println("""
    Pierwsza linia.\s
    Druga linia."""
); // \s spowoduje, że na końcu pierwszej linii będzie spacja

Bloki tekstu stanowią dobry dodatek do języka Java, jednak pamiętaj, że są dostępne dopiero od jego 15 wersji.

Treść tego wpisu pochodzi z mojej książki „Java od podstaw – Tom1”. Jeżeli uczysz się programować, to ta książka jest dla Ciebie! Jest dostępna w moim oficjalnym sklepie.