Testando dois objetos JSON para igualdade, ignorando a ordem dos filhos em Java

233

Estou procurando uma biblioteca de análise JSON que suporte a comparação de dois objetos JSON que ignoram a ordem dos filhos, especificamente para testar a unidade JSON retornando de um serviço da web.

Alguma das principais bibliotecas JSON suporta isso? A biblioteca org.json simplesmente faz uma comparação de referência.

Jeff
fonte
1
Não é possível serializar os dois objetos para representar e comparar cadeias? Eu acho que todas as bibliotecas suportam toString()para converter o objeto em JSONstring.
Teja Kantamneni
47
Isso pressupõe que a ordem na serialização para e de seqüências de caracteres seja sempre a mesma. Eu não estou confortável fazendo essa suposição.
1211 Jeff Jeff
Você está certo Jeff, não é seguro. Este teste mostra um cenário em que os mapeamentos são iguais, mas toString () não retorna a mesma saída: gist.github.com/anonymous/5974797 . Isso ocorre porque o HashMap subjacente pode aumentar e, se você remover chaves, a matriz interna do HashMap não diminui.
precisa

Respostas:

84

Como ponto de arquitetura geral, geralmente não aconselho a deixar dependências em um formato de serialização específico ir além da camada de armazenamento / rede; portanto, primeiro recomendo que você considere testar a igualdade entre seus próprios objetos de aplicativo em vez de suas manifestações JSON.

Dito isto, atualmente sou um grande fã de Jackson, o que minha leitura rápida da implementação de ObjectNode.equals () sugere que a comparação de associação definida que você deseja:

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;
}
Jolly Roger
fonte
Esse método não é simétrico, pois apenas testa a relação de 'subconjunto' dos filhos, não a igualdade. o objeto 'outro' pode ter mais filhos do que em _children, e esse método ainda retornaria verdadeiro.
Yoni
23
@ Yoni: Não é verdade, pois há uma comparação de tamanho. Eles devem ter exatamente o mesmo número de filhos e os mesmos filhos. @Jolly Roger: Nesse caso, não estou serializando o objeto JSON de volta para um POJO, mas ao enviar para JSON um sistema compatível, não posso confiar nele enviando-o de volta exatamente no mesmo formato em que enviei isto.
Jeff
1
@ Jeff Isso funcionou para você? Em junho, assertEquals falhará para mim. O projeto está usando uma versão antiga (1.5), fyi.
Ronnyfm
1
Acho que você está perdendo alguns testes de alto nível se não está afirmando o JSON. Você pode ter um teste fino que faz uma solicitação http e responde com algum JSON esperado - é o principal comportamento funcional do serviço da web.
mogronalol 7/09/16
Apenas uma pequena nota sobre desempenho: o código que compara 'valor' com 'outroValor' pode ser simplificado para se (valor.equals (outro.get (chave)) retornar falso; como 'valor' é garantido como não nulo e iguais de JsonNode () método deve aceitar um argumento nulo.
Tillmann
154

Experimente o JSONAssert do Skyscreamer .

Seu modo não estrito possui duas vantagens principais que o tornam menos quebradiço:

  • Extensibilidade do objeto (por exemplo, com um valor esperado de {id: 1} , isso ainda passaria: {id: 1, moredata: 'x'} .)
  • Ordenação de matriz solta (por exemplo, ['cachorro', 'gato'] == ['gato', 'cachorro'])

No modo estrito, ele se comporta mais como a classe de teste do json-lib.

Um teste é mais ou menos assim:

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

Os parâmetros na chamada JSONAssert.assertEquals () são esperado : JSONString , actualDataString e isStrict .

As mensagens de resultado são bastante claras, o que é importante ao comparar objetos JSON realmente grandes.

Carter Page
fonte
18
Estou usando esta solução, mas acabei de descobrir que você também pode fornecer um JSONCompareMode de sua escolha. Um deles é NON_EXTENSIBLE. Portanto, você terá algo assim: JSONAssert.assertEquals(expected, data, JSONCompareMode.NON_EXTENSIBLE);O modo NON_EXTENSIBLE significa que qualquer campo novo ou ausente causa falhas, mas o pedido não. O uso de false instigaria o modo branda, que não relataria nenhum elemento filho extra ou ausente.
Dan Temple
1
O modo de comparação NON_EXTENSIBLE é exatamente o que eu estava procurando. Obrigado por isso, Dan.
ThoughtCrhyme
Antes de me animar: isso também suporta objetos e matrizes JSON aninhados? :)
Christian
2
As pessoas podem querer considerar esse problema JSONassert antes de usar a biblioteca: indica que atualmente há problemas de licenciamento em potencial com uma dependência da biblioteca.
Chriki
3
O problema nº 44 do JSONAssert foi corrigido com a substituição da biblioteca de sala limpa no PR 67, lançada hoje como JSONAssert 1.4.0.
Carter Página
49

