Prueba de dos objetos JSON para igualdad ignorando el orden secundario en Java


233

Estoy buscando una biblioteca de análisis JSON que admita la comparación de dos objetos JSON ignorando el orden secundario, específicamente para pruebas unitarias de JSON que regresan de un servicio web.

¿Alguna de las principales bibliotecas JSON admite esto? La biblioteca org.json simplemente hace una comparación de referencia.


1
¿No puede serializar ambos objetos para representar y comparar cadenas? Supongo que todas las bibliotecas admiten toString()convertir el objeto en JSONcadena.
Teja Kantamneni

47
Eso supone que el orden de serialización hacia y desde cadenas es siempre el mismo. No me siento cómodo haciendo esa suposición.
Jeff

Tienes razón Jeff, no es seguro en absoluto. Esta prueba muestra un escenario en el que las asignaciones son las mismas pero toString () no devuelve el mismo resultado: gist.github.com/anonymous/5974797 . Esto se debe a que el HashMap subyacente puede crecer, y si elimina las claves, la matriz interna de HashMap no se contrae.
Guillaume Perrot

Respuestas:


84

Como un punto arquitectónico general, generalmente aconsejo no permitir que las dependencias en un formato de serialización particular se desvanezcan más allá de su capa de almacenamiento / red; por lo tanto, primero recomendaría que considere probar la igualdad entre sus propios objetos de aplicación en lugar de sus manifestaciones JSON.

Dicho esto, actualmente soy un gran admirador de Jackson, y mi lectura rápida de su implementación ObjectNode.equals () sugiere la comparación de membresía establecida que desea:

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

Este método no es simétrico, ya que solo prueba la relación 'subconjunto' de los hijos, no la igualdad. el 'otro' objeto puede tener más hijos que en _niños, y este método aún sería verdadero.
Yoni

23
@Yoni: No es cierto, ya que hay una comparación de tamaño. Deben tener exactamente el mismo número de hijos y los mismos hijos. @Jolly Roger: en este caso, no estoy serializando el objeto de JSON en un POJO, pero cuando envío a JSON un sistema que lo hace, no puedo confiar en que lo envíe de vuelta exactamente en el mismo formato en el que envié eso.
Jeff

1
@ Jeff ¿Esto funcionó para ti? En junio, afirmar Equal falla para mí. El proyecto está utilizando una versión anterior (1.5), para su información.
ronnyfm

1
Creo que te estás perdiendo algunas pruebas de alto nivel si no estás afirmando JSON. Podría tener una prueba delgada que realiza una solicitud http y responde con algunos JSON esperados: es el comportamiento funcional principal del servicio web.
mogronalol

Solo una pequeña nota con respecto al rendimiento: el código que compara 'valor' con 'otherValue' se puede simplificar a if (value.equals (other.get (key)) devuelve falso; ya que 'value' se garantiza que no es nulo y El método equals () de JsonNode debería aceptar un argumento nulo.
Tillmann

154

Prueba el JSONAssert de Skyscreamer .

Su modo no estricto tiene dos ventajas principales que lo hacen menos frágil:

  • Extensibilidad del objeto (por ejemplo, con un valor esperado de {id: 1} , esto todavía pasaría: {id: 1, moredata: 'x'} .)
  • Orden de matriz suelta (por ejemplo, ['perro', 'gato'] == ['gato', 'perro'])

En modo estricto, se comporta más como la clase de prueba de json-lib.

Una prueba se parece a esto:

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

Los parámetros de los JSONAssert.assertEquals () llamada se expectedJSONString , actualDataString y isStrict .

Los mensajes de resultados son bastante claros, lo cual es importante cuando se comparan objetos JSON realmente grandes.


18
He estado usando esta solución, pero acabo de descubrir que también puede proporcionar un JSONCompareMode de su elección. Uno de los cuales es NON_EXTENSIBLE. Entonces tendría algo como esto: JSONAssert.assertEquals(expected, data, JSONCompareMode.NON_EXTENSIBLE);el modo NON_EXTENSIBLE significa que los campos nuevos o faltantes causan fallas, pero el orden no. El uso de falso instigaría el modo indulgente que no informaría ningún elemento secundario extra o faltante.
Dan Temple

1
El modo de comparación NON_EXTENSIBLE es exactamente lo que estaba buscando. Gracias por esto, Dan.
ThoughtCrhyme

Antes de entusiasmarme: ¿esto también admite objetos y matrices JSON anidados? :)
Christian

