Tester deux objets JSON pour l'égalité en ignorant l'ordre des enfants en Java


233

Je recherche une bibliothèque d'analyse JSON qui prend en charge la comparaison de deux objets JSON en ignorant l'ordre des enfants, en particulier pour les tests unitaires JSON retournant d'un service Web.

Est-ce que l'une des principales bibliothèques JSON prend en charge cela? La bibliothèque org.json fait simplement une comparaison de référence.


1
Vous ne pouvez pas sérialiser les deux objets en représentation de chaîne et comparer? Je suppose que toutes les bibliothèques prennent toString()en charge la conversion de l'objet en JSONchaîne.
Teja Kantamneni

47
Cela suppose que l'ordre de sérialisation vers et depuis les chaînes est toujours le même. Je ne suis pas à l'aise de faire cette hypothèse.
Jeff

Tu as raison Jeff, ce n'est pas sûr du tout. Ce test montre un scénario où les mappages sont les mêmes mais toString () ne renvoie pas la même sortie: gist.github.com/anonymous/5974797 . En effet, le HashMap sous-jacent peut augmenter et si vous supprimez des clés, le tableau interne HashMap ne rétrécit pas.
Guillaume Perrot

Réponses:


84

En règle générale, je déconseille généralement de laisser les dépendances sur un format de sérialisation particulier s'étendre au-delà de votre couche de stockage / réseau; ainsi, je vous recommande tout d'abord d'envisager de tester l'égalité entre vos propres objets d'application plutôt que leurs manifestations JSON.

Cela dit, je suis actuellement un grand fan de Jackson, ce que ma lecture rapide de leur implémentation ObjectNode.equals () suggère de faire la comparaison d'appartenance que vous souhaitez:

public boolean equals(Object o)
{
    if (o == this) return true;
    if (o == null) return false;
    if (o.getClass() != getClass()) {
        return false;
    }
    ObjectNode other = (ObjectNode) o;
    if (other.size() != size()) {
        return false;
    }
    if (_children != null) {
        for (Map.Entry<String, JsonNode> en : _children.entrySet()) {
            String key = en.getKey();
            JsonNode value = en.getValue();

            JsonNode otherValue = other.get(key);

            if (otherValue == null || !otherValue.equals(value)) {
                return false;
            }
        }
    }
    return true;
}

Cette méthode n'est pas symétrique, car elle teste uniquement la relation de «sous-ensemble» des enfants, pas l'égalité. l'objet 'other' peut avoir plus d'enfants que dans _children, et cette méthode retournerait toujours true.
Yoni

23
@Yoni: Pas vrai, car il y a une comparaison de taille. Ils doivent avoir exactement le même nombre d'enfants ainsi que les mêmes enfants. @Jolly Roger: Dans ce cas, je ne sérialise pas l'objet de JSON dans un POJO, mais lorsque j'envoie à JSON un système qui le fait, je ne peux pas compter sur lui pour le renvoyer dans le même format que celui dans lequel j'ai envoyé il.
Jeff

1
@Jeff Est-ce que cela a fonctionné pour vous? En junit, assertEquals échoue pour moi. Le projet utilise une ancienne version (1.5), fyi.
ronnyfm

1
Je pense que vous manquez des tests de haut niveau si vous n'affirmez pas JSON. Vous pouvez avoir un test fin qui fait une demande http et répond avec du JSON attendu - c'est le comportement fonctionnel principal du service Web.
mogronalol

