0Pricing
Java Academy · Leçon

Compiler des motifs

Pattern.compile et Matcher

Compiler des motifs est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

La paire motif et outil de concordance

Les expressions régulières de Java se trouvent dans java.util.regex. Un Pattern est une expression régulière compilée ; un Matcher applique ce motif à une entrée précise.

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

Compiler une fois et réutiliser souvent

Pattern.compile est relativement coûteux. Compilez un pattern une seule fois et réutilisez-le avec de nombreuses entrées plutôt que de le recompiler dans une boucle.

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

Échapper les barres obliques inverses en Java

Les jetons d’expression régulière comme \d nécessitent une barre oblique inverse, mais les chaînes Java utilisent également la barre oblique inverse pour les séquences d’échappement. Ainsi, dans le code source, vous écrivez \\d pour représenter l’expression régulière \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());
    }
}

Créer un Matcher

pattern.matcher(input) associe le pattern à une chaîne d’entrée et renvoie un nouvel objet Matcher qui suit la position.

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

Les objets Matcher conservent un état

Un Matcher contient un état modifiable (position actuelle, dernière correspondance). Créez un nouveau Matcher pour chaque entrée ; ne partagez pas le même entre plusieurs fils d’exécution.

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

Indicateur insensible à la casse

Passez les indicateurs comme deuxième argument à compile. Pattern.CASE_INSENSITIVE ignore la casse.

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

Combiner des indicateurs

Combinez les indicateurs avec l’opérateur OR bit à bit. Ici, nous ajoutons MULTILINE afin que les ancres correspondent à chaque ligne.

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

Le raccourci statique matches

Pattern.matches(regex, input) est une aide ponctuelle qui compile et effectue la vérification en un seul appel. C’est pratique, mais l’expression est recompilée à chaque utilisation.

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

Découper avec un Pattern

Un Pattern compilé peut découper des chaînes via split, en réutilisant efficacement la même expression régulière compilée.

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

Examiner le Pattern

pattern() renvoie la chaîne d’expression régulière d’origine et flags() renvoie les indicateurs actifs sous forme d’un int.

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

Les Pattern invalides lèvent une exception

Une expression régulière mal formée lève une PatternSyntaxException au moment de compile, ce qui vous permet de détecter les erreurs rapidement.

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

Vérification rapide

Pourquoi devriez-vous compiler une expression régulière fréquemment utilisée dans un champ Pattern statique ?

Récapitulatif

Vous avez compilé des patterns :

  • Pattern.compile construit un pattern réutilisable, immuable et adapté à une utilisation concurrente ; matcher l’associe à une entrée.
  • Échappez les barres obliques inverses des expressions régulières avec \\ dans le code source Java.
  • Les indicateurs comme CASE_INSENSITIVE et MULTILINE se combinent avec un OU bit à bit.
  • Matcher possède un état, alors créez-en un par entrée.

Questions Fréquemment Posées

La leçon « Compiler des motifs » est-elle gratuite ?

Oui — le texte complet de « Compiler des motifs » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Compiler des motifs » ?

Pattern.compile et Matcher Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Compiler des motifs » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Compiler des motifs
  2. Rechercher et faire correspondre
  3. Groupes de capture
  4. Remplacer avec des expressions régulières
← Retour à Java Academy