2
Es posible que las personas quieran tener en cuenta este problema de JSONassert antes de usar la biblioteca: indica que actualmente hay posibles problemas de licencia con una dependencia de la biblioteca.
Chriki

3
El problema # 44 de JSONAssert se solucionó con el reemplazo de la biblioteca de sala limpia en PR 67, lanzado hoy como JSONAssert 1.4.0.
Carter Page

49

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

Editar: desde GSON v2.8.6, el método de instancia JsonParser.parseestá en desuso. Tienes que usar el método estático JsonParser.parseString:

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

Funciona en GSON 2.8.2 para mí.
Tom Saleeba

1
no funciona si los elementos jsonArray no están en orden. versión 2.8.2
Naveen Kumar RB

1
No funciona para mí si el orden del objeto / elemento es diferente
Jknair

Funcionó para mí porque solo lo quería para una prueba unitaria donde las dos propiedades jsons tenían el mismo orden
GabrielBB

@GabrielBB Debería editar la pregunta e indicar en qué versión está desaprobada la API y en qué versión comienza a funcionar el nuevo estilo de código.
clearlight

30

Yo haría lo siguiente,

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 ya estás usando Jackson, esta es la mejor respuesta en mi humilde opinión.
Christoph Dietze

18
pero esta es una comparación estricta, creo. Devuelve falso para dos json iguales que tienen un orden diferente de elementos.
deadpool

@deadpool el principio es sólido, solo necesitaría cambiar la comparación para estar más involucrado (por ejemplo, buscando campos clave en lugar de simples iguales de los árboles).
Jwenting

Esta es la mejor respuesta de todas. No solo responde a mi pregunta ahora, sino que también responde a casi todas las comparaciones de objetos que necesitamos hacer. gracias joshu
Luiz Feijão Veronesi

2
@deadpool, puede haber sido una comparación estricta, pero ahora no lo es.
Andrei Damian-Fekete

18

Puede intentar usar la clase JSONAssert de json-lib :

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

Da:

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

O incluso más simple: JSONAssert.assertJsonEquals ("{foo: 'bar', baz: 'qux'}", {foo: 'bar', baz: 'xyzzy'} ");
Rob Juurlink

2
Si bien esta solución funciona para el orden de los elementos de datos dentro del JSON, fallará si el orden de los elementos dentro de las matrices no coincide. Si su código usa un conjunto que se convierte a JSON, por ejemplo. La siguiente comparación JSON fallaría: JSONAssert.assertJsonEquals( "{foo: 'bar', list: [{test: '1'}, {rest: '2'}] }", "{ foo: 'bar', list: [{rest: '2'}, {test: '1'}] }"); Con el mensaje:junit.framework.AssertionFailedError: : : objects differed at key [list];: arrays first differed at element [0];: objects differed at key [test];
Dan Temple

Sí, esta es una limitación de Json :(. Json.org muestra que no hay un token de colección desordenado. {} Solo puede rodear pares clave-valor. Esto es muy irritante
Merk

15

Use esta biblioteca: 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 el orden en las matrices

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

¿Puedes agregar más comentarios sobre cómo podemos usarlo? Lo agrego a mi pom, pero necesitamos un documento para entender cómo usarlo
Ran Adler

el uso seguro es muy simple: agregue esto a su pom. <dependency> <groupId> net.javacrumbs.json-unit </groupId> <artifactId> json-unit </artifactId> <version> 1.5.0 </version> <scope> test </scope> </dependency>
chethu

10 veces he visto las instrucciones en el enlace y lo he encontrado :)
Ran Adler

12

Si ya está utilizando JUnit, la última versión ahora emplea Hamcrest. Es un marco genérico de coincidencia (especialmente útil para pruebas unitarias) que se puede ampliar para crear nuevos emparejadores.

Hay una pequeña biblioteca de código abierto llamada hamcrest-jsoncon coincidencias compatibles con JSON. Está bien documentado, probado y respaldado. A continuación hay algunos enlaces útiles:

Código de ejemplo usando objetos de la biblioteca JSON org.json.simple:

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

Opcionalmente, puede (1) permitir matrices de "cualquier orden" e (2) ignorar campos adicionales.

Puesto que hay una variedad de bibliotecas JSON para Java ( Jackson, GSON, json-lib, etc.), es útil que hamcrest-jsonel texto JSON soportes (como java.lang.String), los objetos, así como de forma nativa soporte de la biblioteca JSON de Douglas Crockford org.json.

Finalmente, si no está usando JUnit, puede usar Hamcrest directamente para afirmaciones. ( Escribí sobre esto aquí ) .


¿Cuál es la ventaja de usar los emparejadores de hamcrast en lugar de usar el JSONAssert directamente?
Johannes

2
@Johannes: solo estilo.
kevinarpe

Las fuentes de hamcrest-json actualmente tienen una última fecha de confirmación de 2012. Puede que ya no sea tan compatible.
Thorbjørn Ravn Andersen

11

Puedes probar JsonUnit . Puede comparar dos objetos JSON e informar diferencias. Está construido encima de Jackson.

Por ejemplo

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

Resultados en

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

6

Una cosa que hice y que funciona de maravilla es leer ambos objetos en HashMap y luego compararlos con un aserciónEquals () regular. Llamará al método equals () de los hashmaps, que comparará recursivamente todos los objetos dentro (serán otros hashmaps o algún objeto de valor único como una cadena o un entero). Esto se hizo usando el analizador Jackson JSON de Codehaus.

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

Se puede usar un enfoque similar si el objeto JSON es una matriz en su lugar.


6

Estoy usando esto, y funciona bien para mí (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

Para org.json, implementé mi propia solución, un método que se compara con las instancias de JSONObject. No trabajé con objetos JSON complejos en ese proyecto, por lo que no sé si esto funciona en todos los escenarios. Además, dado que uso esto en pruebas unitarias, no puse esfuerzo en las optimizaciones. Aquí está:

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
Como mencionó las optimizaciones :), si val1es nulo, obtendrá un NullPointerException de este códigoif (!val1.equals(val2)) {
JohnDoDo

Le pasa a los mejores de nosotros también :). +1 por arreglarlo en tu respuesta.
JohnDoDo

punto tomado :) Espero que no reciba demasiados votos, de lo contrario será un gran apoyo.
Victor Ionescu

