Java regex替换除少数字符组合外的所有字符

Question

Input String : NNULL(EUR,VALUE)+SOMESTR

Expected output: NNULL(X,X)+X

Expression tried:

String str = "NNULL(EUR,VALUE)+SOMESTR";
str=str.replaceAll("[^(NNULL)\\+,]+","X");

Output getting:

NNULL(XUX,XLUX)+X

Answer 1

You may use a positive look behind with ( , , or +

Regex101

String str = "NNULL(EUR,VALUE)+SOMESTR";
str=str.replaceAll("(?<=[(,+])\\w+","X");
System.out.println(str); // NNULL(X,X)+X 

Answer 2

How do you imagine the output you want would be produced?

The [...] syntax is a character class. It matches individual characters. Negating the class matches any character not in the class. So [^(NNULL)\\\\+,] matches every character that isn't one of ( , N , U , etc.

It seems like what you want to do is tokenize the string according to a set of rules that you haven't clearly defined, and then replace certain tokens.

First, define a simple regex that will match a single 'token'. From your question, I'm guessing you want to consider words and symbols, so the tokens would be NNULL , ( , EUR , , , VALUE , ) , + , X .

Pattern pattern = Pattern.compile("\\w+|\\W"); // a word, or a single non-word character

Now, find a way to specify which tokens to keep and which to replace. I used a Set containing the 'good' tokens, but any string predicate will work.

Set<String> retain = new HashSet<>(Arrays.asList("NNULL", "(", ")", ",", "+"));

All we have to do now is loop through the tokens (as identified by the regex) and see if they're in the 'good' set or not.

StringBuilder result = new StringBuilder();
Matcher m = pattern.matcher(input);
while(m.find()) {
    String token = m.group();
    result.append(retain.contains(token) ? token : "X");
}

Some people, when confronted with a problem, think "I know, I'll use regular expressions." Now they have two problems.

Answer 3

Your suggested pattern [^NNULL] does not mean anything but NNULL , it means anything not in the character class NNULL with N being duplicate here.

Use this pattern instead

\b(?!NNULL)[^(),+]+

Demo

\b              # <word boundary>
(?!             # Negative Look-Ahead
  NNULL         # "NNULL"
)               # End of Negative Look-Ahead
[^(),+]         # Character not in [(),+] Character Class
+               # (one or more)(greedy)