判断两个字符串不同的json是否等价（附:将等价但是不同json调整成同一字符串的方法）
来源：互联网 发布：罗马2全面战争for mac 编辑：程序博客网 时间：2024/06/16 18:35
在做软件和网络测试的时候，经常需要对排版格式与内部结构顺序不固定的json对象进行分析对比，而json基本语法下，同样的一个json对象，字符串变化可以千变万化，json内各个层字段顺序调转,排版变化，打乱顺序的json数组+多层嵌套，等等各种因素，都会造成对比上的困难。
以下由浅及深谈谈几种方法：(一共五种方法，四和五是无缺陷方法，将json对象转换成多叉树，再对多叉树的各个父节点的子节点左右顺序进行hashCode大小排序，这样不管json顺序或者排版如何变化，最终都将生成唯一的json字符串)
一.字符串对比，外加正则方式对比，因为json字符串可变化方式太多，出错率过高略过不谈。
二.使用json库将json字符串转换成对象，这时候可以完全排除掉空格和换行等等纯排版原因造成的差异.
如需更进一步对比，需要转换为json对象后进行递归取出所有键值对，然后通过遍历map对比，缺陷是当存在同名字段或者存在json数组的时候会出现冲突的问题,这个方法适合json层数不多或者不存在同名字段的情况.
三. 使用net.sf.json包，由于net.sf.json包在构造json对象的时候，会在内部进行有序化调整，所以等价的json对象生成的hashCode是完全一致的，可以直接使用 JSONObject.hashCode()对比，而其它包如：com.google.gson包与 vertx.core.json 包无法使用该方法，顺序稍加变化就会改变hashCode.
这是库与库之间构造json对象的数据结构差异.
以下设置了两层嵌套的内部顺序不同但是等价的json字符串
String a= "{\n" + " \"obj_1\": \"name\",\n" + " \"field_1\": \"11\",\n" + " \"list_1\": [\n" + " {\n" + " \"obj_2.1\": \"obj_2.1\",\n" + " \"field_2.1\": \"21\"\n" + " },\n" + " {\n" + " \"obj_2.2\": \"obj_2.2\",\n" + " \"field_2.2\": \"22\"\n" + " },\n" + "\t\t[ \n" + "\t\t{\n" + " \"obj_2.3.1\": \"obj_2.3.1\",\n" + " \"field_2.3.1\": \"231\"\n" + " },\n" + " {\n" + " \"obj_2.3.2\": \"obj_2.3.2\",\n" + " \"field_2.3.2\": \"232\"\n" + " }\n" + "\t\t\n" + "\t\t]\n" + " ]\n" + "}";String b="{\n" + " \"field_1\": \"11\",\n" + " \"obj_1\": \"name\",\n" + " \"list_1\": [\n" + " \n" + " {\n" + "\t\t \"field_2.2\": \"22\",\n" + " \"obj_2.2\": \"obj_2.2\"\n" + " },\n" + "\t\t\n" + "\t\t[ \n" + "\t\t{\n" + " \"obj_2.3.1\": \"obj_2.3.1\",\n" + " \"field_2.3.1\": \"231\"\n" + " },\n" + " {\n" + " \"obj_2.3.2\": \"obj_2.3.2\",\n" + " \"field_2.3.2\": \"232\"\n" + " }\n" + "\t\t],\n" + "\t\t\n" + "\t\t{\n" + " \"field_2.1\": \"21\",\n" + "\t\t\t\"obj_2.1\": \"obj_2.1\"\n" + " \n" + " }\n" + " ]\n" + "}"; JSONObject jsA= JSONObject.fromObject(a); JSONObject jsB= JSONObject.fromObject(b);System.out.println("A与B是否等价："+(jsA.hashCode()==jsB.hashCode()));结果输出：A与B是否等价：true
net.sf.json包的缺陷在于，Integer和String类型字段生成的hashCode会相同
如：{"id": "123"} 与 {"id": 123}，用net.sf.json包生成的json对象的hashCode一样，这时候会造成对比错误.
String a="{\"id\": \"123\"}";String b="{\"id\": 123}";Long time=System.currentTimeMillis(); JSONObject jsA= JSONObject.fromObject(a);JSONObject jsB= JSONObject.fromObject(b); System.out.println("A与B是否等价："+(jsA.hashCode()==jsB.hashCode()));结果输出：A与B是否等价：true四.对（三）方法进行完善，使用net.sf.json包hashCode等价的特性，对json构造的多叉树自上而下调整子节点顺序
由于hashCode等价的特性，此时孙子节点的顺序变化完全不会影响子节点的顺序，所以一次遍历就可以完成整个多叉树树排序.
重排序方法代码如下：
//自上而下将json对象的各个元素重新排序，采用将json对象排序后重新组装的方式static void arrangeJson(Object js){ if(js instanceof JSONObject){ JSONObject jsCopy = JSONObject.fromObject(js.toString()); //将json对象复制一份，进行递归遍历取值 Iterator i=jsCopy.entrySet().iterator(); ArrayList<Object> arr=new ArrayList<Object>(); while(i.hasNext()){ Map.Entry entry = (Map.Entry)i.next(); arr.add(entry.getKey().toString()); //逐个取出子节点对象 //System.out.println(entry.getKey() + " " + entry.getValue()+" "+jsCopy.get(entry.getKey()).getClass()); ((JSONObject)js).remove(entry.getKey().toString()); //清空旧的子元素 } sortArr(arr); for(int n=0;n<arr.size();n++){ //System.out.println("arr="+arr.get(n)); String key=arr.get(n).toString(); if(jsCopy.get(key) instanceof JSONObject||(jsCopy.get(key) instanceof JSONArray)){ arrangeJson(jsCopy.get(key)); //递归调整json对象 } ((JSONObject)js).put(key,jsCopy.get(key)); //重新组装序列化的子元素 } } if(js instanceof JSONArray) { JSONArray jsCopy=JSONArray.fromObject(js.toString()); ArrayList<Object> arr=new ArrayList<Object>(); for(int n=0;n<jsCopy.size();n++){ arr.add(jsCopy.get(n)); ((JSONArray) js).remove(0); } sortArr(arr); for(int n=0;n<arr.size();n++){ //System.out.println("arr_"+n+arr.get(n)); arrangeJson((Object)arr.get(n)); ((JSONArray) js).add((Object)arr.get(n)); } }}//将数组元素按照哈希码从小到大重新排序private static void sortArr(ArrayList<Object> arr){ int len=arr.size(); int[] n=new int[len]; ArrayList<Object> arrCopy=(ArrayList<Object>)arr.clone(); Object[] obj=new Object[len]; for(int i=0;i<len;i++){ n[i]=arrCopy.get(i).hashCode(); obj[i]=arrCopy.get(i); arr.remove(0); } for(int i=0;i<len;i++){ for(int y=i+1;y<len;y++){ if(n[i]<n[y]){ int x=n[y]; n[y]=n[i]; n[i]=x; Object s=obj[y]; obj[y]=obj[i]; obj[i]=s; } } } for(int i=0;i<len;i++){ arr.add(obj[i]); }}构造json对象并对比：public static void main(String[] args) { String a= "{\n" +" \"obj_1\": \"name\",\n" +" \"field_1\": \"11\",\n" +" \"list_1\": [\n" +" {\n" +" \"obj_2.1\": \"obj_2.1\",\n" +" \"field_2.1\": \"21\"\n" +" },\n" +" {\n" +" \"obj_2.2\": \"obj_2.2\",\n" +" \"field_2.2\": \"22\"\n" +" },\n" +"\t\t[ \n" +"\t\t{\n" +" \"obj_2.3.1\": \"obj_2.3.1\",\n" +" \"field_2.3.1\": \"231\"\n" +" },\n" +" {\n" +" \"obj_2.3.2\": \"obj_2.3.2\",\n" +" \"field_2.3.2\": \"232\"\n" +" }\n" +"\t\t\n" +"\t\t]\n" +" ]\n" +"}";Stringb="{\n" +" \"field_1\": \"11\",\n" +" \"obj_1\": \"name\",\n" +" \"list_1\": [\n" +" \n" +" {\n" +"\t\t \"field_2.2\": \"22\",\n" +" \"obj_2.2\": \"obj_2.2\"\n" +" },\n" +"\t\t\n" +"\t\t[ \n" +"\t\t{\n" +" \"obj_2.3.1\": \"obj_2.3.1\",\n" +" \"field_2.3.1\": \"231\"\n" +" },\n" +" {\n" +" \"obj_2.3.2\": \"obj_2.3.2\",\n" +" \"field_2.3.2\": \"232\"\n" +" }\n" +"\t\t],\n" +"\t\t\n" +"\t\t{\n" +" \"field_2.1\": \"21\",\n" +"\t\t\t\"obj_2.1\": \"obj_2.1\"\n" +" \n" +" }\n" +" ]\n" +"}"; arrangeJson(jsA); arrangeJson(jsB); System.out.println("A与B是否等价："+(jsA.toString().equals(jsB.toString())));//此处应对照字符串}结果输出：A与B是否等价：true用对照字符串的方法，可完全避免Integer和String无法区分的情况
五.对于其它json库，如com.google.gson包与 vertx.core.json 包，构造多叉树后，自下而上调整子节点顺序，步骤如下
1.找出所有最小树，也就是子节点不是jsonObject或者jsonArray，而是基本键值对的情况
2.对所有最小树进行排序
3.往上递归，父节点树+排序完成的树进行新的排序，直到最顶层，完成整个多叉树树排序
以com.google.gson包为例：
多叉树节点对象：
public static class jsonObj{ //多叉树双向链表对象 int fatherId=-1; //父节点的ID ArrayList<Integer> sonId=new ArrayList<Integer>(); //子节点ID数组 ArrayList<Object> sonKey=new ArrayList<Object>(); //子节点键值,当前存放的对象为JsonArray时为空 Object obj; //当前存放的对象 boolean isSort; //当前对象是否已经完成排序}重排序方法：static Object getArrangeJson(Object js){ ArrayList<jsonObj> jsonObjs = new ArrayList<jsonObj>(); //声明链表对象 setObjArr(js,jsonObjs); //将json对象自上而下转换成链表对象 arrangeArr(jsonObjs); //将链表对象自下而上调整顺序 return jsonObjs.get(0).obj; } static void arrangeArr(ArrayList<jsonObj> jsonObjs) { int len = jsonObjs.size(); boolean[] isSort = new boolean[len]; boolean isAllSort = false; while (!isAllSort) { //判断是否全部完成排序 for (int i = 0; i < len; i++) { isAllSort = isSort[i]; if (!isAllSort) break; } for (int n = 0; n < len; n++) { int fatherId = jsonObjs.get(n).fatherId; if (fatherId != -1 && is_End_or_Sort(jsonObjs, n, fatherId)) { jsonObj fatherObj = jsonObjs.get(fatherId); ArrayList<Integer> sonId = fatherObj.sonId; if (fatherObj.obj instanceof JsonObject) { sortArr(fatherObj.sonKey, fatherObj.sonId); JsonObject obj = new JsonObject(); for (int m = 0; m < fatherObj.sonId.size(); m++) { obj.add(fatherObj.sonKey.get(m).toString(), (JsonElement) jsonObjs.get(fatherObj.sonId.get(m)).obj); jsonObjs.get(fatherObj.sonId.get(m)).isSort = true; isSort[fatherObj.sonId.get(m)] = true; } fatherObj.obj = obj; fatherObj.isSort = true; isSort[fatherId] = true; } if (fatherObj.obj instanceof JsonArray) { ArrayList<Object> list = new ArrayList<Object>(); for (int m = 0; m < ((JsonArray) fatherObj.obj).size(); m++) { list.add(((JsonArray) fatherObj.obj).get(m)); } sortArr(list, fatherObj.sonId); JsonArray obj = new JsonArray(); for (int m = 0; m < fatherObj.sonId.size(); m++) { obj.add((JsonElement) jsonObjs.get(fatherObj.sonId.get(m)).obj); jsonObjs.get(fatherObj.sonId.get(m)).isSort = true; isSort[fatherObj.sonId.get(m)] = true; } fatherObj.obj = obj; fatherObj.isSort = true; isSort[fatherId] = true; } } } } } static boolean is_End_or_Sort(ArrayList<jsonObj> jsonObjs,int id,int fatherId){ boolean b=true; ArrayList<Integer> sonId= jsonObjs.get(fatherId).sonId; for(int n=0;n<sonId.size();n++){ if(!(jsonObjs.get(sonId.get(n)).obj instanceof com.google.gson.JsonPrimitive) && !jsonObjs.get(sonId.get(n)).isSort){ b=false; break; } } return b; } static void contrast(Object a,Object b){ //将jsonObject或JsonArray的内部元素按照规则重新排序 boolean i = false; System.out.println("json对象a序列化="+a.toString()); System.out.println("json对象b序列化="+b.toString());// if(a.hashCode()==b.hashCode()){ //hashCode与toString两种比较方法均可// i=true;// } if(a.toString().equals(b.toString())){ i=true; } System.out.println("两个json对象是否等价:"+i); } //将json对象自上而下逐个分解转换成链表对象 static void setObjArr(Object js,ArrayList<jsonObj> jsonObjs){ jsonObj obj; if(jsonObjs.size()==0) { obj = new jsonObj(); obj.obj=js; jsonObjs.add(obj); } else{ obj=jsonObjs.get(jsonObjs.size()-1); } int id=jsonObjs.size()-1; if(js instanceof JsonObject) { Iterator i$ = ((JsonObject) js).entrySet().iterator(); //递归遍历子元素 //ArrayList<> while (i$.hasNext()) { Map.Entry entry = (Map.Entry) i$.next(); jsonObj sonObj = new jsonObj(); sonObj.fatherId=id; sonObj.obj=entry.getValue(); obj.sonId.add(jsonObjs.size()); jsonObjs.add(sonObj); obj.sonKey.add(entry.getKey().toString()); if (!(entry.getValue() instanceof com.google.gson.JsonPrimitive)) { setObjArr(entry.getValue(),jsonObjs); //自上而下递归 } } } if(js instanceof JsonArray){ for(int n=0;n<((JsonArray) js).size();n++){ jsonObj sonObj = new jsonObj(); sonObj.fatherId=id; sonObj.obj=((JsonArray) js).get(n); obj.sonId.add(jsonObjs.size()); jsonObjs.add(sonObj); setObjArr(((JsonArray) js).get(n),jsonObjs); //自上而下递归 } } } //将数组元素按照哈希码从小到大重新排序 private static boolean sortArr(ArrayList<Object> arr, ArrayList<Integer> idArr){ boolean b=false; int len=arr.size(); int[] n=new int[len]; for(int i=0;i<len;i++){ n[i]=arr.get(i).toString().hashCode(); } for(int i=0;i<len;i++){ for(int y=i+1;y<len;y++){ if(n[i]<n[y]){ int x=n[y]; n[y]=n[i]; n[i]=x; Object s=arr.get(y); arr.set(y,arr.get(i)); arr.set(i,s); x = idArr.get(y); idArr.set(y,idArr.get(i)); idArr.set(i,x); b=true; } } } return b; }构造json对象并判断：
String a= "{\n" + " \"obj_1\": \"name\",\n" + " \"field_1\": \"11\",\n" + " \"list_1\": [\n" + " {\n" + " \"obj_2.1\": \"obj_2.1\",\n" + " \"field_2.1\": \"21\"\n" + " },\n" + " {\n" + " \"obj_2.2\": \"obj_2.2\",\n" + " \"field_2.2\": \"22\"\n" + " },\n" + "\t\t[ \n" + "\t\t{\n" + " \"obj_2.3.1\": \"obj_2.3.1\",\n" + " \"field_2.3.1\": \"231\"\n" + " },\n" + " {\n" + " \"obj_2.3.2\": \"obj_2.3.2\",\n" + " \"field_2.3.2\": \"232\"\n" + " }\n" + "\t\t\n" + "\t\t]\n" + " ]\n" + "}";String b="{\n" + " \"field_1\": \"11\",\n" + " \"obj_1\": \"name\",\n" + " \"list_1\": [\n" + " \n" + " {\n" + "\t\t \"field_2.2\": \"22\",\n" + " \"obj_2.2\": \"obj_2.2\"\n" + " },\n" + "\t\t\n" + "\t\t[ \n" + "\t\t{\n" + " \"obj_2.3.1\": \"obj_2.3.1\",\n" + " \"field_2.3.1\": \"231\"\n" + " },\n" + " {\n" + " \"obj_2.3.2\": \"obj_2.3.2\",\n" + " \"field_2.3.2\": \"232\"\n" + " }\n" + "\t\t],\n" + "\t\t\n" + "\t\t{\n" + " \"field_2.1\": \"21\",\n" + "\t\t\t\"obj_2.1\": \"obj_2.1\"\n" + " \n" + " }\n" + " ]\n" + "}"; JsonObject jsA = paser.parse(b).getAsJsonObject(); JsonObject jsB = paser.parse(b).getAsJsonObject();//以下两种判断均可System.out.println("A与B是否等价："+(getArrangeJson(jsA).toString().equals(getArrangeJson(jsB).toString())));System.out.println("A与B是否等价："+(getArrangeJson(jsA).hashCode()==getArrangeJson(jsB).hashCode()));结果输出：A与B是否等价：trueA与B是否等价：true注：由于net.sf.json包存在hashCode等价特性，而其它包不存在（需要toString），所以在排序时需要灵活变化排序规则，在toString().hashCode()和.hashCode()之间切换
阅读全文
0 0
- 判断两个字符串不同的json是否等价（附:将等价但是不同json调整成同一字符串的方法）
- 判断两个字符串中出现的字符是否完全一样（顺序可以不同）
- CF560D Equivalent Strings 可拆分的字符串是否等价
- 编写一个函数，判断两个字符串是否是是相互打乱的，也就是说它们有着相同的字符，但是对应不同的顺序。
- 将由16进制数字组成的字符串转换成与之等价的整形值
- 计算两个字符串的不同
- 在输入的字符串中判断是否有a，多种方法（比较前两种不同的表示方法）
- node.js 将json字符串转为json对象的方法
- java比较两段json不同工具类（两个同一类型的java对象比较也推荐转成JSON再进行比较）
- 将同一款APP的两个不同连接安装到同一台手机上的方法
- 正则表达式的等价判断
- 如何将两个不同分组（group by）的结果拼成逗号隔开的字符串
- JavaScript 将 JSON 字符串转换成 JSON 对象的数组
- 将JSON的字符串解析成JSON数据格式
- 将key名不带双引号的JSON字符串转换成JSON对象的方法
- 将key名不带双引号的JSON字符串转换成JSON对象的方法
- 将key名不带双引号的JSON字符串转换成JSON对象的方法
- JavaScript:将key名不带双引号的JSON字符串转换成JSON对象的方法
- Tensorflow学习（1）
- leetcode: 56. Merge Intervals
- 常识
- fd_set 详解
- 黑马商城项目_商品展示样式设计
- 判断两个字符串不同的json是否等价（附:将等价但是不同json调整成同一字符串的方法）
- localstorage 值不见了
- windows上安装TensorFlow和Python（亲自实践有效！）
- Windows下使用VS2012搭建Lua的开发环境
- 【云星数据---Apache Flink实战系列(精品版)】：Apache Flink高级特性与高级应用002-Flink的内存管理002
- leetcode: 57. Insert Interval
- 类的封装以及构造方法
- 深度学习---Windows VS2015 tensorflow环境配置
- NodeJS使用淘宝npm镜像站的各种姿势
