Puis-je remplacer des groupes dans Java regex?

Question

J'ai ce code, et je veux savoir, si je peux remplacer seulement les groupes (pas tous les modèles) dans Java regex. code:

//... 
Pattern p = Pattern.compile("(\\d).*(\\d)"); 
    String input = "6 example input 4"; 
    Matcher m = p.matcher(input); 
    if (m.find()) { 

     //Now I want replace group one ((\\d)) with number 
     //and group two (too (\\d)) with 1, but I don't know how. 

    } 

Answer 1

utilisation $n (où n est un chiffre) pour se référer à des sous-séquences capturées dans replaceFirst(...). Je suppose que vous vouliez remplacer le premier groupe par la chaîne littérale "numéro" et le deuxième groupe avec la valeur du premier groupe.

Pattern p = Pattern.compile("(\\d)(.*)(\\d)"); 
String input = "6 example input 4"; 
Matcher m = p.matcher(input); 
if (m.find()) { 
    // replace first number with "number" and second number with the first 
    String output = m.replaceFirst("number $3$1"); // number 46 
} 

Tenir compte (\D+) pour le deuxième groupe au lieu de (.*). * est un matcher gourmand, et va d'abord consommer le dernier chiffre. Le matcher devra alors faire marche arrière lorsqu'il aura réalisé que le dernier (\d) n'a rien à faire, avant qu'il puisse correspondre au chiffre final.

Answer 2

Ajouter un troisième groupe en ajoutant parens autour .*, puis remplacez le par "number" + m.group(2) + "1"-séquence. par exemple .:

String output = m.replaceFirst("number" + m.group(2) + "1"); 

Answer 3

Vous pouvez utiliser les méthodes matcher.start() et matcher.end() pour obtenir les positions de groupe. Donc, en utilisant ces positions, vous pouvez facilement remplacer n'importe quel texte.

Answer 4

Vous pouvez utiliser Matcher#start(group) et Matcher#end(group) pour construire une méthode de remplacement générique:

public static String replaceGroup(String regex, String source, int groupToReplace, String replacement) { 
    return replaceGroup(regex, source, groupToReplace, 1, replacement); 
} 

public static String replaceGroup(String regex, String source, int groupToReplace, int groupOccurrence, String replacement) { 
    Matcher m = Pattern.compile(regex).matcher(source); 
    for (int i = 0; i < groupOccurrence; i++) 
     if (!m.find()) return source; // pattern not met, may also throw an exception here 
    return new StringBuilder(source).replace(m.start(groupToReplace), m.end(groupToReplace), replacement).toString(); 
} 

public static void main(String[] args) { 
    // replace with "%" what was matched by group 1 
    // input: aaa123ccc 
    // output: %123ccc 
    System.out.println(replaceGroup("([a-z]+)([0-9]+)([a-z]+)", "aaa123ccc", 1, "%")); 

    // replace with "!!!" what was matched the 4th time by the group 2 
    // input: a1b2c3d4e5 
    // output: a1b2c3d!!!e5 
    System.out.println(replaceGroup("([a-z])(\\d)", "a1b2c3d4e5", 2, 4, "!!!")); 
} 

Vérifier online demo here.

Answer 5

Voici une solution différente, qui permet également le remplacement d'un seul groupe dans plusieurs correspondances. Il utilise des piles pour inverser l'ordre d'exécution, de sorte que l'opération de chaîne peut être exécutée en toute sécurité.

private static void demo() { 

    final String sourceString = "hello world!"; 

    final String regex = "(hello) (world)(!)"; 
    final Pattern pattern = Pattern.compile(regex); 

    String result = replaceTextOfMatchGroup(sourceString, pattern, 2, world -> world.toUpperCase()); 
    System.out.println(result); // output: hello WORLD! 
} 

public static String replaceTextOfMatchGroup(String sourceString, Pattern pattern, int groupToReplace, Function<String,String> replaceStrategy) { 
    Stack<Integer> startPositions = new Stack<>(); 
    Stack<Integer> endPositions = new Stack<>(); 
    Matcher matcher = pattern.matcher(sourceString); 

    while (matcher.find()) { 
     startPositions.push(matcher.start(groupToReplace)); 
     endPositions.push(matcher.end(groupToReplace)); 
    } 
    StringBuilder sb = new StringBuilder(sourceString); 
    while (! startPositions.isEmpty()) { 
     int start = startPositions.pop(); 
     int end = endPositions.pop(); 
     if (start >= 0 && end >= 0) { 
      sb.replace(start, end, replaceStrategy.apply(sourceString.substring(start, end))); 
     } 
    } 
    return sb.toString();  
} 

Answer 6

Désolé de battre un cheval mort, mais il est de type de bizarre que faire-on fait remarquer ceci - « Oui, vous pouvez, mais cela est à l'opposé de la façon dont vous utilisez la capture des groupes dans la vie réelle ».

Si vous utilisez Regex la façon dont il est destiné à être utilisé, la solution est aussi simple que cela:

"6 example input 4".replaceAll("(?:\\d)(.*)(?:\\d)", "number$11"); 

Vous n'utilisez généralement pas capture groupes sur les parties de la chaîne que vous voulez à ignorer, vous les utilisez sur la partie de la chaîne que vous voulez garder.

Si vous voulez vraiment des groupes que vous voulez remplacer, ce que vous voulez probablement un type de moteur de modèle (par exemple, moustache, express.js, StringTemplate, ...).