Java regex'indeki grupları değiştirebilir miyim?

Bu koda sahibim ve Java regex'te yalnızca grupları (tüm kalıbı değil) değiştirip değiştiremeyeceğimi bilmek istiyorum. Kod:

 //...
 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.

    }

İçinde $nyakalanan alt dizileri belirtmek için (burada n bir rakamdır) kullanın replaceFirst(...). İlk grubu "sayı" harf dizisiyle ve ikinci grubu birinci grubun değeriyle değiştirmek istediğinizi varsayıyorum .

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
}

(\D+)Bunun yerine ikinci grubu düşünün (.*). *açgözlü bir eşleştiricidir ve ilk başta son rakamı tüketir. Eşleştirici (\d), finalin son rakamla eşleşmeden önce eşleşecek hiçbir şeyi olmadığını anladığında geri adım atmak zorunda kalacaktır .

Genel bir değiştirme yöntemi oluşturmak için Matcher#start(group)ve kullanabilirsiniz Matcher#end(group):

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

Çevrimiçi demoyu buradan kontrol edin .

Ölü bir atı dövdüğüm için özür dilerim, ama hiç kimsenin buna işaret etmemesi biraz garip - "Evet yapabilirsin, ama bu gerçek hayatta grupları yakalama şeklinin tam tersi".

Regex'i kullanılması gerektiği gibi kullanırsanız, çözüm şu kadar basittir:

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

Veya aşağıdaki shmosel'in haklı olarak işaret ettiği gibi,

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

... normal ifadenizde ondalık sayıları gruplamak için iyi bir neden olmadığından.

Genellikle dizinin atmak istediğiniz kısımlarında yakalama grupları kullanmazsınız, onları dizenin tutmak istediğiniz kısmında kullanırsınız .

Değiştirmek istediğiniz grupları gerçekten istiyorsanız, muhtemelen bunun yerine bir şablon oluşturma motorudur (örn. Bıyık, ejs, StringTemplate, ...).

Meraklılar için bir kenara olarak, normal ifadelerdeki yakalamayan gruplar bile, normal ifade motorunun değişken metni tanıması ve atlaması için ihtiyaç duyduğu durum için oradadır. Örneğin,

(?:abc)*(capture me)(?:bcd)*

girişinizi ya "abcabc'ait benzeyebilir eğer onlara ihtiyaç beni yakalama bcdbcd" veya "abc beni yakalama bcd" hatta sadece "yakalama bana".

Ya da başka bir deyişle: Metin her zaman aynıysa ve onu yakalayamazsanız, grupları kullanmak için hiçbir neden yoktur.

Etrafına parantez ekleyerek üçüncü bir grup ekleyin .*, ardından alt diziyi ile değiştirin "number" + m.group(2) + "1". Örneğin:

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

Grup konumlarını almak için matcher.start () ve matcher.end () yöntemlerini kullanabilirsiniz. Dolayısıyla, bu konumları kullanarak herhangi bir metni kolayca değiştirebilirsiniz.

girişteki şifre alanlarını değiştirin:

{"_csrf":["9d90c85f-ac73-4b15-ad08-ebaa3fa4a005"],"originPassword":["uaas"],"newPassword":["uaas"],"confirmPassword":["uaas"]}



  private static final Pattern PATTERN = Pattern.compile(".*?password.*?\":\\[\"(.*?)\"\\](,\"|}$)", Pattern.CASE_INSENSITIVE);

  private static String replacePassword(String input, String replacement) {
    Matcher m = PATTERN.matcher(input);
    StringBuffer sb = new StringBuffer();
    while (m.find()) {
      Matcher m2 = PATTERN.matcher(m.group(0));
      if (m2.find()) {
        StringBuilder stringBuilder = new StringBuilder(m2.group(0));
        String result = stringBuilder.replace(m2.start(1), m2.end(1), replacement).toString();
        m.appendReplacement(sb, result);
      }
    }
    m.appendTail(sb);
    return sb.toString();
  }

  @Test
  public void test1() {
    String input = "{\"_csrf\":[\"9d90c85f-ac73-4b15-ad08-ebaa3fa4a005\"],\"originPassword\":[\"123\"],\"newPassword\":[\"456\"],\"confirmPassword\":[\"456\"]}";
    String expected = "{\"_csrf\":[\"9d90c85f-ac73-4b15-ad08-ebaa3fa4a005\"],\"originPassword\":[\"**\"],\"newPassword\":[\"**\"],\"confirmPassword\":[\"**\"]}";
    Assert.assertEquals(expected, replacePassword(input, "**"));
  }

İşte tek bir grubun birden çok maçta değiştirilmesine de izin veren farklı bir çözüm. Yürütme sırasını tersine çevirmek için yığınları kullanır, böylece dize işlemi güvenli bir şekilde yürütülebilir.

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