I haven't tested this, but I think something like this would do what you want:

import org.codehaus.jackson.node.ObjectNode;
// ...
for (JsonNode personNode : rootNode) {
    if (personNode instanceof ObjectNode) {
        ObjectNode object = (ObjectNode) personNode;
        object.remove("familyName");
        object.remove("middleName");
    }
}

You could also do this more efficiently using Jackon's raw parsing API, but the code would be a lot messier.

One thing I would suggest is to split this into a few functions with descriptive names and smaller scopes. First, since we can remove several fields with this function, I think it would be more clearly named removeProperties. (Also, is there a reason that the function name uses "property" and the parameter name uses "field"? It seems to me you could pick one or the other.)

If you split this into single responsibility functions, you get:

public static JsonNode removeProperties(JsonNode node, List<String> removedField){
    JsonNode modifiedNode = node;

    for (String nodeToBeRemoved: removedField){
        modifiedNode = removeProperty(modifiedNode, nodeToBeRemoved);
    }

    return node;
}

A second observation is that it looks like ObjectNode.remove mutates the node. If that's correct, then why bother returning the modified node? Since it's changed in place, you could make this a void function. Or, if the intent is to avoid mutating the provided node, then you'd need to clone it before starting to operate on it. Even if you clone it, remove still changes the node in place, so there's no need for the inner function to return modifiedNode.

I suggest you include JavaDocs specifying whether this function will change the input node or not.

Thirdly, I suggest some renaming here:

String[] array = nodeToBeRemoved.split("/");

To me, this would me more clear as follows, since it makes sense to split a path but I don't know what it means to split a node. We already have a node in context, and its type is JsonNode. If we also call this string a node, then we have two things called "node" which have different types.

String[] pathParts = pathToBeRemoved.split("/");

On the topic of names, I think it would be helpful to extract a variable for the last element:

String keyToRemove = pathParts[pathParts.length - 1];

That way the remove line becomes more clear:

((ObjectNode) nodeToModify).remove(keyToRemove);

for (JsonNode personNode : rootNode) {
    if (personNode instanceof ObjectNode) {
       if (personNode.has("showTimes")) {
          ObjectNode object = (ObjectNode) personNode;  
          object.remove("showTimes");
       }
    }
}

I am not sure whether this problem has been solved or not. But following code snippet shows how to remove a field whose key is xxx from JSON node. And a JsonNode cannot perform insertion or deletion, so you have to cast it to ObjectNode for further manipulation.

Code snippet

 ObjectMapper mapper = new ObjectMapper();
 JsonNode rootNode = mapper.readTree(jsonStr);
 rootNode.get("arrayNode").forEach(e -> {
     if (e.has("xxx")) {
         ObjectNode objNode = (ObjectNode) e;
         objNode.remove("xxx");
     }
 });

 System.out.println(rootNode.toString());

Console output

{"arrayNode":[{"yyy":{}},{"yyy":{}}]}

The change node will allow you to remove key value pairs from a the msg object.

From the info sidebar:

Set, change, delete or move properties of a message, flow context or global context.

The node can specify multiple rules that will be applied in turn.

The available operations are:

• Set - set a property. The value can be a variety of different types, or can be taken from an existing message or context property.
• Change - search & replace parts of the property. If regular expressions are enabled, the replace with property can include capture groups, for example $1. Replace will only change the type if there is a complete match.
• Delete - delete a property.
• Move - move or rename a property.