Juste une petite remarque concernant les performances: le code qui compare 'value' avec 'otherValue' peut être simplifié si (value.equals (other.get (key)) renvoie false; car 'value' est garanti d'être non nul et La méthode equals () de JsonNode devrait accepter un argument nul
Tillmann

154

Essayez JSONAssert de Skyscreamer .

Son mode non strict présente deux avantages majeurs qui le rendent moins fragile:

  • Extensibilité de l'objet (par exemple, avec une valeur attendue de {id: 1} , cela passerait toujours: {id: 1, moredata: 'x'} .)
  • Ordre des tableaux en vrac (par exemple ['chien', 'chat'] == ['chat', 'chien'])

En mode strict, il se comporte plus comme la classe de test de json-lib.

Un test ressemble à ceci:

@Test
public void testGetFriends() {
    JSONObject data = getRESTData("/friends/367.json");
    String expected = "{friends:[{id:123,name:\"Corby Page\"}"
        + ",{id:456,name:\"Solomon Duskis\"}]}";
    JSONAssert.assertEquals(expected, data, false);
}

Les paramètres dans les JSONAssert.assertEquals () appel sont expectedJSONString , actualDataString et isstrict .

Les messages de résultat sont assez clairs, ce qui est important lors de la comparaison de très gros objets JSON.


18
J'utilise cette solution, mais je viens de découvrir que vous pouvez également fournir un JSONCompareMode de votre choix. L'un d'eux est NON_EXTENSIBLE. Vous auriez donc quelque chose comme ceci: JSONAssert.assertEquals(expected, data, JSONCompareMode.NON_EXTENSIBLE);Le mode NON_EXTENSIBLE signifie que tout champ nouveau ou manquant provoque des échecs, mais pas l'ordre. L'utilisation de false déclencherait le mode indulgent qui ne rapporterait aucun élément enfant supplémentaire ou manquant.
Dan Temple

1
Le mode de comparaison NON_EXTENSIBLE est exactement ce que je cherchais. Merci pour cela, Dan.
ThoughtCrhyme

Avant de m'exciter: cela prend-il également en charge les tableaux et les objets JSON imbriqués? :)
Christian

2
Les utilisateurs peuvent vouloir prendre en compte ce problème JSONassert avant d'utiliser la bibliothèque: cela indique qu'il existe actuellement des problèmes de licence potentiels avec une dépendance de la bibliothèque.
Chriki

3
Problème n ° 44 de JSONAssert corrigé avec le remplacement de la bibliothèque de salle blanche dans PR 67, publié aujourd'hui sous le nom de JSONAssert 1.4.0.
Carter Page

49

Utilisation de GSON

JsonParser parser = new JsonParser();
JsonElement o1 = parser.parse("{a : {a : 2}, b : 2}");
JsonElement o2 = parser.parse("{b : 2, a : {a : 2}}");
assertEquals(o1, o2);

Edit: Depuis GSON v2.8.6, la méthode d'instance JsonParser.parseest obsolète. Vous devez utiliser la méthode statique JsonParser.parseString:

JsonElement o1 = JsonParser.parseString("{a : {a : 2}, b : 2}");
JsonElement o2 = JsonParser.parseString("{b : 2, a : {a : 2}}");
assertEquals(o1, o2);

Fonctionne dans GSON 2.8.2 pour moi.
Tom Saleeba

1
cela ne fonctionne pas si les éléments jsonArray ne sont pas en ordre. version 2.8.2
Naveen Kumar RB

1
Ne fonctionne pas pour moi si l'ordre des objets / éléments est différent
Jknair

Cela a fonctionné pour moi parce que je le voulais juste pour un test unitaire où les deux propriétés jsons avaient le même ordre
GabrielBB

@GabrielBB Vous devez modifier la question et indiquer dans quelle version l'API est obsolète et dans quelle version le nouveau style de code commence à fonctionner.
clearlight

30

Je ferais ce qui suit,

JSONObject obj1 = /*json*/;
JSONObject obj2 = /*json*/;

ObjectMapper mapper = new ObjectMapper();

JsonNode tree1 = mapper.readTree(obj1.toString());
JsonNode tree2 = mapper.readTree(obj2.toString());

return tree1.equals(tree2);

Si vous utilisez déjà Jackson, c'est la meilleure réponse à mon humble avis.
Christoph Dietze

18
mais je pense que c'est une comparaison stricte. Il retournera false pour deux json égaux ayant un ordre d'éléments différent.
Deadpool

@deadpool le principe est bon, il suffit de changer la comparaison pour être plus impliqué (en vérifiant par exemple les champs clés plutôt que de simples équivalents des arbres).
jwenting

C'est la meilleure réponse de tous les temps. Non seulement il répond à ma question maintenant, mais il répond également à presque toutes les comparaisons d'objets que nous devons faire. merci, joshu.
Luiz Feijão Veronesi

2
@deadpool, c'était peut-être une comparaison stricte, mais ce n'est pas le cas maintenant.
Andrei Damian-Fekete

18

Vous pouvez essayer d'utiliser la classe JSONAssert de json-lib :

JSONAssert.assertEquals(
  "{foo: 'bar', baz: 'qux'}",
  JSONObject.fromObject("{foo: 'bar', baz: 'xyzzy'}")
);

Donne:

junit.framework.ComparisonFailure: objects differed at key [baz]; expected:<[qux]> but was:<[xyzzy]>

Ou encore plus simple: JSONAssert.assertJsonEquals ("{foo: 'bar', baz: 'qux'}", {foo: 'bar', baz: 'xyzzy'} ");
Rob Juurlink

2
Bien que cette solution fonctionne pour l'ordre des éléments de données dans le JSON, elle échouera si l'ordre des éléments dans les tableaux ne correspond pas. Si votre code utilise un ensemble qui est converti en JSON par exemple. La comparaison JSON suivante échouerait: JSONAssert.assertJsonEquals( "{foo: 'bar', list: [{test: '1'}, {rest: '2'}] }", "{ foo: 'bar', list: [{rest: '2'}, {test: '1'}] }"); Avec le message:junit.framework.AssertionFailedError: : : objects differed at key [list];: arrays first differed at element [0];: objects differed at key [test];
Dan Temple

Oui, c'est une limitation de Json :(. Json.org montre qu'il n'y a pas de jeton de collection non ordonné. {} Ne peut entourer que les paires clé-valeur. C'est très irritant
Merk

15

Utilisez cette bibliothèque: https://github.com/lukas-krecan/JsonUnit

Pom:

<dependency>
    <groupId>net.javacrumbs.json-unit</groupId>
    <artifactId>json-unit</artifactId>
    <version>1.5.0</version>
    <scope>test</scope>
</dependency>

IGNORING_ARRAY_ORDER - ignore l'ordre dans les tableaux

assertJsonEquals("{\"test\":[1,2,3]}",
  "{\"test\":  [3,2,1]}",
  when(IGNORING_ARRAY_ORDER)
);

pouvez-vous ajouter plus de commentaires sur la façon dont nous pouvons l'utiliser je l'ajoute à mon pom mais nous avons besoin de doc pour comprendre comment l'utiliser
Ran Adler

l'utilisation est très simple: ajoutez-la à votre pompon. <dependency> <groupId> net.javacrumbs.json-unit </groupId> <artifactId> json-unit </artifactId> <version> 1.5.0 </version> <scope> test </scope> </dependency>
chethu

10x j'ai regardé l'instruction sur le lien et je l'ai trouvée :)
Ran Adler

12

Si vous utilisez déjà JUnit, la dernière version utilise désormais Hamcrest. Il s'agit d'un cadre de correspondance générique (particulièrement utile pour les tests unitaires) qui peut être étendu pour créer de nouveaux correspondants.

Il existe une petite bibliothèque open source appelée hamcrest-jsonavec des correspondances compatibles avec JSON. Il est bien documenté, testé et pris en charge. Voici quelques liens utiles:

Exemple de code utilisant des objets de la bibliothèque JSON org.json.simple:

Assert.assertThat(
    jsonObject1.toJSONString(),
    SameJSONAs.sameJSONAs(jsonObject2.toJSONString()));

Facultativement, vous pouvez (1) autoriser les tableaux "de n'importe quel ordre" et (2) ignorer les champs supplémentaires.

Comme il existe une variété de bibliothèques JSON pour Java ( Jackson, GSON, json-lib, etc.), il est utile que les hamcrest-jsonsupports texte JSON (comme java.lang.String), des objets ainsi que nativement l' appui de la bibliothèque JSON de Douglas Crockford org.json.

Enfin, si vous n'utilisez pas JUnit, vous pouvez utiliser Hamcrest directement pour les assertions. ( J'ai écrit à ce sujet ici. )


Quel est l'avantage d'utiliser des comparateurs hamcrast au lieu d'utiliser directement JSONAssert?
Johannes

2
@Johannes: Style uniquement.
kevinarpe

Les sources hamcrest-json ont actuellement une dernière date de validation en 2012. Elle n'est peut-être plus aussi bien supportée.
Thorbjørn Ravn Andersen

11

Vous pouvez essayer JsonUnit . Il peut comparer deux objets JSON et signaler les différences. Il est construit sur Jackson.

Par exemple

assertJsonEquals("{\"test\":1}", "{\n\"test\": 2\n}");

Résulte en

java.lang.AssertionError: JSON documents are different:
Different value found in node "test". Expected 1, got 2.

6

Une chose que j'ai faite et cela fonctionne à merveille est de lire les deux objets dans HashMap puis de les comparer avec un assertEquals () normal. Il appellera la méthode equals () des hashmaps, qui comparera récursivement tous les objets à l'intérieur (ce seront soit d'autres hashmaps soit un objet à valeur unique comme une chaîne ou un entier). Cela a été fait en utilisant l'analyseur Jackson JSON de Codehaus.

assertEquals(mapper.readValue(expectedJson, new TypeReference<HashMap<String, Object>>(){}), mapper.readValue(actualJson, new TypeReference<HashMap<String, Object>>(){}));

Une approche similaire peut être utilisée si l'objet JSON est un tableau à la place.


6

J'utilise ceci et fonctionne bien pour moi (avec org.json. *):

package com.project1.helpers;

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

import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class JSONUtils {

    public static boolean areEqual(Object ob1, Object ob2) throws JSONException {
        Object obj1Converted = convertJsonElement(ob1);
        Object obj2Converted = convertJsonElement(ob2);
        return obj1Converted.equals(obj2Converted);
    }

    private static Object convertJsonElement(Object elem) throws JSONException {
        if (elem instanceof JSONObject) {
            JSONObject obj = (JSONObject) elem;
            Iterator<String> keys = obj.keys();
            Map<String, Object> jsonMap = new HashMap<>();
            while (keys.hasNext()) {
                String key = keys.next();
                jsonMap.put(key, convertJsonElement(obj.get(key)));
            }
            return jsonMap;
        } else if (elem instanceof JSONArray) {
            JSONArray arr = (JSONArray) elem;
            Set<Object> jsonSet = new HashSet<>();
            for (int i = 0; i < arr.length(); i++) {
                jsonSet.add(convertJsonElement(arr.get(i)));
            }
            return jsonSet;
        } else {
            return elem;
        }
    }
}

4

Pour org.json, j'ai déployé ma propre solution, une méthode qui se compare aux instances JSONObject. Je n'ai pas travaillé avec des objets JSON complexes dans ce projet, donc je ne sais pas si cela fonctionne dans tous les scénarios. De plus, étant donné que j'utilise ceci dans des tests unitaires, je n'ai pas mis d'effort dans les optimisations. C'est ici:

public static boolean jsonObjsAreEqual (JSONObject js1, JSONObject js2) throws JSONException {
    if (js1 == null || js2 == null) {
        return (js1 == js2);
    }

    List<String> l1 =  Arrays.asList(JSONObject.getNames(js1));
    Collections.sort(l1);
    List<String> l2 =  Arrays.asList(JSONObject.getNames(js2));
    Collections.sort(l2);
    if (!l1.equals(l2)) {
        return false;
    }
    for (String key : l1) {
        Object val1 = js1.get(key);
        Object val2 = js2.get(key);
        if (val1 instanceof JSONObject) {
            if (!(val2 instanceof JSONObject)) {
                return false;
            }
            if (!jsonObjsAreEqual((JSONObject)val1, (JSONObject)val2)) {
                return false;
            }
        }

        if (val1 == null) {
            if (val2 != null) {
                return false;
            }
        }  else if (!val1.equals(val2)) {
            return false;
        }
    }
    return true;
}

1
Puisque vous avez mentionné des optimisations :), si val1est nul, vous obtiendrez une exception NullPointerException à partir de ce codeif (!val1.equals(val2)) {
JohnDoDo

Cela arrive aussi aux meilleurs d'entre nous :). +1 pour le corriger dans votre réponse.
JohnDoDo

point pris :) J'espère que cela n'obtiendra pas trop de votes, sinon ça va être beaucoup de soutien.
Victor Ionescu du

1
Vous n'avez pas considéré si js2oui nullou non quand js1n'est pasnull
Xiao

Ce code ne fonctionne pas pour les objets / séquences imbriqués.
FabienB

3

Vous pouvez utiliser la bibliothèque zjsonpatch , qui présente les informations de diff conformément à RFC 6902 (JSON Patch). Son très facile à utiliser. Veuillez visiter sa page de description pour son utilisation


2

Je prendrais la bibliothèque à http://json.org/java/ et modifierais la equalsméthode de JSONObject et JSONArray pour faire un test d'égalité approfondi. Pour vous assurer que cela fonctionne sans ordre de l'ordre des enfants, tout ce que vous avez à faire est de remplacer la carte intérieure par un TreeMap, ou d'utiliser quelque chose comme Collections.sort().


4
ce n'est pas terrible - il aurait vraiment dû venir avec du code pour faire une comparaison json.
Chii

Mais imaginez écrire ce code où JSON peut être n'importe quoi dans n'importe quelle structure ... écrivez la comparaison là-dessus! C'est comme écrire une comparaison pour tous les types de pages HTML.
JPM

2

Essaye ça:

public static boolean jsonsEqual(Object obj1, Object obj2) throws JSONException

    {
        if (!obj1.getClass().equals(obj2.getClass()))
        {
            return false;
        }

        if (obj1 instanceof JSONObject)
        {
            JSONObject jsonObj1 = (JSONObject) obj1;

            JSONObject jsonObj2 = (JSONObject) obj2;

            String[] names = JSONObject.getNames(jsonObj1);
            String[] names2 = JSONObject.getNames(jsonObj1);
            if (names.length != names2.length)
            {
                return false;
            }

            for (String fieldName:names)
            {
                Object obj1FieldValue = jsonObj1.get(fieldName);

                Object obj2FieldValue = jsonObj2.get(fieldName);

                if (!jsonsEqual(obj1FieldValue, obj2FieldValue))
                {
                    return false;
                }
            }
        }
        else if (obj1 instanceof JSONArray)
        {
            JSONArray obj1Array = (JSONArray) obj1;
            JSONArray obj2Array = (JSONArray) obj2;

            if (obj1Array.length() != obj2Array.length())
            {
                return false;
            }

            for (int i = 0; i < obj1Array.length(); i++)
            {
                boolean matchFound = false;

                for (int j = 0; j < obj2Array.length(); j++)
                {
                    if (jsonsEqual(obj1Array.get(i), obj2Array.get(j)))
                    {
                        matchFound = true;
                        break;
                    }
                }

                if (!matchFound)
                {
                    return false;
                }
            }
        }
        else
        {
            if (!obj1.equals(obj2))
            {
                return false;
            }
        }

        return true;
    }

dans jsonArrays, cela renvoie true si certains éléments coïncident, par opposition à tous les éléments coïncident.
matiasg

@matiasg - ne garantit-il if (obj1Array.length() != obj2Array.length())pas que tous les éléments coïncident?
kwah

3
@kwah: non. Considérez cet exemple: obj1Array = [1,1,1], obj2Array = [1,2,3]. Cela reviendrait vrai. De plus, même si les éléments coïncident, ils doivent être dans le même ordre. Cela retournerait vrai pour [1,2,3] et [2,3,1] aussi, ce qui est faux
matiasg


2

Le karaté est exactement ce que vous recherchez. Voici un exemple:

* def myJson = { foo: 'world', hey: 'ho', zee: [5], cat: { name: 'Billie' } }
* match myJson = { cat: { name: 'Billie' }, hey: 'ho', foo: 'world', zee: [5] }

(avertissement: dev ici)


2

Pour comparer jsons, je recommande d'utiliser JSONCompare: https://github.com/fslev/json-compare

// Compare by regex
String expected = "{\"a\":\".*me.*\"}";
String actual = "{\"a\":\"some text\"}";
JSONCompare.assertEquals(expected, actual);  // True

// Check expected array has no extra elements
String expected = "[1,\"test\",4,\"!.*\"]";
String actual = "[4,1,\"test\"]";
JSONCompare.assertEquals(expected, actual);  // True

// Check expected array has no numbers
String expected = "[\"\\\\\\d+\"]";
String actual = "[\"text\",\"test\"]";
JSONCompare.assertEquals(expected, actual);  // True

// Check expected array has no numbers
String expected = "[\"\\\\\\d+\"]";
String actual = "[2018]";
JSONCompare.assertNotEquals(expected, actual);  // True

0

Pour ceux comme moi qui souhaitent le faire avec Jackson, vous pouvez utiliser json-unit .

JsonAssert.assertJsonEquals(jsonNode1, jsonNode2);

Les erreurs donnent des informations utiles sur le type de non-concordance:

java.lang.AssertionError: JSON documents have different values:
Different value found in node "heading.content[0].tag[0]". Expected 10209, got 10206.

0

Rien d'autre ne semblait fonctionner correctement, alors j'ai écrit ceci:

private boolean jsonEquals(JsonNode actualJson, JsonNode expectJson) {
    if(actualJson.getNodeType() != expectJson.getNodeType()) return false;

    switch(expectJson.getNodeType()) {
    case NUMBER:
        return actualJson.asDouble() == expectJson.asDouble();
    case STRING:
    case BOOLEAN:
        return actualJson.asText().equals(expectJson.asText());
    case OBJECT:
        if(actualJson.size() != expectJson.size()) return false;

        Iterator<String> fieldIterator = actualJson.fieldNames();
        while(fieldIterator.hasNext()) {
            String fieldName = fieldIterator.next();
            if(!jsonEquals(actualJson.get(fieldName), expectJson.get(fieldName))) {
                return false;
            }
        }
        break;
    case ARRAY:
        if(actualJson.size() != expectJson.size()) return false;
        List<JsonNode> remaining = new ArrayList<>();
        expectJson.forEach(remaining::add);
        // O(N^2)   
        for(int i=0; i < actualJson.size(); ++i) {
            boolean oneEquals = false;
            for(int j=0; j < remaining.size(); ++j) {
                if(jsonEquals(actualJson.get(i), remaining.get(j))) {
                    oneEquals = true;
                    remaining.remove(j);
                    break;
                }
            }
            if(!oneEquals) return false;
        }
        break;
    default:
        throw new IllegalStateException();
    }
    return true;
}

0

Le code suivant sera plus utile pour comparer deux JsonObject, JsonArray, JsonPrimitive et JasonElements.

private 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++;
                    }
                }
            }

            // 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()) {
                if (json1.equals(json2)) {
                    return true;
                } else {
                    return false;
                }
            } else {
                return false;
            }
        } else if (json1 == null && json2 == null) {
            return true;
        } else {
            return false;
        }
        return isEqual;
    }


