Java Academy · Lektion

Suchen und Abgleichen

matches, find, lookingAt

Suchen und Abgleichen ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Drei Möglichkeiten, ein Pattern anzuwenden

Matcher bietet drei grundlegende Tests:

matches() erfordert, dass die gesamte Eingabe übereinstimmt.
lookingAt() erfordert eine Übereinstimmung am Anfang.
find() sucht nach einer Übereinstimmung an beliebiger Stelle.

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("42");
        System.out.println(m.matches());
    }
}

matches: gesamte Eingabe

matches gibt nur dann true zurück, wenn der gesamte String dem Pattern entspricht, als wäre er an beiden Enden verankert.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("\\d+");
        System.out.println(p.matcher("123").matches());
        System.out.println(p.matcher("123abc").matches());
    }
}

lookingAt: Übereinstimmung am Anfang

lookingAt ist erfolgreich, wenn die Eingabe mit einer Übereinstimmung beginnt, auch wenn der Rest nicht übereinstimmt.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("\\d+");
        System.out.println(p.matcher("123abc").lookingAt());
        System.out.println(p.matcher("abc123").lookingAt());
    }
}

find: Übereinstimmung an beliebiger Stelle

find durchsucht die Eingabe ab der aktuellen Position nach der nächsten Übereinstimmung. Es gibt true zurück, wenn ab dieser Position eine Übereinstimmung existiert.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("\\d+");
        System.out.println(p.matcher("abc123def").find());
    }
}

Mit find alle Übereinstimmungen durchlaufen

Wenn Sie find in einer Schleife aufrufen, durchlaufen Sie jede Übereinstimmung in der Eingabe.

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("a1bb22ccc333");
        while (m.find()) {
            System.out.println(m.group());
        }
    }
}

Positionen einer Übereinstimmung: start und end

Nach einer erfolgreichen Übereinstimmung geben start() und end() den Indexbereich an, und group() gibt den übereinstimmenden Text zurück.

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("abc123");
        if (m.find()) {
            System.out.println(m.group() + " at [" + m.start() + "," + m.end() + ")");
        }
    }
}

Anker mit find

Mit den Ankern ^ und $ kann sich find wie eine Prüfung von Anfang oder Ende verhalten. Hier findet ^\d+ nur Ziffern ganz am Anfang.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("^\\d+");
        System.out.println(p.matcher("123abc").find());
        System.out.println(p.matcher("abc123").find());
    }
}

Einen Matcher zurücksetzen

reset() setzt den Matcher an den Anfang zurück, sodass Sie dieselbe Eingabe erneut durchsuchen können.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("a").matcher("aaa");
        int first = 0;
        while (m.find()) first++;
        m.reset();
        int second = 0;
        while (m.find()) second++;
        System.out.println(first + " " + second);
    }
}

Einen Matcher für eine neue Eingabe wiederverwenden

reset(newInput) verwendet dasselbe Matcher-Objekt mit einem anderen String wieder und vermeidet dadurch eine neue Speicherbelegung.

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("abc");
        m.reset("xyz789");
        System.out.println(m.find());
        System.out.println(m.group());
    }
}

Zusammenfassung: matches und find

Wählen Sie die Methode nach ihrer Absicht: Verwenden Sie matches, um einen vollständigen Wert zu validieren, etwa eine komplette ID, und find, um Teile in einem größeren Text zu extrahieren oder zu finden.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern id = Pattern.compile("[A-Z]{2}\\d{4}");
        System.out.println(id.matcher("AB1234").matches());
        System.out.println(id.matcher("id=AB1234;").find());
    }
}

Übereinstimmungen zählen

Eine häufige Aufgabe ist das Zählen von Vorkommen. Durchlaufen Sie find in einer Schleife und erhöhen Sie einen Zähler.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("o").matcher("foo boo zoo");
        int count = 0;
        while (m.find()) count++;
        System.out.println(count);
    }
}

Kurze Überprüfung

Welche Methode erfordert, dass der gesamte Eingabestring mit dem Pattern übereinstimmt?

Zusammenfassung

Sie haben Übereinstimmungen gefunden:

matches prüft die gesamte Eingabe, lookingAt den Anfang und find sucht an beliebiger Stelle.
Durchlaufen Sie find in einer Schleife, um alle Übereinstimmungen zu durchlaufen, und lesen Sie group, start und end aus.
reset setzt den Matcher zurück, und reset(input) verwendet ihn für einen neuen Text wieder.

Häufig gestellte Fragen

Ist die Lektion „Suchen und Abgleichen“ kostenlos?

Ja — der vollständige Text von „Suchen und Abgleichen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Suchen und Abgleichen“?

matches, find, lookingAt Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Suchen und Abgleichen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Java Academy