0Pricing
Java Academy · Leçon

Remplacer avec des expressions régulières

replaceAll et références arrière

Remplacer avec des expressions régulières est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Remplacer avec une expression régulière

Les expressions régulières ne servent pas uniquement à rechercher : elles peuvent aussi transformer du texte. replaceAll remplace chaque correspondance par une chaîne de remplacement.

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("a1b22c333");
        System.out.println(m.replaceAll("#"));
    }
}

Raccourci String.replaceAll

String.replaceAll(regex, replacement) est une instruction concise pratique qui compile le pattern en interne.

public class Main {
    public static void main(String[] args) {
        String cleaned = "hello   world  again".replaceAll("\\s+", " ");
        System.out.println(cleaned);
    }
}

replaceFirst

replaceFirst remplace uniquement la première correspondance et laisse les suivantes inchangées.

public class Main {
    public static void main(String[] args) {
        String s = "cat cat cat".replaceFirst("cat", "dog");
        System.out.println(s);
    }
}

Références aux groupes dans les remplacements

Dans la chaîne de remplacement, $1, $2, etc. insèrent le texte capturé par ces groupes. Cela permet de réordonner ou de reformater le contenu correspondant.

public class Main {
    public static void main(String[] args) {
        String iso = "30/05/2026".replaceAll("(\\d{2})/(\\d{2})/(\\d{4})", "$3-$2-$1");
        System.out.println(iso);
    }
}

Références aux groupes nommés

Vous pouvez également référencer les groupes nommés dans le remplacement avec ${name}.

public class Main {
    public static void main(String[] args) {
        String r = "alice@example.com"
            .replaceAll("(?<user>\\w+)@(?<host>[\\w.]+)", "${user} at ${host}");
        System.out.println(r);
    }
}

Échapper le dollar et la barre oblique inverse

Comme $ et \ ont une signification particulière dans les remplacements, échappez un dollar littéral avec \$. Matcher.quoteReplacement les échappe pour vous.

import java.util.regex.Matcher;

public class Main {
    public static void main(String[] args) {
        String price = "100".replaceAll("\\d+", Matcher.quoteReplacement("$100"));
        System.out.println(price);
    }
}

Remplacements calculés avec la fonction replaceAll

Depuis Java 9, Matcher.replaceAll peut recevoir une fonction, ce qui vous permet de calculer chaque remplacement à partir de la correspondance.

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("a1 b2 c3");
        String out = m.replaceAll(mr -> String.valueOf(Integer.parseInt(mr.group()) * 10));
        System.out.println(out);
    }
}

Mettre les mots correspondants en majuscules

La forme fonctionnelle est particulièrement utile lorsque le remplacement dépend du texte correspondant, par exemple pour mettre chaque mot en majuscules.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("\\b\\w").matcher("hello there world");
        String title = m.replaceAll(mr -> mr.group().toUpperCase());
        System.out.println(title);
    }
}

appendReplacement et appendTail

Pour un contrôle total, utilisez une boucle avec find et construisez la sortie avec appendReplacement, puis appendTail. C’est la technique classique de bas niveau.

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("a1b2");
        StringBuilder sb = new StringBuilder();
        while (m.find()) {
            m.appendReplacement(sb, "[" + m.group() + "]");
        }
        m.appendTail(sb);
        System.out.println(sb);
    }
}

Références arrière dans le Pattern

Les références arrière dans le pattern (\1) correspondent au texte répété, ce qui est utile pour supprimer les mots doublés lors d’un remplacement.

public class Main {
    public static void main(String[] args) {
        String fixed = "the the end end".replaceAll("\\b(\\w+) \\1\\b", "$1");
        System.out.println(fixed);
    }
}

Supprimer les caractères indésirables

Une utilisation fréquente consiste à assainir l’entrée en remplaçant tout ce qui se trouve en dehors d’un ensemble autorisé par une chaîne vide.

public class Main {
    public static void main(String[] args) {
        String digits = "(555) 123-4567".replaceAll("[^0-9]", "");
        System.out.println(digits);
    }
}

Vérification rapide

Dans une chaîne de remplacement pour replaceAll, que signifie $2 ?

Récapitulatif

Vous avez transformé du texte avec des expressions régulières :

  • replaceAll et replaceFirst remplacent les correspondances ; String propose des raccourcis.
  • $1 / ${name} insèrent les groupes capturés dans les remplacements ; échappez un $ littéral avec \$ ou via quoteReplacement.
  • La forme fonctionnelle de replaceAll calcule les remplacements à partir de chaque correspondance.
  • appendReplacement et appendTail offrent un contrôle manuel total.

Questions Fréquemment Posées

La leçon « Remplacer avec des expressions régulières » est-elle gratuite ?

Oui — le texte complet de « Remplacer avec des expressions régulières » 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 « Remplacer avec des expressions régulières » ?

replaceAll et références arrière 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 4 sur 4.

Combien de temps prend la leçon « Remplacer avec des expressions régulières » ?

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