Usando o 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: Desde o GSON v2.8.6, o método da instância JsonParser.parseestá obsoleto. Você precisa usar o 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);
axelhzf
fonte
Funciona no GSON 2.8.2 para mim.
precisa saber é o seguinte
1
não está funcionando se os elementos jsonArray não estiverem em ordem. versão 2.8.2
Naveen Kumar RB
1
Não trabalho para mim se a ordem do objeto / elemento é diferente
Jknair
Funcionou para mim porque eu só queria um teste de unidade em que as duas propriedades jsons tivessem a mesma ordem
GabrielBB 16/01
@ GabrielBB Você deve editar a pergunta e indicar em qual versão a API está obsoleta e em qual versão o novo estilo de código começa a funcionar.
clearlight
30

Eu faria o seguinte,

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);
Josh
fonte
Se você já usa o Jackson, esta é a melhor resposta para IMHO.
Christoph Dietze
18
mas acho que é uma comparação estrita. Ele retornará false para dois json iguais com ordem de elementos diferente.
Deadpool 5/05
@deadpool o princípio é sólido, você só precisa alterar a comparação para se envolver mais (checar por campos-chave, por exemplo, em vez de simplesmente iguais às árvores).
jwenting
Esta é a melhor resposta de todas. Agora, ele não apenas responde à minha pergunta, como também responde quase todas as comparações de objetos que precisamos fazer. obrigado, Josué.
Luiz Feijão Veronesi 31/08
2
@ Deadpool, pode ter sido uma comparação estrita, mas não é estrita agora.
Andrei Damian-Fekete 28/03
18

Você pode tentar usar a classe JSONAssert do 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]>
hertzsprung
fonte
Ou ainda mais simples: JSONAssert.assertJsonEquals ("{foo: 'bar', baz: 'qux'}", {foo: 'bar', baz: 'xyzzy'} ");
Rob Juurlink
2
Se essa solução funcionar para a ordem dos itens de dados no JSON, ela falhará se a ordem dos elementos nas matrizes não corresponder. Se seu código usar um conjunto que é convertido em JSON, por exemplo. A seguinte comparação JSON falharia: JSONAssert.assertJsonEquals( "{foo: 'bar', list: [{test: '1'}, {rest: '2'}] }", "{ foo: 'bar', list: [{rest: '2'}, {test: '1'}] }"); Com a mensagem:junit.framework.AssertionFailedError: : : objects differed at key [list];: arrays first differed at element [0];: objects differed at key [test];
Dan Temple
Sim, essa é uma limitação do Json :(. Json.org mostra que não há token de coleção desordenado. {} Só pode envolver pares de valores-chave. Isso é altamente 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 a ordem nas matrizes

assertJsonEquals("{\"test\":[1,2,3]}",
  "{\"test\":  [3,2,1]}",
  when(IGNORING_ARRAY_ORDER)
);
chethu
fonte
você pode adicionar mais comentário como podemos usá-lo eu adicioná-lo ao meu pom mas precisamos doc para entender como usá-lo
Ran Adler
certeza de que o uso é muito simples: adicione isso ao seu pom. <dependency> <groupId> net.javacrumbs.json-unit </groupId> <artifactId> unidade json </artifactId> <versão> 1.5.0 </version> <scope> test </scope> </dependency>
chethu 4/04
10x Eu olhei para a instrução no link e eu achei :)
Ran Adler
12

Se você já está usando o JUnit, a versão mais recente agora emprega o Hamcrest. É uma estrutura de correspondência genérica (especialmente útil para testes de unidade) que pode ser estendida para criar novos correspondentes.

Há uma pequena biblioteca de código aberto chamada hamcrest-jsoncom correspondências compatíveis com JSON. Está bem documentado, testado e suportado. Abaixo estão alguns links úteis:

Código de exemplo usando objetos da biblioteca JSON org.json.simple:

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

Opcionalmente, você pode (1) permitir matrizes de "qualquer ordem" e (2) ignorar campos extras.

Uma vez que há uma variedade de bibliotecas JSON para Java ( Jackson, GSON, json-lib, etc.), é útil que hamcrest-jsono texto suportes JSON (como java.lang.String), objetos, bem como nativamente suporte da biblioteca JSON de Douglas Crockford org.json.

Por fim, se você não estiver usando o JUnit, poderá usar o Hamcrest diretamente para asserções. ( Eu escrevi sobre isso aqui. )

kevinarpe
fonte
Qual é a vantagem de usar correspondências de hamcrast em vez de usar o JSONAssert diretamente?
Johannes
2
@ Jones: Apenas estilo.
Kevinarpe
As fontes hamcrest-json atualmente têm uma última data de confirmação de 2012. Talvez não seja mais tão bem suportado.
Thorbjørn Ravn Andersen
11

Você pode tentar o JsonUnit . Pode comparar dois objetos JSON e relatar diferenças. É construído em cima de Jackson.

Por exemplo

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

Resulta em

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

Uma coisa que fiz e faz maravilhas é ler os dois objetos no HashMap e comparar com um assertEquals () regular. Ele chamará o método equals () dos hashmaps, que comparará recursivamente todos os objetos internos (eles serão outros hashmaps ou algum objeto de valor único, como uma string ou um número inteiro). Isso foi feito usando o analisador Jackson JSON da Codehaus.

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

Uma abordagem semelhante pode ser usada se o objeto JSON for uma matriz.

Claudio Aguiar
fonte
6

Estou usando isso e funciona bem para mim (com 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;
        }
    }
}
Apanhador
fonte
4

