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.

If jsonNode is an Array of Objects then jsonNode.elements() returns Iterator<JsonNode>, by using if condition check the node with name equals 1 then delete the entire node

 JsonNode jsonNode = objectMapper.readTree(new File("savefiles.json"));
Iterator<JsonNode> nodes = jsonNode.elements()
 while(nodes.hasNext()) {
     if(nodes.next().get("name").textValue().equals("1")){
           nodes.remove();
           }
       }

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);

As I pointed in comment you need to remove arrayNode variable(which must be named as arrayElementNode ) from arrayNode(which is entry.getValue()), currently you are just removing arrayNode's(arrayElementNode's) properties

Here is the code with this logic

Iterator<Map.Entry<String, JsonNode>> fieldIterator = testNode.
while (fieldIterator.hasNext()) 
{
   Map.Entry<String, JsonNode> entry = fieldIterator.next();
   if (entry.getValue().isArray())
   {
      ArrayNode arrayNode = (ArrayNode) entry.getValue();
      for(int i = arrayNode.size()-1; i >= 0 ; i--)
      {
         if(arrayNode.get(i).path("form2").isMissingNode())
            arrayNode.remove(i);

     }
   }
}

you are removing the key-value pair from JsonObject and not the enclosing JsonArray. And a JsonObject can have several key-value pair in itself. So deleting one doesn't delete the whole object.

jsonObj={"a":"cde","b":"fgh"}

this is a valid jsonObject. when I delete "b" from it like jsonObj.remove("b"), only "a" remains {"a":"cde"} and deleting "a" returns {}

Hence, if you want to remove the whole jsonObject from jsonArray, remove it directly from jsonArray.

And in JsonArray, you can't select a jsonObject with key and rather with its index. Hence, even when it has two JsonObjects with same keys, you have to select one by their unique index.

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":{}}]}