If Gson is like Jackson (I assume so) you'll have to first get the JsonObject "accounts" from the root object and then remove the member "email", e.g. like this:

jsonObj.getAsJsonObject("accounts").remove("email");

Alternatively - and probably the preferred way - you would map the json object to a POJO (one that has the fields "status", "accounts" and "accounts" would point to another POJO), navigate to the accounts-POJO and set "email" to null there. Then you reformat the root POJO to JSON and apply a setting that omits fields with null values.

Edit (answer to the question in the comment):

To make it short, I don't know whether there is a built-in functionality or not but it should be doable.

The problem is that if you just provide keys like email etc. you might get situations where there are multiple keys so identifying the correct one could be hard. Thus it might be better to provide the key as accounts.email and split the "key" into sub-expressions and then traverse the Json tree using the parts or convert the Json to a POJO and use some expression language (e.g. Java EL or OGNL) to traverse the POJO.

If you want to remove all properties named email you could just travers the entire json tree, check whether there is a property with that name and if so remove it.

You have to use remove("OLD_KEY") to remove value and then add this under new key

jsonObj.getJSONArray("Data").get(0).remove("status);

#Updated Code-breakdown:

JSONObject obj= (JSONObject) jsonObj.getJSONArray("Data").get(0);
   obj.remove("status");

   JSONArray newArr=new JSONArray();
   newArr.put(obj);
   jsonObj.put("Data", newArr);

It should do your work, haven't tested though. First, your Data is JSONArray, retrieving that by jsonObj.getJSONArray("Data"), then access the array with get(0)[assuming, your array will contain only one entry like your example] and finally, removing that key by remove method.

Try this:

JSONObject jsonObject = new JSONObject(Result);
jsonObject
  .getJSONObject("MerchHierarchyEBM")
  .getJSONObject("DataArea")
  .getJSONObject("Division")
  .remove("Group");

Or if getJSONObject() doesn't work, replace it with getAsJsonObject().

I wouldn't recommend using regex for such thing, the better choice would be using a library for parsing json, remove the value, and then turn it into a string again.

    JSONObject jsonObject = new JSONObject(input);
    jsonObject.getJSONObject("expressions").remove("storyId");
    String output = jsonObject.toString();

if you really want to use regex, you can use the follow

    jsonString.replaceAll("(\\\"storyId\\\"|\\'storyId\\')\\s*:\\s*(\\\"[^\\\"]*\\\"|'[^\\\"]*')\\s*,?", "");

but just make sure that storyId is really a string, otherwise this regex won't work.

edit: updated my answer, if you want a function that get the parameter to remove with regex,

void replaceAllKeys(String keyName, String jsonAsString) {
    String pattern = String.format("(\\\"%s\\\"|\\'%s\\')\\s*:\\s*(\\\"[^\\\"]*\\\"|'[^\\\"]*')\\s*,?", keyName, keyName);
    return jsonAsString.replaceAll(pattern, "");
}

Iterator keys = detailJSON.keys();
while(keys.hasNext())
  detailJSON.remove((String)detailJSON.keys().next());

org-json-java can do the things you want

import org.json.JSONException;
import org.json.JSONObject;

public class JsonTest {
    public static void main(String[] args) {
        try {
            JSONObject testObject = new JSONObject("{\"a\":\"vala\", \"b\":\"valb\", \"c\":\"valc\"}");
            testObject.remove("b");
            testObject.remove("c");
            System.out.println(testObject.toString());  // This prints out the json string
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }
}

The execution result is

{"a":"vala"}

Make sure you've downloaded and imported org.json-YYYYMMDD.jar from here before you run the above code.

You can do something like this. This will iterate and remove each matched key.

private static void iterateJSONAndRemoveKey(JSONObject jObj) {
    Set<String> keys = jObj.keySet();
    for(String key : keys) {
        if(key.equals("remove_me")) {
            jObj.remove(key);
        }
        else if(jObj.get(key) instanceof JSONObject) {
            JSONObject subObject = (JSONObject) jObj.get(key);
            iterateJSONAndRemoveKey(subObject);
        }
        else if(jObj.get(key) instanceof JSONArray) {
            JSONArray jArray = (JSONArray) jObj.get(key); 
            for(int i = 0; i < jArray.size(); i++) {
                if(jArray.get(i) instanceof JSONObject) {
                iterateJSONAndRemoveKey((JSONObject)jArray.get(i));
                }
            }
        }
    }
}

You can remove any element by using JsonObjectBuilder.

For example:

public class Test{
    public static void main(String[] args) {
        javax.json.JsonObject full = javax.json.Json.createObjectBuilder().add("a", 1).add("b", 2).build();
        full = javax.json.Json.createObjectBuilder(full).remove("a").build();
        System.out.println(full); // return {"b":2}
     }
}