remplacer le groupe de capture

Si j'ai une regex avec une capture d'un groupe, par exemple foo(_+f). Si je correspond à ce contre une chaîne de caractères et souhaitez remplacer la première capture d'un groupe à tous les matches avec baz de sorte que

foo___f blah foo________f

est converti à:

foobaz blah foobaz

Il ne semble pas être un moyen facile de faire cela en utilisant les bibliothèques standard. Si j'utilise Matcher.replaceAll() ce sera de remplacer tous les matches de l'ensemble du motif et de convertir la chaîne de

baz blah baz

Évidemment, je peux juste faire une itération sur les matchs, de stocker le début et la fin de l'index de chaque capture d'un groupe, puis revenir en arrière et de les remplacer, mais est-il un moyen plus facile?

Grâce,
Ne

source d'informationauteur Dónal

  1. 25

    Je pense que vous voulez quelque chose de ce genre?

        System.out.println(
        "foo__f blah foo___f boo___f".replaceAll("(?<=foo)_+f", "baz")
    ); //prints "foobaz blah foobaz boo___f"

    Ici, il vous suffit de remplacer l'ensemble du match avec "baz"mais le match utilise lookbehind pour s'assurer que _+f est précédée par foo.

    Voir aussi

    Si lookbehind n'est pas possible (peut-être parce que la longueur n'est pas fini), puis il suffit de capturer ce que vous n'êtes PAS remplacer, et vous y reporter en arrière dans la chaîne de remplacement.

        System.out.println(
        "fooooo_f boooo_f xxx_f".replaceAll("(fo+|bo+)(_+f)", "$1baz")
    ); //prints "fooooobaz boooobaz xxx_f"

    Donc, ici, nous sommes, en fait, uniquement le remplacement de ce \2 matchs.

  2. 4

    Donc je ne pense pas qu'aucune de ces réponses ne sont justice plus abstraits cas de la question suivante, qui est quelque chose que je suis tombé sur moi-même, j'ai donc écrit un code qui fonctionne dans le cas plus général:

    /**
 * 
 * @param regex  Pattern to find in oldLine. Will replace contents in ( ... ) - group(1) - with newValue
 * @param oldLine  Previous String that needs replacing
 * @param newValue  Value that will replace the captured group(1) in regex
 * @return
 */
public static String replace(String regex, String oldLine, String newValue)
{
    Pattern p = Pattern.compile(regex);
    Matcher m = p.matcher(oldLine);
    if (m.find())
    {
        return m.replaceAll(replaceGroup(regex, newValue));
    }
    else
    {
        throw new RuntimeException("No match");
    }
}

/**
 * Replaces group(1) ( ... ) with replacement, and returns the resulting regex with replacement String
 * @param regex  Regular expression whose parenthetical group will be literally replaced by replacement
 * @param replacement  Replacement String
 * @return
 */
public static String replaceGroup(String regex, String replacement)
{
    return regex.replaceAll("\\(.*\\)", replacement);
}

    Sur votre exemple, il ne fait précisément que vous le décrivez:

    String regex = "foo(_+f)";
String line = "foo___f blah foo________f";
System.out.println(FileParsing.replace(regex, line, "baz"));

    Imprime:

    foobaz blah foobaz
  3. 1
    p = Pattern.compile("foo(g.*?f)");
m = p.matcher("foog___f blah foog________f");
s = m.replaceAll("foobaz");//replace with foobaz instead of just baz
System.out.println(s);//foobaz blah foobaz
  4. 0

    Est-ce n'importe où près ....

    String[] s = {"foo___f blah foo________f", 
    "foo___f blah goo________f"};
for(String ss: s)
System.out.println(ss.replaceAll("(foo)(_+)f", "$1baz"));

    C'est à dire, ajouter une capture d'un groupe de 'foo' également. Sinon, un simple remplacement serait 

    "foo___f blah foo________f".replaceAll("(_+)f", "baz")