Test di due oggetti JSON per l'uguaglianza ignorando l'ordine figlio in Java


233

Sto cercando una libreria di analisi JSON che supporti il ​​confronto tra due oggetti JSON ignorando l'ordine figlio, in particolare per il test di unità JSON che ritorna da un servizio web.

Qualcuno delle principali librerie JSON lo supporta? La libreria org.json fa semplicemente un confronto di riferimento.


1
Non è possibile serializzare entrambi gli oggetti per rappresentare e confrontare le stringhe? Immagino che tutte le librerie supportino la toString()conversione dell'oggetto in JSONstringa.
Teja Kantamneni,

47
Ciò presuppone che l'ordine sulla serializzazione da e verso le stringhe sia sempre lo stesso. Non mi sento a mio agio nel fare questa ipotesi.
Jeff,

Hai ragione Jeff, non è affatto sicuro. Questo test mostra uno scenario in cui i mapping sono uguali ma toString () non restituisce lo stesso output: gist.github.com/anonymous/5974797 . Questo perché l'HashMap sottostante può crescere e se si rimuovono le chiavi, l'array interno di HashMap non si riduce.
Guillaume Perrot,

Risposte:


84

Come punto generale di architettura, di solito sconsiglio di lasciare fuoriuscire le dipendenze da un particolare formato di serializzazione oltre il livello di archiviazione / rete; pertanto, per prima cosa ti consiglio di considerare di testare l'uguaglianza tra i tuoi oggetti applicativi piuttosto che le loro manifestazioni JSON.

Detto questo, al momento sono un grande fan di Jackson che la mia rapida lettura della loro implementazione ObjectNode.equals () suggerisce fa il confronto tra le appartenenze impostato che desideri:

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

Questo metodo non è simmetrico, in quanto verifica solo la relazione "secondaria" dei bambini, non l'uguaglianza. l'oggetto "altro" potrebbe avere più figli rispetto a _children, e questo metodo restituirà comunque true.
Yoni,

23
@Yoni: non è vero, poiché esiste un confronto delle dimensioni. Devono avere lo stesso numero esatto di bambini e gli stessi bambini. @Jolly Roger: In questo caso, non sto serializzando l'oggetto da JSON in un POJO, ma quando invio a JSON un sistema che funziona, non posso fare affidamento sul fatto che lo rispedisca nello stesso identico formato in cui ho inviato esso.
Jeff,

1
@Jeff Ha funzionato per te? In junit, assertEquals fallisce per me. Il progetto utilizza una versione precedente (1.5), fyi.
ronnyfm,

1
Penso che ti manchi qualche test di alto livello se non stai affermando JSON. Potresti avere un test sottile che fa una richiesta http e risponde con alcuni JSON previsti: è il comportamento funzionale principale del servizio web.
mogronalol,

Solo una piccola nota relativa alle prestazioni: il codice che confronta "valore" con "otherValue" può essere semplificato se (value.equals (other.get (chiave)) restituisce false; poiché "value" è garantito non-null e Il metodo equals () di JsonNode dovrebbe accettare un argomento nullo.
Tillmann

154

Prova JSONAssert di Skyscreamer .

La sua modalità non rigorosa presenta due vantaggi principali che la rendono meno fragile:

  • Estensibilità dell'oggetto (ad es. Con un valore atteso di {id: 1} , ciò passerebbe comunque: {id: 1, moredata: 'x'} .)
  • Ordinamento di array allentati (ad es. ['Cane', 'gatto'] == ['gatto', 'cane'])

In modalità rigorosa si comporta più come la classe di test di json-lib.

Un test è simile al seguente:

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

I parametri nelle JSONAssert.assertEquals () chiamata sono expectedJSONString , actualDataString e isStrict .

I messaggi dei risultati sono piuttosto chiari, il che è importante quando si confrontano oggetti JSON veramente grandi.


18
Sto usando questa soluzione, ma ho appena scoperto che potresti anche fornire una modalità JSONCompare di tua scelta. Uno dei quali è NON_EXTENSIBLE. Quindi avresti qualcosa del genere: JSONAssert.assertEquals(expected, data, JSONCompareMode.NON_EXTENSIBLE);la modalità NON_EXTENSIBLE significa che qualsiasi campo nuovo o mancante causa errori, ma l'ordine no. L'utilizzo di false implicherebbe la modalità clemente che non riporterebbe alcun elemento figlio aggiuntivo o mancante.
Dan Temple

1
La modalità di confronto NON_EXTENSIBLE è esattamente quello che stavo cercando. Grazie per questo, Dan.
ThoughtCrhyme,

Prima di emozionarmi: supporta anche oggetti e matrici JSON nidificati? :)
Christian

