Regex to remove Key and value from JSON

I have a JSON like below:

{"queueNumber": "123","UserId":[12,12,34],"cur":[{"objectName":"test","uniqueNumber":"123456"}]}

I want to remove the key-value pairs if it matches a given field.

I tried with the below regex but it adds a comma at the end which raises an exception at runtime while reading this JSON again.

"((queueNumber|name|uniqueNumber)[0-9]*)":(\s*)?((".*?")|(\d+.\d+)|(\w+))[,]?

current output:

{"UserId":[12,12,34],"cur":[{"objectName":"test",}]}

Expected output:

{"UserId":[12,12,34],"cur":[{"objectName":"test"}]}

How to remove K,V pairs without that extra comma at the end?

I second the comments, that you should probably use a JSON parser library for java. For the sake of completeness I developed both approaches:

regex approach

We need to consider the following cases:

1. key-value-pair is alone: {"queueNumber": "123"}
2. key-value-pair is at the beginning: {"queueNumber": "123","asdf": "1",...}
3. key-value-pair is in the middle: {,"asdf1": "1","queueNumber": "123","asdf2": "1",...}
4. key-value-pair is at the end: {...,"asdf1": "1","queueNumber": "123"}

The difficulty is to not to remove too many commas. We can categorize the cases in two classes:

1. the key-value-pair starts with a comma
2. the key-value-pair doesn't start with a comma, but may(!) end with a comma
   "may end with a comma" could be considered a sub-class

If either of these classes is true, we have a full match.

Regex for class 1: ,\s*"(queueNumber|name|uniqueNumber)\d*":\s*("[^"]*?"|\d+.\d+|\w+) <br>
Regex for class 2: "(queueNumber|name|uniqueNumber)\d*":\s*("[^"]*?"|\d+.\d+|\w+)(\s*,)?

Full Regex (see this link):
(,\s*"(queueNumber|name|uniqueNumber)\d*":\s*("[^"]*?"|\d+.\d+|\w+))|("(queueNumber|name|uniqueNumber)\d*":\s*("[^"]*?"|\d+.\d+|\w+)(\s*,)?)

Explanation:

• ,\s* - matches a comma followed by any whitespace 0 - unlimited times
• " - match the literal char "
• (queueNumber|name|uniqueNumber)\d* - matches either queueNumber, name or uniqueNumber, followed by optional numbers
• ":\s* - literal ": followed by optional whitespaces
• ("[^"]*?"|\d+.\d+|\w+) - matches either anything inside of quotation marks, a decimal digit or a word <br>
  ** [^"]*? - lazy match of any string, that does not contain " ([^abc]-creates a word class with all chars, that are not a, b or c). Lazy means, the regex tries to match the least amount of chars possible.
• (.a.)|(.b.) matches either the first(a) or the second(b) regex. If the first regex matched, the second regex is ignored.
• (\s*,)? optionally matches optional white spaces followed by a comma <br>
  ** ? - means 0 to 1 matches

Improvements to your regex approach:

• you didn't need so many groups (...). Grouping is only necessary for replacing or to apply a quantifier or other logic to a sub-regex. The boolean OR operator is not applied to single chars/matchers, but to the whole connected chars then come before and follow after.
• \d is the same as [0-9]
• [,]? can be simplified to ,?
• (\s*)? can be simplified to \s* → the * already means 0-infinity matches. So there is no need to make this part optional with the ? quantifier
• Your approach to match the value-part ((".*?"|\d+.\d+|\w+)) can get out of hand, because of the part .*?. Your rightfully made it a lazy match. But if the regex doesn't find something in the way you intended to, the laziness will not stop it to go on as far as possible to get at least one match. A better approach is to replace the .-matcher with [^"]. That way you will not match outside of the string.

JSON parser approach

Take a look at the following libraries:

• JSON.simple
• GSON
• Jackson

If you don't know the exact structure of the json, I recommend using JsonPath to remove the keys. But you need to be extra careful not to remove more than you want to. See this example:

maven dependency:

<dependency>
  <groupId>com.jayway.jsonpath</groupId>
  <artifactId>json-path</artifactId>
  <version>2.8.0</version>
</dependency>

Java code (minimum Java 15 required):

import com.jayway.jsonpath.DocumentContext;
import com.jayway.jsonpath.JsonPath;
import com.jayway.jsonpath.Option;
import com.jayway.jsonpath.Configuration;

public class App {
    public static void main( String[] args ) {
        String details = """
            {"queueNumber": "123","UserId":[12,12,34],"cur":[{"objectName":"test","uniqueNumber":"123456"}]}
                """;

        DocumentContext parsedJson = JsonPath.parse(details, 
                // exceptions are thrown when a key is not present. For a simpler demo
                // we suppress all exceptions. Be cautious how to use this implementation
                // in production though!
                Configuration.defaultConfiguration().addOptions(Option.SUPPRESS_EXCEPTIONS));
        
        parsedJson.delete("$..queueNumber");
        parsedJson.delete("$..name");
        parsedJson.delete("$..uniqueNumber");

        System.out.println(parsedJson.jsonString());
    }
}

Now, if you are certain about the structure of the given json, you can change the path to the following:

        parsedJson.delete("$.queueNumber");
        parsedJson.delete("$..name");
        parsedJson.delete("$.cur[*].uniqueNumber");

You'd only need to adapt the path of the key "name". As it was missing in your example, I don't know where it usually occurs. If you get stuck using the library, check the example section of the readme file, it's well documented: https://github.com/json-path/JsonPath#path-examples