0

En regardant les réponses, j'ai essayé JSONAssert mais il a échoué. J'ai donc utilisé Jackson avec zjsonpatch. J'ai posté des détails dans la réponse SO ici .


-5

Cette solution pour moi, fonctionne très bien:

try {           
                // Getting The Array "Courses" from json1 & json2   
                Courses1 =json1.getJSONArray(TAG_COURSES1);
                Courses2 = json2.getJSONArray(TAG_COURSES);

                //LOOP FOR JSON1
                for(int i = 0; i < Courses1.length(); i++){
                    //LOOP FOR JSON2
                    for(int ii = 0; ii < Courses2.length(); ii++){
                        JSONObject courses1 = Courses1.getJSONObject(i);
                        JSONObject courses2 = Courses2.getJSONObject(ii);

                        // Storing each json1 item in variable
                        int courseID1 = courses1.getInt(TAG_COURSEID1);
                        Log.e("COURSEID2:", Integer.toString(courseID1));
                        String Rating1 = courses1.getString(TAG_RATING1);
                        int Status1 = courses1.getInt(TAG_STATUS1);
                        Log.e("Status1:", Integer.toString(Status1));      //Put the actual value for Status1 in log.             

                        // Storing each json2 item in variable
                        int courseID2 = courses2.getInt(TAG_COURSEID);
                        Log.e("COURSEID2:", Integer.toString(courseID));   //Put the actual value for CourseID in log
                        String Title2 = courses2.getString(TAG_TITLE);                      
                        String instructor2 = courses2.getString(TAG_INSTRUCTOR);
                        String length2 = courses2.getString(TAG_LENGTH);
                        String rating2 = courses2.getString(TAG_RATING);
                        String subject2 = courses2.getString(TAG_SUBJECT);
                        String description2 = courses2.getString(TAG_DESCRIPTION);

                        //Status1 = 5 from json1; Incomplete, Status1 =-1 Complete 
                        if(Status1 == 5 && courseID2 == courseID1){                                  

                        // creating new HashMap
                        HashMap<String, String> map = new HashMap<String, String>();         
                        //Storing the elements if condition is true.
                        map.put(TAG_COURSEID, Integer.toString(courseID2)); //pend for compare
                        map.put(TAG_TITLE, Title2);
                        map.put(TAG_INSTRUCTOR, instructor2);
                        map.put(TAG_LENGTH, length2);
                        map.put(TAG_RATING, rating2);
                        map.put(TAG_SUBJECT, subject2); //show it
                        map.put(TAG_DESCRIPTION, description2);

                        //adding HashList to ArrayList
                        contactList.add(map);
                        }//if
                    }//for2 (json2)
                } //for1 (json1)                
            }//Try

J'espère que cela aidera les autres.


bien sûr, il suffit de mettre vos valeurs et conditions, et le type de vue, dans ce cas; Hashmap sur une vue de liste.
JLouis

1
C'est un bel exemple pour savoir comment ne pas le faire :)
Petr Újezdský
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.