2
Le persone potrebbero voler prendere in considerazione questo problema JSONassert prima di utilizzare la libreria: indica che attualmente ci sono potenziali problemi di licenza con una dipendenza della libreria.
Chriki,

3
Il problema n. 44 di JSONAssert è stato risolto con la sostituzione della libreria per camera bianca in PR 67, rilasciata oggi come JSONAssert 1.4.0.
Pagina Carter,

49

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

Modifica: da GSON v2.8.6 il metodo dell'istanza JsonParser.parseè obsoleto. Devi usare il metodo statico JsonParser.parseString:

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

Funziona in GSON 2.8.2 per me.
Tom Saleeba,

1
non funziona se gli elementi jsonArray non sono in ordine. versione 2.8.2
Naveen Kumar RB

1
Non funziona per me se l'ordine dell'oggetto / elemento è diverso
Jknair,

Ha funzionato per me perché lo volevo solo per un test unitario in cui le proprietà dei due json avevano lo stesso ordine
GabrielBB

@GabrielBB Dovresti modificare la domanda e indicare in quale versione l'API è obsoleta e in quale versione inizia a funzionare il nuovo stile di codice.
chiarimento

30

Vorrei fare quanto segue,

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

Se stai già usando Jackson, questa è la risposta migliore IMHO.
Christoph Dietze,

18
ma questo è un confronto rigoroso penso. Restituirà falso per due uguali json con diverso ordine di elementi.
Deadpool,

@deadpool il principio è valido, dovresti solo cambiare il confronto per essere più coinvolto (controllando per esempio i campi chiave anziché un semplice uguale degli alberi).
jwenting

Questa è la migliore risposta di sempre. Non solo risponde alla mia domanda ora, poiché risponde anche a quasi ogni confronto di oggetti che dobbiamo fare. grazie, Joshu.
Luiz Feijão Veronesi,

2
@deadpool, potrebbe essere stato un confronto rigoroso, ma non è adesso severo.
Andrei Damian-Fekete,

18

Potresti provare a usare la classe JSONAssert di json-lib :

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

dà:

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