1
No consideró si js2es nullo no cuando js1no lo esnull
Xiao

Este código no funciona para objetos / secuencias anidadas.
FabienB

3

Puede usar la biblioteca zjsonpatch , que presenta la información de diferencias de acuerdo con RFC 6902 (parche JSON). Es muy fácil de usar. Visite su página de descripción para su uso.


2

Tomaría la biblioteca en http://json.org/java/ , y modificaría el equalsmétodo de JSONObject y JSONArray para hacer una prueba de igualdad profunda. Para asegurarse de que funciona sin graduación del orden de los hijos, todo lo que necesita hacer es reemplazar el mapa interno con a TreeMap, o usar algo como Collections.sort().


44
no es tan genial, realmente debería haber venido con código para hacer una comparación json.
Chii

Pero imagine escribir ese código donde JSON puede ser cualquier cosa en cualquier estructura ... ¡escriba la comparación en eso! Es como escribir una comparación para todos los tipos de páginas HTML.
JPM

2

Prueba esto:

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

dentro de jsonArrays, esto devuelve verdadero si algunos de los elementos coinciden, a diferencia de todos los elementos coinciden.
matiasg

@matiasg: ¿ if (obj1Array.length() != obj2Array.length())no garantiza que todos los elementos coincidan?
kwah

3
@kwah: no. Considere este ejemplo: obj1Array = [1,1,1], obj2Array = [1,2,3]. Esto volvería a ser cierto. Además, incluso si los elementos coinciden, deben estar en el mismo orden. Esto también sería cierto para [1, 2, 3] y [2, 3, 1], lo cual está mal
matiasg


2

Karate es exactamente lo que estás buscando. Aquí hay un ejemplo:

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

(descargo de responsabilidad: dev aquí)


2

Para comparar jsons, recomiendo usar 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

Para aquellos como yo que quieran hacer esto con Jackson, pueden usar json-unit .

JsonAssert.assertJsonEquals(jsonNode1, jsonNode2);

Los errores brindan comentarios útiles sobre el tipo de desajuste:

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

0

Nada más parecía funcionar bien, así que escribí esto:

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

El siguiente código será más útil para comparar dos JsonObject, JsonArray, JsonPrimitive y 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

Mirando las respuestas, probé JSONAssert pero falló. Así que usé Jackson con zjsonpatch. Publiqué detalles en la respuesta SO aquí .


-5

Esta solución para mí, el trabajo es muy bueno:

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

Espero que esto ayude a otros.


por supuesto, simplemente ponga sus valores y condiciones, y el tipo de vista, en este caso; Hashmap sobre una vista de lista.
JLouis

1
Este es un buen ejemplo de cómo no hacerlo :)
Petr Újezdský
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.