0Pricing
Java Academy · Leçon

Rechercher et faire correspondre

matches, find, lookingAt

Rechercher et faire correspondre est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

Trois façons d’appliquer un Pattern

Matcher propose trois vérifications principales :

  • matches() exige que la totalité de l’entrée corresponde.
  • lookingAt() exige une correspondance au début.
  • find() recherche une correspondance n’importe où.
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 : entrée complète

matches renvoie true uniquement si la chaîne entière respecte le pattern, comme si elle était encadrée par des ancres aux deux extrémités.

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 : correspondance au début

lookingAt réussit si l’entrée commence par une correspondance, même si le reste ne correspond pas.

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 : correspondance n’importe où

find parcourt l’entrée vers l’avant à la recherche de la prochaine correspondance. Il renvoie true s’il en existe une à partir de la position actuelle.

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

Parcourir toutes les correspondances avec find

Appeler find dans une boucle parcourt toutes les correspondances présentes dans l’entrée.

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

Positions des correspondances : start et end

Après une correspondance réussie, start() et end() fournissent l’intervalle d’indices, tandis que group() fournit le texte correspondant.

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

Ancres avec find

Les ancres ^ et $ permettent à find de se comporter comme une vérification du début ou de la fin. Ici, ^\d+ ne correspond qu’aux chiffres situés tout au début.

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

Réinitialiser un Matcher

reset() ramène le Matcher au début afin que vous puissiez parcourir à nouveau la même entrée.

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

Réutiliser un Matcher avec une nouvelle entrée

reset(newInput) réutilise le même objet Matcher avec une chaîne différente, ce qui évite une nouvelle allocation.

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

Résumé de matches et find

Choisissez selon votre objectif : utilisez matches pour valider une valeur complète, comme un ID entier, et find pour extraire ou localiser des parties dans un texte plus long.

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

Compter les correspondances

Compter les occurrences est une tâche courante. Parcourez find dans une boucle et incrémentez un compteur.

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

Vérification rapide

Quelle méthode exige que la chaîne d’entrée entière corresponde au pattern ?

Récapitulatif

Vous avez localisé des correspondances :

  • matches vérifie toute l’entrée ; lookingAt vérifie le début ; find recherche n’importe où.
  • Utilisez find dans une boucle pour parcourir toutes les correspondances et lire group, start et end.
  • reset revient au début, et reset(input) réutilise le Matcher avec un nouveau texte.

Questions Fréquemment Posées

La leçon « Rechercher et faire correspondre » est-elle gratuite ?

Oui — le texte complet de « Rechercher et faire correspondre » 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 « Rechercher et faire correspondre » ?

matches, find, lookingAt 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 2 sur 4.

Combien de temps prend la leçon « Rechercher et faire correspondre » ?

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