Java Academy · Lektion

Söka och matcha

matches, find, lookingAt.

Lektion 2 av 413 steg

Söka och matcha är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 4 lektioner.

Tre sätt att tillämpa ett mönster

Matcher erbjuder tre grundläggande tester:

matches() kräver att hela indatan matchar.
lookingAt() kräver en matchning i början.
find() söker efter en matchning var som helst.

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: Hela indatan

matches returnerar true endast om hela strängen följer mönstret, som om den hade ankare i båda ändarna.

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: Matchning i början

lookingAt lyckas om indatan börjar med en matchning, även om resten inte matchar.

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: Matchning var som helst

find söker framåt efter nästa matchning. Metoden returnerar true om det finns en matchning från den aktuella positionen och framåt.

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

Iterera över alla matchningar med find

Genom att anropa find i en loop går du igenom varje matchning i indatan.

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

Matchningspositioner: start och end

Efter en lyckad matchning anger start() och end() indexintervallet, och group() ger den matchade texten.

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() + ")");
        }
    }
}

Ankare med find

Med ankarna ^ och $ kan find fungera som kontroller av början och slutet. Här matchar ^\d+ endast siffror allra först.

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

Återställ en Matcher

reset() spolar tillbaka matchern till början, så att du kan söka igenom samma indata på nytt.

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

Återanvänd en Matcher med ny indata

reset(newInput) återanvänder samma matcherobjekt med en annan sträng och undviker en ny allokering.

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

Sammanfattning av matches och find

Välj utifrån avsikten: använd matches för att validera ett helt värde, till exempel ett helt ID, och find för att extrahera eller hitta delar i en större text.

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

Räkna matchningar

Att räkna förekomster är en vanlig uppgift. Loopa över find och öka en räknare.

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

Snabb kontroll

Vilken metod kräver att hela indatasträngen matchar mönstret?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Du hittade matchningar:

matches testar hela indatan, lookingAt testar början och find söker var som helst.
Loopa över find för att iterera över alla matchningar och läsa group, start och end.
reset spolar tillbaka, och reset(input) återanvänder matchern med ny text.

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 104
Lektioner: 374

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Söka och matcha” gratis?

Ja – hela texten till ”Söka och matcha” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Söka och matcha”?

matches, find, lookingAt. Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Java Academy?

Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Söka och matcha”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Java Academy-lektionen?

Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Java Academy