0Pricing
Java Academy · Lekcja

Zastępowanie za pomocą wyrażeń regularnych

replaceAll i odwołania wsteczne

Zastępowanie za pomocą wyrażeń regularnych to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 4 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.

Zastępowanie za pomocą regexu

Regex służy nie tylko do wyszukiwania; może również przekształcać tekst. replaceAll zamienia każde dopasowanie na napis zastępczy.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("\\d+").matcher("a1b22c333");
        System.out.println(m.replaceAll("#"));
    }
}

Skrótowa metoda String.replaceAll

String.replaceAll(regex, replacement) to wygodne wywołanie jednolinijkowe, które wewnętrznie kompiluje wzorzec.

public class Main {
    public static void main(String[] args) {
        String cleaned = "hello   world  again".replaceAll("\\s+", " ");
        System.out.println(cleaned);
    }
}

replaceFirst

replaceFirst zamienia tylko pierwsze dopasowanie, pozostawiając późniejsze bez zmian.

public class Main {
    public static void main(String[] args) {
        String s = "cat cat cat".replaceFirst("cat", "dog");
        System.out.println(s);
    }
}

Odwołania do grup w zastąpieniach

W napisie zastępującym elementy $1, $2 itd. wstawiają tekst przechwycony przez odpowiednie grupy. Umożliwia to zmianę kolejności lub formatowanie dopasowanej treści.

public class Main {
    public static void main(String[] args) {
        String iso = "30/05/2026".replaceAll("(\\d{2})/(\\d{2})/(\\d{4})", "$3-$2-$1");
        System.out.println(iso);
    }
}

Odwołania do grup nazwanych

Do grup nazwanych w zastąpieniu można również odwoływać się za pomocą ${name}.

public class Main {
    public static void main(String[] args) {
        String r = "alice@example.com"
            .replaceAll("(?<user>\\w+)@(?<host>[\\w.]+)", "${user} at ${host}");
        System.out.println(r);
    }
}

Escapowanie znaku dolara i ukośnika odwrotnego

Ponieważ znaki $ i \ mają specjalne znaczenie w zastąpieniach, literał dolara należy zapisać jako \$. Matcher.quoteReplacement wykonuje escapowanie tych znaków automatycznie.

import java.util.regex.Matcher;

public class Main {
    public static void main(String[] args) {
        String price = "100".replaceAll("\\d+", Matcher.quoteReplacement("$100"));
        System.out.println(price);
    }
}

Obliczane zastąpienia za pomocą funkcji replaceAll

Od wersji Java 9 metoda Matcher.replaceAll może przyjmować funkcję, co pozwala obliczać każde zastąpienie na podstawie dopasowania.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("\\d+").matcher("a1 b2 c3");
        String out = m.replaceAll(mr -> String.valueOf(Integer.parseInt(mr.group()) * 10));
        System.out.println(out);
    }
}

Zamiana dopasowanych słów na wielkie litery

Wariant funkcyjny jest szczególnie przydatny, gdy zastąpienie zależy od dopasowanego tekstu, na przykład podczas zamiany każdego słowa na wielkie litery.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("\\b\\w").matcher("hello there world");
        String title = m.replaceAll(mr -> mr.group().toUpperCase());
        System.out.println(title);
    }
}

appendReplacement i appendTail

Aby uzyskać pełną kontrolę, należy użyć pętli z find i zbudować wynik za pomocą metod appendReplacement, a następnie appendTail. Jest to klasyczna technika niskopoziomowa.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("\\d+").matcher("a1b2");
        StringBuilder sb = new StringBuilder();
        while (m.find()) {
            m.appendReplacement(sb, "[" + m.group() + "]");
        }
        m.appendTail(sb);
        System.out.println(sb);
    }
}

Odwołania wsteczne we wzorcu

Odwołania wsteczne we wzorcu (\1) dopasowują powtórzony tekst i przydają się na przykład do usuwania podwojonych słów podczas zastępowania.

public class Main {
    public static void main(String[] args) {
        String fixed = "the the end end".replaceAll("\\b(\\w+) \\1\\b", "$1");
        System.out.println(fixed);
    }
}

Usuwanie niepożądanych znaków

Częstym zastosowaniem jest oczyszczanie danych wejściowych przez zastąpienie pustym tekstem wszystkiego, co nie należy do dozwolonego zbioru.

public class Main {
    public static void main(String[] args) {
        String digits = "(555) 123-4567".replaceAll("[^0-9]", "");
        System.out.println(digits);
    }
}

Szybkie sprawdzenie

Co oznacza $2 w napisie zastępującym używanym przez replaceAll?

Podsumowanie

Przekształcono tekst za pomocą regexu:

  • replaceAll i replaceFirst zamieniają dopasowania; klasa String udostępnia skrótowe metody.
  • $1 / ${name} wstawiają przechwycone grupy do zastąpień; literał $ należy escapować jako \$ lub za pomocą quoteReplacement.
  • Wariant funkcyjny metody replaceAll oblicza zastąpienia na podstawie każdego dopasowania.
  • appendReplacement i appendTail zapewniają pełną ręczną kontrolę.

Często zadawane pytania

Czy lekcja „Zastępowanie za pomocą wyrażeń regularnych” jest bezpłatna?

Tak — pełny tekst „Zastępowanie za pomocą wyrażeń regularnych” 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 „Zastępowanie za pomocą wyrażeń regularnych”?

replaceAll i odwołania wsteczne Ć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 4 z 4.

Ile czasu zajmuje lekcja „Zastępowanie za pomocą wyrażeń regularnych”?

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. Kompilowanie wzorców
  2. Wyszukiwanie i dopasowywanie
  3. Grupy przechwytujące
  4. Zastępowanie za pomocą wyrażeń regularnych
← Powrót do Java Academy