Java Academy · Lektion

Kompilera mönster

Pattern.compile och Matcher.

Lektion 1 av 413 steg

Kompilera mönster är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 1 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.

Paret Pattern och Matcher

Javas reguljära uttryck finns i java.util.regex. En Pattern är ett kompilerat reguljärt uttryck, medan en Matcher tillämpar mönstret på en specifik indata.

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

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

Kompilera en gång, återanvänd ofta

Pattern.compile är relativt kostsamt. Kompilera ett mönster en gång och återanvänd det för många indata i stället för att kompilera om det i en loop.

import java.util.regex.Pattern;

public class Main {
    static final Pattern DIGITS = Pattern.compile("\\d+");

    public static void main(String[] args) {
        System.out.println(DIGITS.matcher("a1").find());
        System.out.println(DIGITS.matcher("bb").find());
    }
}

Escapning av backslash i Java

Regex-token som \d kräver ett backslash, men Java-strängar använder också backslash för escapning. Därför skriver du \\d i källkoden för att beteckna regexen \d.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern word = Pattern.compile("\\w+");
        System.out.println(word.matcher("hello").matches());
    }
}

Skapa en Matcher

pattern.matcher(input) kopplar mönstret till en indatasträng och returnerar en ny Matcher som håller reda på positionen.

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

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("cat");
        Matcher m = p.matcher("the cat sat");
        System.out.println(m.find());
    }
}

Matchers är tillståndsfulla

En Matcher innehåller föränderligt tillstånd (aktuell position, senaste matchning). Skapa en ny matcher för varje indata och dela inte en matcher mellan trådar.

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

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

Flaggan för skiftlägesokänslighet

Ange flaggor som det andra argumentet till compile. Pattern.CASE_INSENSITIVE ignorerar skillnaden mellan versaler och gemener.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("java", Pattern.CASE_INSENSITIVE);
        System.out.println(p.matcher("I love JAVA").find());
    }
}

Kombinera flaggor

Kombinera flaggor med den bitvisa OR-operatorn. Här lägger vi till MULTILINE så att ankare matchar på varje rad.

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

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("^a", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);
        Matcher m = p.matcher("apple\nApricot");
        int count = 0;
        while (m.find()) count++;
        System.out.println(count);
    }
}

Den statiska genvägen matches

Pattern.matches(regex, input) är en hjälpfunktion för engångsanvändning som kompilerar och testar i ett enda anrop. Det är praktiskt, men mönstret kompileras om varje gång.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        System.out.println(Pattern.matches("\\d{3}", "123"));
        System.out.println(Pattern.matches("\\d{3}", "12"));
    }
}

Dela upp med en Pattern

En kompilerad Pattern kan dela upp strängar med split och återanvända samma kompilerade regex effektivt.

import java.util.Arrays;
import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern comma = Pattern.compile("\\s*,\\s*");
        String[] parts = comma.split("a, b ,c,  d");
        System.out.println(Arrays.toString(parts));
    }
}

Inspektera mönstret

pattern() returnerar den ursprungliga regexsträngen och flags() returnerar de aktiva flaggorna som ett heltal.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("[a-z]+", Pattern.CASE_INSENSITIVE);
        System.out.println(p.pattern());
        System.out.println(p.flags());
    }
}

Ogiltiga mönster kastar undantag

En felaktigt formaterad regex kastar PatternSyntaxException vid compile, så att du kan upptäcka fel tidigt.

import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;

public class Main {
    public static void main(String[] args) {
        try {
            Pattern.compile("[unclosed");
        } catch (PatternSyntaxException e) {
            System.out.println("Invalid regex");
        }
    }
}

Snabb kontroll

Varför bör du kompilera en ofta använd regex till ett statiskt Pattern-fält?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Du kompilerade mönster:

Pattern.compile skapar ett återanvändbart, oföränderligt och trådsäkert mönster; matcher kopplar det till en indata.
Escapa backslash i regex med \\ i Java-källkod.
Flaggor som CASE_INSENSITIVE och MULTILINE kombineras med bitvis OR.
Matcher är tillståndsfull, så skapa en per indata.

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 ”Kompilera mönster” gratis?

Ja – hela texten till ”Kompilera mönster” 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 ”Kompilera mönster”?

Pattern.compile och Matcher. 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 1 av 4.

Hur lång tid tar lektionen ”Kompilera mönster”?

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