给定具有以下示例结构的同一类t的两个示例a和b：

Class T {
  Object C;
  Object D;
  List<E> listA;
  List<F> listB;
 ..... 
 }
 Where CLass E, Class F have also nested lists containing Objects etc.

列表中包含的所有对象都有一个bigdecimalseqnum属性，它表示列表中项目的序列号。
我想开发一种方法来比较两个示例a和b，如下所示： Compare all deeply nested lists of the two instances, find deleted list items from instance A and add them to the corresponding list in instance B with a negative seqNum 例子

* Instance A*     *Instance B*      *Updated Instance B*
    List E          List E           List E 
       1                1                1
       2                3                -2
       3                5                3
       4                                 -4
       5                                 5
    Where 1,2,3,4,5 the seqNums of the objects contained in the list.

对于所有嵌套列表，以通用方式执行这种比较/更新的最佳方式是什么？
我曾考虑过将初始对象转换为json对象，并以这种方式进行比较/更新，但我想知道是否存在更优雅的解决方案。
以下是我使用jsonobjects更新的解决方案：

public T intersectLists(T obj1, T obj2, Class<T> type){
    String obj1InString = new Gson().toJson(obj1);
    String obj2InString = new Gson().toJson(obj2);
    JsonParser parser = new JsonParser();
    JsonElement j1 = parser.parse(obj1InString);
    JsonElement j2 = parser.parse(obj2InString);
    compare(j1,j2);
    GsonBuilder gson = new GsonBuilder();
    return  gson.create().fromJson(j2, type);
}
private void compare(JsonElement j1, JsonElement j2) {
    if (j1.equals(j2)) return;
    if (j1.isJsonArray() && j2.isJsonArray()) {
        JsonArray arrJ = (JsonArray) j1;
        JsonArray arrO = (JsonArray) j2;
        int size = Math.min(arrJ.size(), arrO.size());
        for (int i = 0; i < size; i++) {
            compare(arrJ.get(i), arrO.get(i));
        }
        if (arrJ.size() > arrO.size()) {
            JsonArray deletedElements = new JsonArray();
            for (int i = 0; i < arrJ.size(); i++) {
                JsonObject jsonObject = arrJ.get(i).getAsJsonObject();
                String sequenceNumeric = jsonObject.get("sequenceNumeric").getAsString();
                int j=0;
                boolean elementFound = false;
                while( j < arrO.size()) {
                    JsonObject amendmentJsonObject = arrO.get(j).getAsJsonObject();
                    String amendSequenceNumeric = amendmentJsonObject.get("sequenceNumeric").getAsString();
                    if(amendSequenceNumeric.equals(sequenceNumeric)){
                        elementFound = true;
                        break;
                    }
                    j++;
                }
                if(!elementFound){
                    jsonObject.remove("sequenceNumeric");
                    jsonObject.addProperty("sequenceNumeric", -Integer.parseInt(sequenceNumeric));
                    deletedElements.add(jsonObject);
                }
            }
            arrO.addAll(deletedElements);
        }
    } else if (j1.isJsonObject() && j2.isJsonObject()) {
        JsonObject objJ = (JsonObject) j1;
        JsonObject objO = (JsonObject) j2;
        for (Map.Entry<String, JsonElement> entry : objJ.entrySet()) {
            String key = entry.getKey();
            JsonElement value = entry.getValue();
            if (objO.has(key)) {
                compare(value, objO.get(key));
            }
        }
    }
}