Java Academy · Lekcja

Sekwencje escape w blokach tekstowych

Używaj nowych sekwencji escape

Sekwencje escape w blokach tekstowych 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.

Nowe sekwencje escape dla bloków tekstowych

Bloki tekstowe obsługują wszystkie zwykłe sekwencje escape oraz dwie nowe, zaprojektowane specjalnie z myślą o nich: kontynuację wiersza \ i jawną spację \s. Zapewniają one precyzyjną kontrolę nad danymi wyjściowymi.

Kontynuacja wiersza za pomocą odwrotnego ukośnika

Zakończenie wiersza znakiem \ informuje Javę, aby nie wstawiała w tym miejscu znaku nowej linii. Następny wiersz zostaje dołączony do bieżącego. Umożliwia to zawijanie długich wierszy logicznych w celu poprawy czytelności.

public class Main {
    public static void main(String[] args) {
        String text = """
            This is one \
            single long line.
            """;
        System.out.print(text);
    }
}

Dlaczego kontynuacja wiersza jest przydatna

Można sformatować kod źródłowy w kilku wierszach fizycznych, jednocześnie tworząc jeden wiersz wynikowy. Jest to przydatne w przypadku długich zdań lub adresów URL.

public class Main {
    public static void main(String[] args) {
        String url = """
            https://example.com/\
            path/to/\
            resource
            """;
        System.out.print(url);
    }
}

Sekwencja spacji \s

Końcowe spacje są zwykle usuwane. Sekwencja escape \s wstawia dosłowną spację, która przetrwa usuwanie, dzięki czemu można zachować znaczące końcowe białe znaki.

public class Main {
    public static void main(String[] args) {
        String text = """
            red  \s
            green\s
            """;
        for (String line : text.split("\n")) {
            System.out.println("|" + line + "|");
        }
    }
}

Zachowywanie wyrównania kolumn

\s jest przydatne w tabelach o stałej szerokości, w których końcowe spacje mają znaczenie dla wyrównania.

public class Main {
    public static void main(String[] args) {
        String table = """
            NAME\s\s\sAGE
            Alice\s\s30
            """;
        System.out.print(table);
    }
}

Standardowe sekwencje escape nadal działają

Klasyczne sekwencje escape, takie jak \t oznaczająca tabulator i \n oznaczająca znak nowej linii, działają również wewnątrz bloków tekstowych.

public class Main {
    public static void main(String[] args) {
        String text = """
            Col1\tCol2
            A\tB
            """;
        System.out.print(text);
    }
}

Escapowanie potrójnych cudzysłowów

Aby umieścić wewnątrz bloku tekstowego trzy następujące po sobie cudzysłowy, należy poprzedzić co najmniej jeden z nich sekwencją \", aby nie został pomylony z zamykającym ogranicznikiem.

public class Main {
    public static void main(String[] args) {
        String text = """
            He said \"\"\" loudly.
            """;
        System.out.print(text);
    }
}

Dosłowny odwrotny ukośnik

Aby umieścić w danych wyjściowych rzeczywisty odwrotny ukośnik, należy zapisać \\, dokładnie tak jak w zwykłych napisach. Ma to znaczenie w przypadku ścieżek systemu Windows lub wzorców wyrażeń regularnych.

public class Main {
    public static void main(String[] args) {
        String path = """
            C:\\Users\\Alice
            """;
        System.out.print(path);
    }
}

Łączenie kontynuacji wiersza i \s

Można łączyć obie nowe sekwencje escape. W tym przypadku kontynuacja łączy wiersze, a \s zapewnia spację w miejscu ich połączenia.

public class Main {
    public static void main(String[] args) {
        String sentence = """
            Hello\s\
            World
            """;
        System.out.print(sentence);
    }
}

Unikanie przypadkowych znaków nowej linii

Bez kontynuacji każde przejście do nowego wiersza w kodzie źródłowym staje się znakiem nowej linii. Dodanie \ na końcu wiersza usuwa ten znak, zapewniając pełną kontrolę nad miejscem podziału wierszy.

public class Main {
    public static void main(String[] args) {
        String joined = """
            part1\
            part2\
            part3
            """;
        System.out.println(joined);
    }
}

Pojedynczy cudzysłów nie wymaga escapowania

Wewnątrz bloku tekstowego pojedynczy znak cudzysłowu " nie stanowi problemu. Uwagę trzeba poświęcić tylko sekwencjom, które mogłyby utworzyć zamykający """.

public class Main {
    public static void main(String[] args) {
        String quote = """
            She said "hi" to me.
            """;
        System.out.print(quote);
    }
}

Szybkie sprawdzenie

Co powoduje zakończenie wiersza bloku tekstowego pojedynczym odwrotnym ukośnikiem \?

Podsumowanie

Omówiono sekwencje escape w blokach tekstowych:

\ na końcu wiersza = kontynuacja wiersza (brak znaku nowej linii)
\s = spacja, która przetrwa usuwanie końcowych białych znaków
Standardowe sekwencje \t, \n i \\ nadal działają
Aby umieścić """, należy poprzedzić cudzysłów sekwencją escape
Pojedynczy znak " nie wymaga escapowania

Często zadawane pytania

Czy lekcja „Sekwencje escape w blokach tekstowych” jest bezpłatna?

Tak — pełny tekst „Sekwencje escape w blokach tekstowych” 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 „Sekwencje escape w blokach tekstowych”?

Używaj nowych sekwencji escape Ć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 „Sekwencje escape w blokach tekstowych”?

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

← Powrót do Java Academy