对于想了解嵌套JSON数组对象，判断里面某个值屈改变内容的读者，本文将是一篇不可错过的文章，我们将详细介绍数组嵌套数组的json怎么解析，并且为您提供关于ES6复制拷贝数组，对象，json数组、fas
对于想了解嵌套JSON数组对象，判断里面某个值屈改变内容的读者，本文将是一篇不可错过的文章，我们将详细介绍数组嵌套数组的json怎么解析，并且为您提供关于ES6复制拷贝数组，对象，json数组、fastjson-1.2.21 使用实例，复杂嵌套Java对象转json对象，复杂嵌套json对象转对应Java对象的代码实现、fastjson: json对象，json对象数组，javabean对象，json字符串之间的相互转化、java – 从mongodb中的嵌套json数组中检索值的有价值信息。
本文目录一览：- 嵌套JSON数组对象，判断里面某个值屈改变内容（数组嵌套数组的json怎么解析）
- ES6复制拷贝数组，对象，json数组
- fastjson-1.2.21 使用实例，复杂嵌套Java对象转json对象，复杂嵌套json对象转对应Java对象的代码实现
- fastjson: json对象，json对象数组，javabean对象，json字符串之间的相互转化
- java – 从mongodb中的嵌套json数组中检索值
嵌套JSON数组对象，判断里面某个值屈改变内容（数组嵌套数组的json怎么解析）
经常遇到数据嵌套和数据处理，举个例子：
json = [
{"name":zhangsan,"id":111,"sex":1,"time":2020/12/15,},
{"name":李四,"id":222,"sex":0,"time":1900/1/1,},
{"name":王五,"id":333,"sex":1,"time":1900/1/1,},
],
收到以上这个数据格式，然后想判断sex=0就显示为女，sex=1就显示为男；不管白猫黑猫，能构建处理就是好猫
就是重写拆分构建：
//定义新容器
var newJson=[];
ver newSex；
//循环替换对象
for(var i=0;i<json.length;i++){ //判断原json里面的长度，进行循环修改
//这就判断替换值咯
if(json[i].sex == 0){
newSex= "女"
}else{
newSex= "男"
}
newJson.push(
{"name":json[i].name,"id":json[i].id,"sex":newSex,"time":json[i].time,}
);
}适用于js和VUE
应该还有更简单的方法，比如spit（）等函数，直接就可以，不用写这么多行代码。上面这种方法可以构建树或者其他更简单
json = [
{"name":张三,"id":111,"sex":1,"time":2020/12/15,
"childInfo":{
"name":张三人,"id":111,"sex":1,"time":2020/12/15,"childInfo":null
}
},
{"name":李四,"id":222,"sex":0,"time":1900/1/1,"childInfo":null
"childInfo":{
"name":张三啊,"id":111,"sex":1,"time":2020/12/15,"childInfo":null
}
},
{"name":王五,"id":333,"sex":1,"time":1900/1/1,"childInfo":null},
],
类似这种嵌套，然后你想变成这种格式：
JSON = [
{"name":张三,"id":333,"sex":1,"time":1900/1/1,"childInfo":null},
{"name":张三人,"id":333,"sex":1,"time":1900/1/1,"childInfo":null},
{"name":李四,"id":333,"sex":1,"time":1900/1/1,"childInfo":null},
{"name":张三啊,"id":333,"sex":1,"time":1900/1/1,"childInfo":null},
{"name":王五,"id":333,"sex":1,"time":1900/1/1,"childInfo":null},
]，
那就做个递归循环屈解决，每个都拆分,VUE的大概写法，JS也是如此类型。这就是构造新的结构（虽然办法傻了点）
getjson(e){//tree置换【{}，{}】的JSON方法
value；//数据来源
var NewJSON = [];
var i ;
e.map((cuttentDate ) => {
this.NewJSON.push( {"name":value.name,"id":value.id,"sex":value.sex,"time":value.,"childInfo":value.childInfo},);
cuttentDate.childInfo!=null && cuttentDate.childInfo.length >0 ? this.getjson(cuttentDate.childInfo,cuttentDate.id) : "";
})
},
ES6复制拷贝数组，对象，json数组
扩展运算符的应用spread打散数组[...]
（1）复制数组
数组是复合的数据类型，直接复制的话，只是复制了指向底层数据结构的指针，而不是克隆一个全新的数组。
const a1 = [1, 2];
const a2 = a1;
a2[0] = 2;
a1 // [2, 2]上面代码中，a2并不是a1的克隆，而是指向同一份数据的另一个指针。修改a2，会直接导致a1的变化。
ES5 只能用变通方法来复制数组。
const a1 = [1, 2];
const a2 = a1.concat();
a2[0] = 2;
a1 // [1, 2]上面代码中，a1会返回原数组的克隆，再修改a2就不会对a1产生影响。
扩展运算符提供了复制数组的简便写法。
const a1 = [1, 2];
// 写法一
const a2 = [...a1];
// 写法二
const [...a2] = a1;上面的两种写法，a2都是a1的克隆。
对象及json数组的拷贝，Object.assign() {...obj} JSON.Parse 等几种拷贝的区别
let obj = {
age: 10
}
let obj1 = {
grade: 1,
name: {
first: ''bob''
}
}
let objS = obj1
let objA = Object.assign(obj, obj1)
let objJ = JSON.parse(JSON.stringify(obj1))
let objK = { ...obj1 }
console.log(objA)
console.log(objJ)
console.log(objK)
obj1.grade = 9
obj1.name.first = ''chris''
console.log(objS)
console.log(objA)
console.log(objJ)
console.log(objK)打印结果:
{ age: 10, grade: 1, name: { first: ''bob'' } }
{ grade: 1, name: { first: ''bob'' } }
{ grade: 1, name: { first: ''bob'' } }
{ grade: 9, name: { first: ''chris'' } }
{ age: 10, grade: 1, name: { first: ''chris'' } }
{ grade: 1, name: { first: ''bob'' } }
{ grade: 1, name: { first: ''chris'' } }
结论: 由于对象创建在堆上 栈上的变量保存其地址 所以也叫指针变量
浅拷贝 如let simpleObj = obj;
则只拷贝了 obj在栈上的指针变量给 simpleObj 也就是说simpleObj实际存储的值是 obj的对象的内存地址 指向与 obj同样的堆内存地址 所以改变 obj的值 simpleObj 的值也会改变
深拷贝 就是copy了一份对象 放在另一块堆内存地址 改变之前的对象 对这个复制的对象不会有任何影响
js里有几种深拷贝方式
Object.assign方法实行的是浅拷贝，而不是深拷贝。也就是说，如果源对象某个属性的值是对象，那么目标对象拷贝得到的是这个对象的引用。
... 扩展和 assign 一样
JSON.parse(JSON.Stringify()) 深拷贝 但是缺点是不能拷贝 constructor 方法 解决办法就是递归
fastjson-1.2.21 使用实例，复杂嵌套Java对象转json对象，复杂嵌套json对象转对应Java对象的代码实现
理论我就不多废话了，直接看代码吧。使用的是fastjson-1.2.21版本的来实现下面代码的。
主要是实现复杂的嵌套的Java对象，也就是对象嵌套对象的复杂对象，转换成json字符串。然后就是反过来，把复杂的json字符串转换成对应的嵌套的Java对象。
先上工具类。如下。
package com.lxk.json;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
/**
* JSON 转换
*/
public final class JsonUtils {
/**
* 把Java对象转换成json字符串
*
* @param object 待转化为JSON字符串的Java对象
* @return json 串 or null
*/
public static String parSEObjToJson(Object object) {
String string = null;
try {
//string = JSON.toJSONString(object);
string = JSONObject.toJSONString(object);
} catch (Exception e) {
System.out.println(e.getMessage());
}
return string;
}
/**
* 将Json字符串信息转换成对应的Java对象
*
* @param json json字符串对象
* @param c 对应的类型
*/
public static <T> T parseJsonToObj(String json,Class<T> c) {
try {
//两个都是可行的，起码我测试的时候是没问题的。
//JSONObject jsonObject = JSONObject.parSEObject(json);
JSONObject jsonObject = JSON.parSEObject(json);
return JSON.toJavaObject(jsonObject,c);
} catch (Exception e) {
System.out.println(e.getMessage());
}
return null;
}
}
从代码中引入的包来看，真就是简单的只是引用了com.alibaba.fastjson这个包里面的2个类。所以，使用这个包，就很简单，不耦合其他工具包。
上面对象转json字符串的方法还可以如下修改下。
/**
* 把Java对象转换成json字符串
*
* @param object 待转化为JSON字符串的Java对象
* @return json 串 or null
*/
public static <T> String parSEObjToJson(T object) {
String string = null;
try {
//string = JSON.toJSONString(object);
string = JSONObject.toJSONString(object);
} catch (Exception e) {
System.out.println(e.getMessage());
}
return string;
}把穿进去的Object类给换成泛型，显得高级点点。这样的话，2个方法都是使用的泛型啦。可以让你写代码的水平，稍微闷骚一下。这只是泛型的简单用法。所以说只是稍微。
关于泛型，不懂的可以看下面的链接：包教包不会。
Java泛型详解：和Class的使用。泛型类，泛型方法的详细使用实例
Java泛型： 中的？ 和 extends 的理解和使用实例
pom.xml中引入如下配置。
<!-- json转换很是方便的工具jar -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.21</version>
</dependency>非maven项目，也可以去找这个jar包：fastjson-1.2.21.jar
我给放到云盘上，这里分享下：链接：http://pan.baidu.com/s/1dE1CLc1 密码：xg2c 有需要的可以直接下载使用，省的麻烦。嫌弃版本旧的也可自己找最新的。
下面是测试类。
package com.lxk.json;
import com.google.common.collect.Lists;
import com.lxk.model.Car;
import com.lxk.model.Dog;
import com.lxk.model.Student;
import java.util.List;
/**
* 测试json和Java对象之间的转换
* <p>
* Created by lxk on 2017/6/15
*/
public class TestJsonMain {
public static void main(String[] args) {
Student student = getStudent();
String studentJson = JsonUtils.parSEObjToJson(student);
System.out.println(studentJson);
Student studentFromJson = JsonUtils.parseJsonToObj(studentJson,Student.class);
System.out.println(studentFromJson);
}
private static Student getStudent() {
Dog dog1 = new Dog("大师兄的dog",true,true);
Dog dog2 = new Dog("大师兄的dog",false,false);
List<Dog> dogs = Lists.newArrayList();
dogs.add(dog1);
dogs.add(dog2);
List<String> boys = Lists.newArrayList("tom","jerry","jack");
Car car = new Car("q7",182,dogs,boys);
Student student = new Student();
student.setName("Lxk");
student.setCar(car);
return student;
}
}
然后就是看代码的运行结果。
这个乍一看，看不出来什么，我把我用到的几个Java bean也给放这吧，看官，别嫌弃文章太长。已经删掉getter和setter了
先是主体类Student类
package com.lxk.model;
/**
* Created by lxk on 2017/3/23
*/
public class Student implements Cloneable {
private String name;
private Car car;
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
",car=" + car +
'}';
}
@Override
public Student clone() {
Student student = null;
try {
student = (Student) super.clone();
if (car != null) {
student.setCar(car.clone());
}
} catch (CloneNotSupportedException ignored) {
System.out.println(ignored.getMessage());
}
return student;
}
}
这个是我原来测试clone方法的使用（Java中的深浅克隆）的时候，使用的类，现在顺道带过来测试这个，也是可以的。
只要你暂时没用到过这个clone方法，估计你也是不会去研究这个深浅克隆的，我还是附上链接吧。看链接：
java之实现Cloneable接口的详解，克隆一个对象--对应有浅克隆和深克隆，概念结合代码深入理解
然后就是学生的属性Car类。
package com.lxk.model;
import com.google.common.collect.Lists;
import java.util.List;
public class Car implements Cloneable,Comparable<Car> {
private String sign;
private int price;
private List<Dog> myDog;
private List<String> boys;
public Car() {
}
public Car(String sign,int price) {
this.sign = sign;
this.price = price;
}
public Car(String sign,int price,List<Dog> myDog) {
this.sign = sign;
this.price = price;
this.myDog = myDog;
}
public Car(String sign,List<Dog> myDog,List<String> boys) {
this.sign = sign;
this.price = price;
this.myDog = myDog;
this.boys = boys;
}
@Override
public int compareto(Car o) {
//同理也可以根据sign属性排序，就不举例啦。
return this.getPrice() - o.getPrice();
}
@Override
public String toString() {
return "Car{" +
"sign='" + sign + '\'' +
",price=" + price +
",myDog=" + myDog +
",boys=" + boys +
'}';
}
@Override
public Car clone() {
Car car = null;
try {
car = (Car) super.clone();
if (myDog != null) {
car.setMyDog(Lists.newArrayList(myDog));
}
if (boys != null) {
car.setBoys(Lists.newArrayList(boys));
}
} catch (CloneNotSupportedException ignored) {
System.out.println(ignored.getMessage());
}
return car;
}
}
下面就是Dog类。
package com.lxk.model;
import com.google.common.base.Objects;
/**
* 测试boolean属性的getter和setter
* <p>
* Created by lxk on 2016/12/23
*/
public class Dog {
private String name;
private boolean isLoyal;//是忠诚的
private boolean alive;//活蹦乱跳的
public Dog() {
}
public Dog(boolean isLoyal,boolean alive) {
this.isLoyal = isLoyal;
this.alive = alive;
}
public Dog(String name,boolean isLoyal,boolean alive) {
this.name = name;
this.isLoyal = isLoyal;
this.alive = alive;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Dog)) return false;
Dog dog = (Dog) o;
return Objects.equal(getName(),dog.getName());
}
@Override
public int hashCode() {
return Objects.hashCode(getName());
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
",isLoyal=" + isLoyal +
",alive=" + alive +
'}';
}
}
POJO 类中的任何boolean布尔类型的变量，都不要加 is，否则部分框架解析会引起序列化错误
好了，到这里，就把使用的三个model类啰嗦完了。下面再看主代码运行结果吧。
先是把复杂嵌套Java对象转换成json字符串对象，对json对象稍加格式化，展示如下。
{
"car": {
"boys": [
"tom","jack"
],"myDog": [
{
"alive": true,"loyal": true,"name": "大师兄的dog"
},{
"alive": false,"loyal": false,"name": "大师兄的dog"
}
],"price": 182,"sign": "q7"
},"name": "Lxk"
}然后就是把这个
json字符串再转乘Java对象的运行结果。也格式化下，展示如下。
Student{
name='Lxk',car=Car{
sign='q7',price=182,myDog=[
Dog{
name='大师兄的dog',isLoyal=true,alive=true
},Dog{
name='大师兄的dog',isLoyal=false,alive=false
}
],boys=[
tom,jerry,jack
]
}
}
还有关于这个Student类实例化的对象，调用toString（）方法，可以可以这么完美，你们不好奇么？为什么不是返回的一个Java内存地址，而是我们可以看的懂的一个类似json对象的字符串格式呢？这里面也是大有文章的，细心的小伙伴们，可以回头看下我的三个javabean，这三个Java model都是重写了toString（）方法的，所以，你在调用最上层的toString（）方法的时候，他会一次嵌套调用的。所以，才会这样，这个好像我当时测试什么的时候发现的，既然总结到这了，就多啰嗦两句吧，看官要是不信的话，大可以把这个代码贴出来，去掉某个复写的toString（）方法，再自己测试一下，就可以看到，我所言非虚啦。
在使用json字符串转Java对象的时候，可能会抛异常，我这遇到的是因为，我的Dog类，没有默认的构造函数，所以，就转换失败了，当添加了默认构造函数之后，就OK啦。看下图的异常截图。
可以看到，我这个默认的构造函数是刚刚添加的。
关于这个默认的构造函数，我们在实际开发的时候，还是一定要记的随时都给写上，不管自己用不用，都要加上，下面是我因为这个默认构造函数又出的bug。看链接：
ajax 报错 400 (Failed to load resource: the server responded with a status of 400 (Bad Request))
好了，到此算是啰嗦完了。
等下，还是再啰嗦一下，
这个fastjson是在github上开源的，看链接：
Github，这个网站听过没？没听过的话，作为程序员，可就渣渣啦。
fastjson: json对象，json对象数组，javabean对象，json字符串之间的相互转化
fastjson: json对象，json对象数组，javabean对象，json字符串之间的相互转化
在开发过程中，经常需要和前端交互数据，数据交互的格式都是JSON，在此过程中免不了json字符串与JSON对象互相转换，自己在这一方面的概念总是很混乱，最近看源码和博客，在此记录一下。注意：全程用的是fastjson
首先JSON有两种格式，一种是对象格式，一种是对象数组。
在JSON使用中主要的3个类：JSON，JSONObjec，JSONArray
其中JSONObjec和JSONArray继承于JSON的。
JSON对象(JSONObject)
{"id":1,"name":"chen"}JSON对象数组(JSONArray)
[ {"id":1,"name":"chen"}, {"id":2,"name":"张三"}]下面直接进入正题：
Java Bean 和JSON字符串的互转
Java Bean 转 JSON字符串
Java Bean是指Java中的一个普通对象（实体类）例如：
public class Student{ private String name; // 姓名 private Integer age; // 年龄 public void setName(String name){ this.name = name; } public String getName(){ return name; } public void setAge(Integer age){ this.age = age; } public Integer getAge(){ return age; } @Override public String toString() { return "Student{" + "name=''" + name + ''\'''' + ", age=" + age + ''}''; }}使用JSON类的toJSONString()方法，实现JSON对象转化为JSON字符串和Java Bean对象转化为JSON字符串。仔细观察源码发现，该方法经过多次重载，但最终都是实现JSON对象转化为JSON字符串和Java Bean对象转化为JSON字符串。
@Testpublic void BeanToJSONTest(){ Student student = new Student(); student.setName("小明"); student.setAge(20); String s1 = JSON.toJSONString(student); St..............
java – 从mongodb中的嵌套json数组中检索值
{
"myobj" : {
"objList" : [
{ "location" : "Texas" },{ "location" : "Houston"},{ "name":"Sam" }
]
},"category" : "cat1"
}
{
"myobj" :
{
"objList" : [
{ "location" : "Tennesy" },{ "location" : "NY"},{ "location" : "SF" }
]
},"category" : "cat2"
}
我想提取位于“休斯顿”的“**类别**”.在简单的JSON对象的情况下,我必须将其作为查询传递,如：
BasicDBObject place = new BasicDBObject();
place.put("location","Houston");
但是在嵌套JSON的情况下,我不知道如何将其作为查询传递并获得适当的类别.即如果我将我的位置作为“休斯顿”通过,那么它应该返回它的相应类别“cat1”…我希望我的问题现在清楚了….
解决方法
db.coll1.insert({
"myobj" : {
"objList" : [
{ "location" : "Texas" },"category" : "cat1"
})
和
db.coll1.insert({
"myobj" : {
"objList" : [
{ "location" : "Tennesy" },{ "location" : "SF" }
]
},"category" : "cat1"
})
现在您可以使用dot operator找到您想要的内容：
db.coll1.find({“myobj.objList.location”：“Texas”}).pretty()将返回一个具有德克萨斯州的对象
db.coll1.find({“myobj.objList.location”：“SF”}).pretty()将返回一个具有SF的对象
db.coll1.find({“myobj.objList.location”：“Houston”}).pretty()将返回两个对象
现在我希望你能用Java编写它.我从来没有使用过Java,但based on this question你可以做这样的事情.如果它不起作用,只需看看如何在java驱动程序中使用dot运算符为mongo：
DBCursor cursor = coll1.find(new BasicDBObject("myobj.objList.location","Texas"));
附：你说,你想要检索类别.以这种方式,您将需要使用投影db.coll1.find({<我提供的查询},{category：1,_id：0})
我们今天的关于嵌套JSON数组对象，判断里面某个值屈改变内容和数组嵌套数组的json怎么解析的分享就到这里，谢谢您的阅读，如果想了解更多关于ES6复制拷贝数组，对象，json数组、fastjson-1.2.21 使用实例，复杂嵌套Java对象转json对象，复杂嵌套json对象转对应Java对象的代码实现、fastjson: json对象，json对象数组，javabean对象，json字符串之间的相互转化、java – 从mongodb中的嵌套json数组中检索值的相关信息，可以在本站进行搜索。
本文标签：
