Java 如何测试json object1是json object2的子集

我正在寻找一个JSON配对库，它支持比较两个JSON对象，忽略子顺序，检查第一个对象是否是其他对象的子集，您可以像这样创建JSONDiff：

JsonPatch patch = JsonDiff.asJsonPatch(source, target);

---

可能需要先按关键点对对象排序，因为它没有忽略子对象顺序的选项。（微分后，您只需在微分中查找

add

s和

replace

s）。

我找不到任何答案，所以我编写了自己的算法

公共布尔checksubsetobject（JSONObject outputjson，JSONObject inputjson）抛出JSONException {

Iterator inputjsonkeys=inputjson.keys（）；
while（inputjsonkeys.hasNext（））
{
String key=inputjsonkeys.next（）；
字符串val=null；
试一试{
JSONObject inputvalue=inputjson.getJSONObject（键）；
if（outputjson.has（key））
{
试一试{
JSONObject outputvalue=outputjson.getJSONObject（键）；
if（checksubsetobject（outputvalue，inputvalue）==false）
{
返回false；
}
}
捕获（例外e）
{
返回false；
}
}
其他的
{
返回false；
}
}捕获（例外e）{
val=inputjson.get（key.toString（）；
}
如果（val！=null）{
if（checksubsetstring（outputjson，key，val）==false）
{
返回false；
}
}
}
返回true；
}
公共布尔checksubsetstring（JSONObject outputjson、字符串键、字符串val）抛出JSONException{
试一试{
if（val.contains（“[”）&&val.contains（“]））
{
Pattern p=Pattern.compile（“\\[”）；
匹配器m=p.Matcher（val）；
val=m.replaceAll（“”）；
模式p2=Pattern.compile（“\\]”）；
匹配器m2=p2.匹配器（val）；
val=m2.replaceAll（“”）；
模式p5=Pattern.compile（“\\{”）；
匹配器m5=p5.匹配器（val）；
val=m5.replaceAll（“”）；
模式p6=Pattern.compile（\\}）；
匹配器m6=p6.匹配器（val）；
val=m6.replaceAll（“”）；
/*Pattern p9=Pattern.compile（“\”）；
匹配器m9=p9.匹配器（val）；
val=m9.replaceAll（“”）*/
//系统输出打印项次（“值1”+val）；
字符串valarray[]=val.split（“，”）；
字符串outputarrystring=outputjson.get（key.toString（）；
如果（！outputarrystring.contains（“[”）&&outputarrystring.contains（“]））
{
返回false；
}
其他的
{
模式p3=模式。编译（“\\[”）；
匹配器m3=p3.匹配器（输出阵列串）；
OutputaryString=m3.replaceAll（“”）；
Pattern p4=Pattern.compile（“\\]”）；
匹配器m4=p4.匹配器（输出阵列串）；
outputarrystring=m4.replaceAll（“”）；
Pattern p7=Pattern.compile（“\\{”）；
匹配器m7=p7.匹配器（输出阵列串）；
outputarrystring=m7.replaceAll（“”）；
Pattern p8=Pattern.compile（\\}）；
匹配器m8=p8.匹配器（输出阵列串）；
outputarrystring=m8.replaceAll（“”）；
/*Pattern p9=Pattern.compile（“\”）；
匹配器m9=p9.匹配器（val）；
val=m9.replaceAll（“”）*/
字符串outputarray[]=outputarrystring.split（“，”）；
/*for（int i=0；i

     Iterator<String> inputjsonkeys = inputjson.keys();
    while(inputjsonkeys.hasNext())
    {

     String key = inputjsonkeys.next();
      String val = null;
        try{
             JSONObject inputvalue = inputjson.getJSONObject(key);

             if(outputjson.has(key))
             {
                 try{
                    JSONObject outputvalue = outputjson.getJSONObject(key);
                    if( checksubsetobject(outputvalue,inputvalue) == false)
                        {
                          return false;
                        }
                    }
                 catch(Exception e)
                 {
                     return false;
                 }

             }
             else
             {
                 return false;
             }
        }catch(Exception e){
            val =inputjson.get(key).toString();


        }

        if(val != null){
        if (checksubsetstring(outputjson,key,val)==false)
            {
              return false;
            }
        }

    }

    return true;

}
public boolean checksubsetstring(JSONObject outputjson, String key, String val) throws JSONException {


        try{
            if(val.contains("[")&&val.contains("]"))
            {

                Pattern p = Pattern.compile("\\[");

                   Matcher m = p.matcher(val); 
                   val = m.replaceAll("");

                   Pattern p2 = Pattern.compile("\\]");
                   Matcher m2 = p2.matcher(val); 
                   val = m2.replaceAll("");

                   Pattern p5 = Pattern.compile("\\{");
                   Matcher m5 = p5.matcher(val); 
                   val = m5.replaceAll("");

                   Pattern p6 = Pattern.compile("\\}");
                   Matcher m6 = p6.matcher(val); 
                   val = m6.replaceAll("");

                 /*  Pattern p9 = Pattern.compile("\"");
                   Matcher m9 = p9.matcher(val); 
                   val = m9.replaceAll("");*/

                 //  System.out.println("value1  "+val);

                String valarray[] = val.split(",");
                String outputarraystring = outputjson.get(key).toString();

                if(!outputarraystring.contains("[")&&outputarraystring.contains("]"))
                {
                    return false;
                }
                else
                {

                    Pattern p3 = Pattern.compile("\\[");

                       Matcher m3 = p3.matcher(outputarraystring); 
                       outputarraystring = m3.replaceAll("");

                       Pattern p4 = Pattern.compile("\\]");
                       Matcher m4 = p4.matcher(outputarraystring); 
                       outputarraystring = m4.replaceAll("");

                       Pattern p7 = Pattern.compile("\\{");
                       Matcher m7 = p7.matcher(outputarraystring); 
                       outputarraystring = m7.replaceAll("");

                       Pattern p8 = Pattern.compile("\\}");
                       Matcher m8 = p8.matcher(outputarraystring); 
                       outputarraystring = m8.replaceAll("");

                    /*   Pattern p9 = Pattern.compile("\"");
                       Matcher m9 = p9.matcher(val); 
                       val = m9.replaceAll("");*/

                    String outputarray[] = outputarraystring.split(",");
                     /* for(int i=0; i < valarray.length; i++){
                            System.out.println(valarray[i]);
                    }*/
            //      if (Arrays.equals(valarray, outputarray))
                    Set set = new HashSet(Arrays.asList(outputarray)); 
                    Set set2 = new HashSet(Arrays.asList(valarray)); 
                    if (set.containsAll(set2))
                       return true;
                    else
                        return false;

                }

        }
        else{ 
                    if(val.equals(outputjson.get(key).toString()))
                    {
                        return true;
                    }
                    else
                    {
                        return false;
                    }
            }
   }

    catch(Exception e){
        return false;
    }


}