Deep Vergleichen von zwei JSON und Anzeigen der Unterschiede

Question

Ich versuche, zwei dynamische JSON-Daten zu vergleichen, und wenn sie nicht gleich sind, drucke ich die Unterschiede. Dazu verwende ich

Type mapType = new TypeToken<Map<String, Object>>(){}.getType(); 
Map<String,Object> firstMap = g.fromJson(jsonElement1, mapType); 
Map<String, Object> secondMap = g.fromJson(jsonElement2, mapType); 
System.out.println(Maps.difference(firstMap, secondMap)); 

Ich muss den Unterschied in der Konsole anzeigen. Diese ist der Java-Code, in dem ich versuche, die Unterschiede der json anzuzeigen

 public class Tester { 
public static ArrayList<Object> ls1 = new ArrayList<Object>(); 
public static    ArrayList<Object> ls2 = new ArrayList<Object>(); 
      public static void main(String[] args) throws Exception { 
       JsonParser parser = new JsonParser(); 

       try{ 
        Gson g = new Gson(); 
        JsonElement jsonElement1 = parser 
          .parse(new FileReader("D:\\file1.json")); 
        JsonElement jsonElement2 = parser 
          .parse(new FileReader("D:\\file2.json")); 
        System.out.println("Is the two JSON File Same: "+compareJson(jsonElement1, jsonElement2)); 
        if(!compareJson(jsonElement1, jsonElement2)){ 
         Type mapType = new TypeToken<Map<String, Object>>(){}.getType(); 
         Map<String,Object> firstMap = g.fromJson(jsonElement1, mapType); 
         Map<String, Object> secondMap = g.fromJson(jsonElement2, mapType); 
         System.out.println(Maps.difference(firstMap, secondMap)); 
        } 
        else{ 
         System.out.println("The Two JSON Are SAME!!!!!!!!!!!!!!!"); 
        } 

       }catch(Exception e1){ 
        e1.printStackTrace(); 
       } 

      } 

      public static boolean compareJson(JsonElement json1, JsonElement json2) { 
       boolean isEqual = true; 

       // Check whether both jsonElement are not null 
       if (json1 != null && json2 != null) { 

        // Check whether both jsonElement are objects 
        if (json1.isJsonObject() && json2.isJsonObject()) { 
         Set<Entry<String, JsonElement>> ens1 = ((JsonObject) json1).entrySet(); 
         Set<Entry<String, JsonElement>> ens2 = ((JsonObject) json2).entrySet(); 
         JsonObject json2obj = (JsonObject) json2; 
         if (ens1 != null && ens2 != null && (ens2.size() == ens1.size())) { 
          // Iterate JSON Elements with Key values 
          for (Entry<String, JsonElement> en : ens1) { 
           isEqual = isEqual && compareJson(en.getValue(),json2obj.get(en.getKey())); 
          } 
         } else { 
          return false; 
         } 
        } 
        // Check whether both jsonElement are arrays 
        else if (json1.isJsonArray() && json2.isJsonArray()) { 
         JsonArray jarr1 = json1.getAsJsonArray(); 
         JsonArray jarr2 = json2.getAsJsonArray(); 
         if (jarr1.size() != jarr2.size()) { 
          return false; 
         } else { 
          int i = 0; 
          // Iterate JSON Array to JSON Elements 
          for (JsonElement je : jarr1) { 
           isEqual = isEqual && compareJson(je, jarr2.get(i)); 
           i++; 
          } 
          if (isEqual) { 
           Object[] o1 = ls1.toArray(); 
           Object[] o2 = ls2.toArray(); 
           isEqual = Arrays.deepEquals(o1, o2); 
          } 
         } 

        } 

        // Check whether both jsonElement are null 
        else if (json1.isJsonNull() && json2.isJsonNull()) { 
         return true; 
        } 

        // Check whether both jsonElement are primitives 
        else if (json1.isJsonPrimitive() && json2.isJsonPrimitive()) { 
         ls1.add(json1); 
         ls2.add(json2);   
        }    
       } else if (json1 == null && json2 == null) { 
        return true; 
       } else { 
        return false; 
       } 
       return isEqual; 
      } 
     } 

das Objekt Array

if (isEqual) { 
          Object[] o1 = ls1.toArray(); 
          Object[] o2 = ls2.toArray(); 
          isEqual = Arrays.deepEquals(o1, o2); 
         } 

das Objekt Array o1 und o2 sind null weiß nicht, warum es null ist. Diese sind die beiden Proben json ich verwende zum Testen json1 {"Company List":["Compnay: Paypal","Compnay: eBay","Compnay: Google"]} json2 {"Company List":["Compnay: Viswesh","Compnay: Anand","Compnay: Anand"]} sowohl in der json der Wert für Unternehmen ist anders, so der Code falsch zurückgeben muss aber den Code return true

Answer 1

Der Kommentarbereich wurde immer zu lang, also hier ist eine Antwort:

Zunächst einmal haben Sie immer noch ein Problem, wenn Ihre Json-Objekte unterschiedliche Strukturen haben. Zum Beispiel:

{"Company List":["Compnay: eBay","Compnay: Google","Compnay: Paypal"]} 

{"Company List":"ImAString"} 

Weder null ist, dann ist es eine primitive und ein Array. Sie fangen diesen Fall nicht ein, also wird Ihre isEqual wahr bleiben.

---

Wie auch immer, zurück zu dem Problem zur Hand.

Arrays müssen nicht gleich bestellt werden, um in Ihrem Fall gleich zu sein.

if (isEqual) { 
    Object[] o1 = ls1.toArray(); 
    Object[] o2 = ls2.toArray(); 
    isEqual = Arrays.deepEquals(o1, o2); 
} 

Sie sollten leicht in der Lage sein, es zu lösen, indem sie diese in das zu ändern:

if (isEqual) { 
    isEqual = ls1.containsAll(ls2); 
} 

Obwohl ich sollte erwähnen, dass ich sind es wirklich seltsam, dass Ihr LS1 und LS2 finden sowohl statische als auch halten nur immer Einträge. In Ihren Beispielen spielt es keine Rolle, weil sie so klein sind, aber bei großen Dateien erhalten Sie riesige ArrayLists mit vielen Werten, die mehrmals erscheinen.

Und sie alle zu vergleichen, jedes Mal, wenn Sie zu einem JsonArray kommen, scheint wie eine riesige Zeitverschwendung.

---

Da dies immer noch das Problem der nicht anders vergleichen zu können bestellt JSON Arrays mit JSON-Elementen, die nicht Primitive sind, hier sind der Brute-Force-Ansatz zwei Arrays zu vergleichen. Beachten Sie, dass es weit ist von einem optimalen Ansatz zu sein, aber es ist relativ einfach zu implementieren:

public static boolean equality(ArrayList<Object> list1, ArrayList<Object> list2) { 
    if (list1.length != list2.length) return false; 

    for (Object entry1 : list1) { 
     Object equalEntry = null; 

     for(Object entry2 : list2) { 
      if (entry1.equals(entry2)) { 
       equalEntry = entry2; 
       break; 
      } 
     } 

     if (equalEntry == null) return false;  
     list2.remove(equalEntry); 
    } 

    return true; 
} 

Ich sollte auch erwähnen, dass es als if (entry1.equals(entry2)) offensichtlich nicht so einfach ist. Wahrscheinlich müssen Sie an dieser Stelle die Rekursion durchführen und Ihre Vergleichs-Methode aufrufen. Ich bin mir auch ziemlich sicher, dass Ihre Listen JSON-Elemente enthalten und keine Objekte;)