替换 java 或 kotlin 上的特定（不是所有匹配项）正则表达式匹配项

Question

例如，我在正则表达式替换系统中有不同的正则表达式

"([e][u][r])+" = "euros"
"([e][u][r][o][s])+" = "currency"

但我想替换：

 1. The longest match for all the regex occurrences if more than 2 regex are true for the same part of text
 2. Just apply one time a rule for a part of text

如果我有类似这样的文字（文字不被行分割）

150,00 euros
42,00 eur
12,00 eureureuros

我有这种情况：

第一行出现两次

eur = euros (first line, match 3 characters)
euros = currency (first line, match 5 characters)

我们选择最长的（欧元=货币）

第二行，出现一次

eur = euros (second line, match 3 characters)

第三行，出现两次

eur = euros (match 9 characters)
euros = currency (match 5 characters)

结果必须是

150,00 currency (because euros = currency is the longest match)
42,00 euros (because we apply eur = euros but after that we DON'T apply euros = currency because we just apply one replacement for a part of text)
12,00 eurosos

有没有办法复制这种行为？

提前致谢！！

Answer 1

这回答了最初的问题。
您可以使用函数replace() 两次。
替换顺序很重要。
首先用"currency"替换最长的"euros"，然后用"euros"替换"eur"。
在您的情况下，只有 1 个替代品真正起作用。
对于"150,00 euros"：

val s1 = "150,00 euros"
val new1 = s1.replace("euros", "currency").replace("eur", "euros")
println(new1)

结果：

150,00 currency

对于"42,00 eur"：

val s2 = "42,00 eur"
val new2 = s2.replace("euros", "currency").replace("eur", "euros")
println(new2)

结果：

42,00 euros

Answer 2

我会这样解决它：jdoodle.com/a/23Xw

public class MyClass {
   static List<Replacement> _regexes = new ArrayList<Replacement>();

   private static String parseWord(String word) {
        // Variables for holding the best match.
        String longest = "";
        String replacement = "";

        // Check all possible replacements.
        for (Replacement regex: _regexes) {
            // Find the longest possible match.
            Pattern p = Pattern.compile("(" + regex.Source + ")+");
            Matcher m = p.matcher(word);

            // Check all matches and store it if one is longer that the current one.
            while(m.find()) {
                String match = m.group();
                if (match.length() > longest.length()) {
                    longest = match;
                    replacement = regex.Target;
                }
            }
        }

        // Finally apply the replacement.
        String result = word.replace(longest, replacement);

        return result;
    }

    private static String parse(String text) {
        // Split text into words.
        List<String> words = Arrays.asList(text.split(" "));
        // Apply replacements.
        words = words.stream().map(word -> parseWord(word)).collect(Collectors.toList());
        // Join the words again to a text.
        return String.join(" ", words);
    }


    public static void main(String args[]) {
      _regexes.add(new Replacement("euros", "currency"));
      _regexes.add(new Replacement("eur", "euros"));
      Collections.sort(_regexes);

      List<String> data = Arrays.asList("150,00 euros", "42,00 eur", "12,00 eureureuros", "15,00 euroseuroseuroseur euros eur");
      for (String text: data) {
          String result = parse(text);
          System.out.println(text + " - " + result);
      }
    }
}

public class Replacement implements Comparable<Replacement> {
  public String Source;
  public String Target;

  public Replacement(String source, String target) {
      this.Source = source;
      this.Target = target;
  }

  @Override
  public int compareTo(Replacement r) {
    return r.Source.length();
  }  
}