O ancora più semplice: JSONAssert.assertJsonEquals ("{foo: 'bar', baz: 'qux'}", {foo: 'bar', baz: 'xyzzy'} ");
Rob Juurlink

2
Mentre questa soluzione funziona per l'ordine degli elementi di dati all'interno di JSON, fallirà se l'ordine degli elementi all'interno di array non corrisponde. Ad esempio, se il codice utilizza un set convertito in JSON. Il seguente confronto JSON fallirebbe: JSONAssert.assertJsonEquals( "{foo: 'bar', list: [{test: '1'}, {rest: '2'}] }", "{ foo: 'bar', list: [{rest: '2'}, {test: '1'}] }"); Con il messaggio:junit.framework.AssertionFailedError: : : objects differed at key [list];: arrays first differed at element [0];: objects differed at key [test];
Dan Temple

Sì, questa è una limitazione di Json :(. Json.org mostra che non esiste un token di raccolta non ordinato. {} Può solo circondare coppie chiave-valore. Questo è molto irritante
Merk,

15

Utilizzare questa libreria: 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: ignora l'ordine nelle matrici

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

puoi aggiungere altri commenti come possiamo usarlo lo aggiungo al mio pom ma abbiamo bisogno di doc per capire come usarlo
Ran Adler

sicuramente l'utilizzo è molto semplice: aggiungi questo al tuo pom. <dependency> <groupId> net.javacrumbs.json-unit </groupId> <artifactId> json-unit </artifactId> <version> 1.5.0 </version> <scope> test </scope> </dependency>
chethu,

10x ho guardato le istruzioni sul link e l'ho trovato :)
Ran Adler

12

Se stai già utilizzando JUnit, l'ultima versione ora impiega Hamcrest. È un framework di matching generico (particolarmente utile per i test unitari) che può essere esteso per costruire nuovi matcher.

Esiste una piccola libreria open source chiamata hamcrest-jsoncon corrispondenze compatibili con JSON. È ben documentato, testato e supportato. Di seguito sono riportati alcuni link utili:

Codice di esempio che utilizza oggetti dalla libreria JSON org.json.simple:

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

Facoltativamente, è possibile (1) consentire matrici di "qualsiasi ordine" e (2) ignorare i campi aggiuntivi.

Dato che ci sono una serie di librerie JSON per Java ( Jackson, GSON, json-lib, ecc), è utile che hamcrest-jsonil testo supporta JSON (come java.lang.String), gli oggetti così come nativo di supporto dalla libreria JSON di Douglas Crockford org.json.

Infine, se non si utilizza JUnit, è possibile utilizzare Hamcrest direttamente per le asserzioni. ( Ne ho scritto qui. )


Qual è il vantaggio di usare i matcher hamcrast invece di usare direttamente JSONAssert?
Johannes

2
@Johannes: solo stile.
kevinarpe,

Le fonti hamcrest-json attualmente hanno una data di ultimo commit del 2012. Potrebbe non essere più così ben supportato.
Thorbjørn Ravn Andersen,

11

Puoi provare JsonUnit . Può confrontare due oggetti JSON e segnalare differenze. È costruito sopra Jackson.

Per esempio

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

Risultati in

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

6

Una cosa che ho fatto e funziona a meraviglia è leggere entrambi gli oggetti in HashMap e confrontarli con un assertEquals () regolare. Chiamerà il metodo equals () degli hashmaps, che confronterà in modo ricorsivo tutti gli oggetti all'interno (saranno o altri hashmaps o qualche oggetto a valore singolo come una stringa o un numero intero). Questo è stato fatto usando il parser Jackson JSON di Codehaus.

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

Un approccio simile può essere utilizzato se l'oggetto JSON è invece un array.


6

Lo sto usando e funziona bene per me (con 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

Per org.json ho implementato la mia soluzione, un metodo paragonabile alle istanze di JSONObject. Non ho lavorato con oggetti JSON complessi in quel progetto, quindi non so se funziona in tutti gli scenari. Inoltre, dato che lo uso nei test unitari, non ho fatto sforzi per ottimizzare. Ecco qui:

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
Dato che hai citato ottimizzazioni :), se val1è null otterrai una NullPointerException da questo codiceif (!val1.equals(val2)) {
JohnDoDo

Succede anche al migliore di noi :). +1 per averlo corretto nella tua risposta.
JohnDoDo,

punto preso :) Spero che non ottenga troppi voti, altrimenti sarà molto supporto.
Victor Ionescu,

1
Non hai considerato se lo js2è nullo no quando js1non lo ènull
Xiao

Questo codice non funziona per oggetti / sequenze nidificati.
FabienB,

3

È possibile utilizzare la libreria zjsonpatch , che presenta le informazioni diff secondo RFC 6902 (patch JSON). È molto facile da usare. Si prega di visitare la sua pagina di descrizione per il suo utilizzo


2

Prenderei la libreria su http://json.org/java/ e modificherei il equalsmetodo di JSONObject e JSONArray per fare un test di uguaglianza profonda. Per assicurarti che funzioni indipendentemente dall'ordine dei bambini, tutto ciò che devi fare è sostituire la mappa interna con una TreeMapo usare qualcosa di simile Collections.sort().


4
non è eccezionale - dovrebbe davvero venire con il codice per fare il confronto JSON.
Chii,

Ma immagina di scrivere quel codice in cui JSON può essere qualsiasi cosa in qualsiasi struttura ... scrivi il confronto su quello! È come scrivere un confronto per tutti i tipi di pagine HTML.
JPM,

2

Prova questo:

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

all'interno di jsonArrays questo ritorna vero se alcuni degli elementi coincidono, al contrario di tutti gli elementi coincidono.
matiasg,

@matiasg - if (obj1Array.length() != obj2Array.length())non garantisce che tutti gli elementi coincidano?
kwah

3
@kwah: no. Considera questo esempio: obj1Array = [1,1,1], obj2Array = [1,2,3]. Ciò ritornerebbe vero. Inoltre, anche se gli elementi coincidono, dovrebbero essere nello stesso ordine. Ciò sarebbe vero anche per [1,2,3] e [2,3,1], il che è sbagliato
matiasg


2

Il karate è esattamente quello che stai cercando. Ecco un esempio:

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

(dichiarazione di non responsabilità: dev qui)


2

Per confrontare jsons consiglio di usare 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

Per quelli come me che vogliono farlo con Jackson, puoi usare json-unit .

JsonAssert.assertJsonEquals(jsonNode1, jsonNode2);

Gli errori forniscono un feedback utile sul tipo di mancata corrispondenza:

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

0

Nient'altro sembrava funzionare abbastanza bene, quindi ho scritto questo:

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

Il seguente codice sarà più utile per confrontare due JsonObject, JsonArray, JsonPrimitive e 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

Guardando le risposte, ho provato JSONAssert ma non è riuscito. Quindi ho usato Jackson con zjsonpatch. Ho pubblicato i dettagli nella risposta SO qui .


-5

Questa soluzione per me funziona molto bene:

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

Spero che questo aiuti gli altri.


ovviamente, metti solo i tuoi valori e condizioni, e il tipo di vista, in questo caso; Hashmap su una visualizzazione elenco.
JLouis,

1
Questo è un buon esempio di come non farlo :)
Petr Újezdský,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.