Para org.json, implantei minha própria solução, um método que se compara às instâncias JSONObject. Como não trabalhei com objetos JSON complexos nesse projeto, não sei se isso funciona em todos os cenários. Além disso, como utilizo isso em testes de unidade, não dediquei esforços às otimizações. Aqui 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;
}
Victor Ionescu
fonte
1
Desde que você mencionou otimizações :), se val1é nulo você receberá um NullPointerException deste códigoif (!val1.equals(val2)) {
JohnDoDo
Isso acontece com os melhores de nós também :). +1 para corrigi-lo em sua resposta.
31412 JohnDoDo
ponto tomado :) Espero que não receba muitos votos, caso contrário será muito apoio.
Victor Ionescu
1
Você não considerar se js2é nullou não quando js1não énull
Xiao
Este código não funciona para objetos / seqüências aninhados.
FabienB
3

Você pode usar a biblioteca zjsonpatch , que apresenta as informações diferenciais de acordo com o RFC 6902 (JSON Patch). É muito fácil de usar. Por favor, visite sua página de descrição para seu uso

Gopi Vishwakarma
fonte
2

Eu pegaria a biblioteca em http://json.org/java/ e modificaria o equalsmétodo JSONObject e JSONArray para fazer um teste de igualdade profunda. Para garantir que ele funcione sem ordem de ordem dos filhos, tudo o que você precisa fazer é substituir o mapa interno por a TreeMapou usar algo parecido Collections.sort().

Yoni
fonte
4
não é tão bom - ele realmente deveria ter vindo com código para fazer a comparação do json.
Chii
Mas imagine escrever esse código onde JSON pode ser qualquer coisa em qualquer estrutura ... escreva a comparação nisso! É como escrever uma comparação para todos os tipos de páginas HTML.
JPM
2

Tente o seguinte:

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;
    }
Misha
fonte
dentro de jsonArrays, isso retornará true se alguns dos elementos coincidirem, ao contrário de todos os elementos coincidirem.
18714 Matiasg
@matiasg - if (obj1Array.length() != obj2Array.length())não garante que todos os elementos coincidam?
Kwah 19/08
3
@kwah: não. Considere este exemplo: obj1Array = [1,1,1], obj2Array = [1,2,3]. Isso retornaria verdadeiro. Além disso, mesmo que os elementos coincidam, eles devem estar na mesma ordem. Isto iria retornar verdadeiro para [1,2,3] e [2,3,1] também, o que está errado
matiasg
2

Sei que geralmente é considerado apenas para teste, mas você poderia usar o Hamcrest JSON comparatorSameJSONAs no Hamcrest JSON.

Hamcrest JSON SameJSONAs

Justin Ohms
fonte
2

Karatê é exatamente o que você está procurando. Aqui está um exemplo:

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

(aviso: dev aqui)

Peter Thomas
fonte
2

Para comparar jsons, recomendo usar o 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
Slev Florin
fonte
0

Para aqueles como eu que querem fazer isso com Jackson, você pode usar o json-unit .

JsonAssert.assertJsonEquals(jsonNode1, jsonNode2);

Os erros fornecem feedback útil sobre o tipo de incompatibilidade:

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

Nada mais parecia funcionar muito bem, então eu escrevi o seguinte:

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;
}
Alex R
fonte
0

O código a seguir será mais útil para comparar dois 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;
    }
Radadiya Nikunj
fonte
0

Olhando para as respostas, tentei o JSONAssert, mas ele falhou. Então, eu usei Jackson com zjsonpatch. Postei detalhes na resposta SO aqui .

likejudo
fonte
-5

Esta solução para mim, o trabalho é muito bom:

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 isso ajude os outros.

JLouis
fonte
é claro, basta colocar seus valores e condições, e o tipo de visão, neste caso; Hashmap sobre uma exibição de lista.
JLouis
1
Isso é bom exemplo de como não fazê-lo :)
Petr Újezdský