Java中JSON字符串与java对象的沟通实例详解,双层

时间:2019-08-29 00:15来源:亚洲城ca88唯一官方网站
双层嵌套json字符串(即json对象内嵌json数组)深入分析为Map 事先自个儿层写过一篇小说,介绍了json与map的互相转化,但立时只提到到单一的json对象或json数组,对json对象内嵌套那json数组

双层嵌套json字符串(即json对象内嵌json数组)深入分析为Map

事先自个儿层写过一篇小说,介绍了json与map的互相转化,但立时只提到到单一的json对象或json数组,对json对象内嵌套那json数组的json字符串不也许管理,那篇文章首要解决那个标题。 
率先要在品种中程导弹入json的jar包:
亚洲城ca88唯一官方网站 1
在底下的代码中处理json对象既使用了net.sf.json.JSONObject 也使用了org.json.JSONObject 五个的包都要导。

率先在E盘下开创贰个priceJson.txt,写入一下内容:

{
    height:1,
    width:1,
    location:[
               {
               顶部:3
               },{
               底部:1
               },{
               左侧:2
               },{
               右侧:1
               },{
               悬浮:4
               }
    ],
    type:[
             {
               1:1
               },{
               2:2
               },{
               3:4
               },{
               4:4
               }
    ]
}

下边包车型大巴类会通过read方法将文件中的json串读抽取来,通过getMapByJson获取到map:

package com.ngsh.common;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import net.sf.json.JSONObject;

import org.json.JSONArray;

public class FileIO {

    //读文件
    public String read(String path){
        String data = ;
        File file = new File(path);
        if(file.isFile()&&file.exists()){
            try {
                InputStreamReader read = new InputStreamReader(
                    new FileInputStream(file),utf-8);//考虑到编码格式
                BufferedReader bufferedReader = new BufferedReader(read);
                String lineTxt = null;
                while((lineTxt = bufferedReader.readLine()) != null){
                    data  =lineTxt;
                }
                read.close();
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }catch (IOException e) {
                e.printStackTrace();
            }

        }
        return data;

    }
    //将json转换为map
    public Map getMapByJson(String json) {
        Map map = new HashMap();
        // 最外层解析
        JSONObject object = object = JSONObject.fromObject(json);
        for (Object k : object.keySet()) {
            Object v = object.get(k);
            map.put(k.toString(), v);
        }
        Map map2 = new HashMap();
        //第二层解析 第二层可能是 也可能不是
        for(Map.Entry entry:map.entrySet()){
            try {
                JSONArray array = new JSONArray(entry.getValue().toString());  //判断是否是json数组

                //是json数组
                for (int i = 0; i < array.length(); i  ) {
                    org.json.JSONObject object2 = array.getJSONObject(i);//json数组对象
                    JSONObject object3 = JSONObject.fromObject(object2.toString());  //json对象
                    for (Object k : object3.keySet()) {
                        Object v = object3.get(k);
                        map2.put(k.toString(), v);
                    }
                }
            } catch (Exception e) {  //不是json串数组
                map2.put(entry.getKey(), entry.getValue());
            }
        }
    /*  for(Map.Entry entry:map2.entrySet()){
            System.out.println(entry.getKey() - entry.getValue());
        }
    */
        return map2;
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
         String path=E:priceJson.txt;
         FileIO fo = new FileIO();
         Map map = fo.getMapByJson(fo.read(path));
         for(Map.Entry entry:map.entrySet()){
            System.out.println(key: entry.getKey() -value: entry.getValue());
        }
    }

}

运营结果如下:

key:3-value:4
key:2-value:2
key:1-value:1
key:height-value:1
key:左侧-value:2
key:4-value:4
key:width-value:1
key:底部-value:1
key:悬浮-value:4
key:右侧-value:1
key:顶部-value:3

 

在此以前本人层写过一篇小说,介绍了json与map的并行转化,但当时只关乎到单一的json对象或...

在支付进度中,平时索要和其他系统交流数据,数据调换的格式有XML、JSON等,JSON作为多少个轻量级的数量格式比xml功用要高,XML必要广大的标签,那确实攻陷了互连网流量,JSON在那地点则做的很好,下边先看下JSON的格式,

在付出进程中,平常索要和别的系统交流数据,数据调换的格式有XML、JSON等,JSON作为三个轻量级的数额格式比xml效能要高,XML需求过多的价签,那如实私吞了互连网流量,JSON在这上面则做的很好,上边先看下JSON的格式,

JSON能够有两种格式,一种是指标格式的,另一种是数组对象,

JSON能够有二种格式,一种是指标格式的,另一种是数组对象,

{"name":"JSON","address":"北京市西城区","age":25}//JSON的对象格式的字符串

{"name":"JSON","address":"香港(Hong Kong)市西清城区","age":25}//JSON的目标格式的字符串

 

[{"name":"JSON","address":"法国首都市西云城区","age":25}]//数据对象格式

[{"name":"JSON","address":"北京市西城区","age":25}]//数据对象格式

从上边的二种格式能够见到对象格式和数组对象格式独一的差异则是在对象格式的功底上增加了[],再来看现实的布局,能够观察都以以键值对的样式出现的,中间以立陶宛语状态下的逗号(,)分隔。

从地点的二种格式能够看看对象格式和数组对象格式独一的两样则是在指标格式的底蕴上加上了[],再来看具体的构造,能够看来都是以键值对的情势出现的,中间以保加塔那那利佛语状态下的逗号(,)分隔。

在前面四个和后端举行多少传输的时候这种格式也是非常受款待的,后端重临json格式的字符串,前台使用js中的JSON.parse()方法把JSON字符串深入分析为json对象,然后进行遍历,供前端选择。

在后面一个和后端举办数据传输的时候这种格式也是相当受接待的,后端重临json格式的字符串,前台使用js中的JSON.parse()方法把JSON字符串解析为json对象,然后进行遍历,供前端选拔。

上面踏向正题,介绍在JAVA中JSON和java对象时期的互转。

上边步向正题,介绍在JAVA中JSON和java对象时期的互转。

要想实现JSON和java对象时期的互转,必要借助第三方jar包,这里运用json-lib这么些jar包,下载地址为:

要想实现JSON和java对象之间的互转,供给正视第三方jar包,这里运用json-lib那些jar包,下载地址为:

json-lib提供了几个类能够成功此效率,例,JSONObject、JSONArray。从类的名字上能够看出JSONObject转化的相应是目的格式的,而JSONArray转化的则应当是数组对象(即,带[]形式)的。

json-lib提供了几个类能够落成此功能,例,JSONObject、JSONArray。从类的名字上得以看到JSONObject转化的相应是目的格式的,而JSONArray转化的则应当是数组对象(即,带[]形式)的。

一、java普通对象和json字符串的互转

一、java普通对象和json字符串的互转

java对象--》》字符串

  java对象--》》字符串

java普通对象指的是java中的一个java bean,即叁个实体类,如,

java普通对象指的是java中的二个java bean,即二个实体类,如,

package com.cn.study.day3;
  public class Student {
    //姓名
    private String name;
    //年龄
    private String age;
    //住址
    private String address;
    public String getName() {
      return name;
    }
    public void setName(String name) {
      this.name = name;
    }
    public String getAge() {
      return age;
    }
    public void setAge(String age) {
      this.age = age;
    }
    public String getAddress() {
      return address;
    }
    public void setAddress(String address) {
      this.address = address;
    }
    @Override
    public String toString() {
      return "Student [name="   name   ", age="   age   ", address="
        address   "]";
    }
}
package com.cn.study.day3;

public class Student {
    //姓名
    private String name;
    //年龄
    private String age;
    //住址
    private String address;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    @Override
    public String toString() {
        return "Student [name="   name   ", age="   age   ", address="
                  address   "]";
    }


}

上边是自己的八个惯常的java实体类,看json-lib怎么样把它转化为字符串方式,

 

public static void convertObject() {
    Student stu=new Student();
    stu.setName("JSON");
    stu.setAge("23");
    stu.setAddress("北京市西城区");
    //1、使用JSONObject
    JSONObject json = JSONObject.fromObject(stu);
    //2、使用JSONArray
    JSONArray array=JSONArray.fromObject(stu);
    String strJson=json.toString();
    String strArray=array.toString();
    System.out.println("strJson:" strJson);
    System.out.println("strArray:" strArray);
}

上边是自己的一个清淡无奇的java实体类,看json-lib如何把它转化为字符串情势,

本人定义了一个Student的实体类,然后分别采纳了JSONObject和JSONArray三种方法转化为JSON字符串,上边看打字与印刷的结果,

public static void convertObject() {

        Student stu=new Student();
        stu.setName("JSON");
        stu.setAge("23");
        stu.setAddress("北京市西城区");

        //1、使用JSONObject
        JSONObject json = JSONObject.fromObject(stu);
        //2、使用JSONArray
        JSONArray array=JSONArray.fromObject(stu);

        String strJson=json.toString();
        String strArray=array.toString();

        System.out.println("strJson:" strJson);
        System.out.println("strArray:" strArray);
    }

亚洲城ca88唯一官方网站,strJson:{"address":"大阪市西江城区","age":"23","name":"JSON"}
strArray:[{"address":"松山市西龙湖区","age":"23","name":"JSON"}]

 

从结果中得以观察三种办法都得以把java对象转化为JSON字符串,只是转化后的布局不一。

自个儿定义了一个Student的实体类,然后分别选拔了JSONObject和JSONArray二种格局转化为JSON字符串,上面看打字与印刷的结果,

JSON字符串--》》java对象

strJson:{"address":"北京市西城区","age":"23","name":"JSON"}
strArray:[{"address":"北京市西城区","age":"23","name":"JSON"}]

地点说明了什么把java对象转化为JSON字符串,上面看怎么着把JSON字符串格式转化为java对象,

从结果中能够见到二种方法都足以把java对象转化为JSON字符串,只是转化后的协会差异。

首先需求定义三种区别格式的字符串,须求动用对双引号进行转义,

  JSON字符串--》》java对象

public static void jsonStrToJava(){
    //定义两种不同格式的字符串
    String objectStr="            
    {"name":"JSON","age":"24","address":"北京市西城区
    "}";
    String arrayStr="    
    [{"name":"JSON","age":"24","address":"北京市西城区
    "}]";
    //1、使用JSONObject
    JSONObject jsonObject=JSONObject.fromObject(objectStr);
    Student stu=(Student)JSONObject.toBean(jsonObject,     
    Student.class);
    //2、使用JSONArray
    JSONArray jsonArray=JSONArray.fromObject(arrayStr);
    //获得jsonArray的第一个元素
    Object o=jsonArray.get(0);
    JSONObject jsonObject2=JSONObject.fromObject(o);
    Student stu2=(Student)JSONObject.toBean(jsonObject2,     
    Student.class);
    System.out.println("stu:" stu);
    System.out.println("stu2:" stu2);
} 

上面表达了怎样把java对象转化为JSON字符串,上面看怎么样把JSON字符串格式转化为java对象,

打字与印刷结果为:

先是需求定义二种不一样格式的字符串,需求运用对双引号进行转义,

stu:Student [name=JSON, age=24, address=巴黎市西徐闻县]
stu2:Student [name=JSON, age=24, address=新加坡市西新会区]

public static void jsonStrToJava(){
        //定义两种不同格式的字符串
        String objectStr="{"name":"JSON","age":"24","address":"北京市西城区"}";
        String arrayStr="[{"name":"JSON","age":"24","address":"北京市西城区"}]";

        //1、使用JSONObject
        JSONObject jsonObject=JSONObject.fromObject(objectStr);
        Student stu=(Student)JSONObject.toBean(jsonObject, Student.class);

        //2、使用JSONArray
        JSONArray jsonArray=JSONArray.fromObject(arrayStr);
        //获得jsonArray的第一个元素
        Object o=jsonArray.get(0);
        JSONObject jsonObject2=JSONObject.fromObject(o);
        Student stu2=(Student)JSONObject.toBean(jsonObject2, Student.class);
        System.out.println("stu:" stu);
        System.out.println("stu2:" stu2);

    }

从上边的代码中得以观看,使用JSONObject能够轻易的把JSON格式的字符串转化为java对象,不过采纳JSONArray就没那么轻易了,因为它有“[]”符号,所以大家那边在获得了JSONArray的靶子之后,取其首先个因素即大家必要的贰个student的变形,然后利用JSONObject轻巧到手。

打字与印刷结果为:

二、list和json字符串的互转

stu:Student [name=JSON, age=24, address=北京市西城区]
stu2:Student [name=JSON, age=24, address=北京市西城区]

list--》》json字符串

从上边的代码中得以看来,使用JSONObject可以轻巧的把JSON格式的字符串转化为java对象,但是采用JSONArray就没那么轻巧了,因为它有“[]”符号,所以大家那边在得到了JSONArray的靶子之后,取其首先个因素即大家须求的三个student的变形,然后利用JSONObject轻巧获取。

 

二、list和json字符串的互转

public static void listToJSON(){
    Student stu=new Student();
    stu.setName("JSON");
    stu.setAge("23");
    stu.setAddress("北京市海淀区");
    List<Student> lists=new ArrayList<Student>();
    lists.add(stu);
    //1、使用JSONObject
    //JSONObject listObject=JSONObject.fromObject(lists);
    //2、使用JSONArray
    JSONArray listArray=JSONArray.fromObject(lists);
    //System.out.println("listObject:" listObject.toString());
    System.out.println("listArray:" listArray.toString());
}

list--》》json字符串

自己把施用JSONObject的点子给注掉了,大家先看注释以前的结果,

 

Exception in thread "main" net.sf.json.JSONException: 'object' is an array. Use JSONArray instead
报告自个儿说有二个卓绝,通过查阅源码开掘,在应用fromObject方法的时候会先进行参数类型的判断,这里就报告大家,传入的参数是三个array类型,因为使用的ArrayList,再来看,注释之后的结果,

public static void listToJSON(){
        Student stu=new Student();
        stu.setName("JSON");
        stu.setAge("23");
        stu.setAddress("北京市海淀区");
        List<Student> lists=new ArrayList<Student>();
        lists.add(stu);
        //1、使用JSONObject
        //JSONObject listObject=JSONObject.fromObject(lists);
        //2、使用JSONArray
        JSONArray listArray=JSONArray.fromObject(lists);

        //System.out.println("listObject:" listObject.toString());
        System.out.println("listArray:" listArray.toString());

    }

listArray:[{"address":"香港(Hong Kong)市海淀区","age":"23","name":"JSON"}]
如此结果是例行的。

本身把利用JSONObject的法子给注掉了,大家先看注释在此以前的结果,

json字符串--》》list

Exception in thread "main" net.sf.json.JSONException: 'object' is an array. Use JSONArray instead

从上边的事例能够观望list的对象只好中间转播为数组对象的格式,那么我们看下边包车型客车字符串到list的转速,

告诉作者说有二个不行,通过查看源码开采,在选拔fromObject方法的时候会先进行参数类型的推断,这里就告诉我们,传入的参数是二个array类型,因为运用的ArrayList,再来看,注释之后的结果,

public static void jsonToList(){
String arrayStr="[{"name":"JSON","age":"24","address":"北京市西城区"}]";
//转化为list
List<Student> list2=(List<Student>)JSONArray.toList(JSONArray.fromObject(arrayStr), Student.class);
for (Student stu : list2) {
System.out.println(stu);
}
//转化为数组
Student[] ss =(Student[])JSONArray.toArray(JSONArray.fromObject(arrayStr),Student.class);
for (Student student : ss) {
System.out.println(student);
}
}
listArray:[{"address":"北京市海淀区","age":"23","name":"JSON"}]

打字与印刷结果,

那样结果是健康的。
json字符串--》》list

Student [name=JSON, age=24, address=香岛市西四会市]

从上边的事例能够观望list的目的只可以中间转播为数组对象的格式,那么大家看下边包车型大巴字符串到list的转折,

Student [name=JSON, age=24, address=北京市西新雨花台区]

public static void jsonToList(){
        String arrayStr="[{"name":"JSON","age":"24","address":"北京市西城区"}]";
        //转化为list
                List<Student> list2=(List<Student>)JSONArray.toList(JSONArray.fromObject(arrayStr), Student.class);

                for (Student stu : list2) {
                    System.out.println(stu);
                }
                //转化为数组
                Student[] ss =(Student[])JSONArray.toArray(JSONArray.fromObject(arrayStr),Student.class);
                for (Student student : ss) {
                    System.out.println(student);
                }


    }

是因为字符串的格式为含有“[]”的格式,所以这里选拔JSONArray那个目的,它有toArray、toList方法可供使用,前面三个转化为java中的数组,大概转载为java中的list,由于此处有实体类进行相应,所以在采纳时钦命了泛型的类型(Student.class),那样就能够获得转化后的目的。

打字与印刷结果,

三、map和json字符串的互转

Student [name=JSON, age=24, address=北京市西城区]
Student [name=JSON, age=24, address=北京市西城区]

map--》》json字符串

是因为字符串的格式为带有“[]”的格式,所以这里选拔JSONArray那么些指标,它有toArray、toList方法可供使用,前面一个转化为java中的数组,或许转载为java中的list,由于这里有实体类举办对应,所以在采纳时钦赐了泛型的品类(Student.class),那样即可获得转化后的对象。

public static void mapToJSON(){
Student stu=new Student();
stu.setName("JSON");
stu.setAge("23");
stu.setAddress("中国上海");
Map<String,Student> map=new HashMap<String,Student>();
map.put("first", stu);
//1、JSONObject
JSONObject mapObject=JSONObject.fromObject(map);
System.out.println("mapObject" mapObject.toString());
//2、JSONArray
JSONArray mapArray=JSONArray.fromObject(map);
System.out.println("mapArray:" mapArray.toString());
}

三、map和json字符串的互转

打字与印刷结果,

map--》》json字符串

mapObject{"first":{"address":"中华夏族民共和国东方之珠","age":"23","name":"JSON"}}
mapArray:[{"first":{"address":"中夏族民共和国巴黎","age":"23","name":"JSON"}}]

public static void mapToJSON(){
        Student stu=new Student();
        stu.setName("JSON");
        stu.setAge("23");
        stu.setAddress("中国上海");
        Map<String,Student> map=new HashMap<String,Student>();
        map.put("first", stu);

        //1、JSONObject
        JSONObject mapObject=JSONObject.fromObject(map);
        System.out.println("mapObject" mapObject.toString());

        //2、JSONArray
        JSONArray mapArray=JSONArray.fromObject(map);
        System.out.println("mapArray:" mapArray.toString());
    }

地方打字与印刷了三种样式。

打字与印刷结果,

json字符串--》》map

mapObject{"first":{"address":"中国上海","age":"23","name":"JSON"}}
mapArray:[{"first":{"address":"中国上海","age":"23","name":"JSON"}}]

JSON字符串不能够直接转接为map对象,要想博得map中的键对应的值必要其余格局,

上边打印了两种样式。

public static void jsonToMap(){
String strObject="{"first":{"address":"中国上海","age":"23","name":"JSON"}}";
//JSONObject
JSONObject jsonObject=JSONObject.fromObject(strObject);
Map map=new HashMap();
map.put("first", Student.class);
//使用了toBean方法,需要三个参数 
MyBean my=(MyBean)JSONObject.toBean(jsonObject, MyBean.class, map);
System.out.println(my.getFirst());
}

json字符串--》》map

打字与印刷结果,

JSON字符串不可能直接转接为map对象,要想获得map中的键对应的值供给其他方法,

Student [name=JSON, age=23, address=中华夏族民共和国东京]

public static void jsonToMap(){
        String strObject="{"first":{"address":"中国上海","age":"23","name":"JSON"}}";

        //JSONObject
        JSONObject jsonObject=JSONObject.fromObject(strObject);
        Map map=new HashMap();
        map.put("first", Student.class);

        //使用了toBean方法,需要三个参数 
        MyBean my=(MyBean)JSONObject.toBean(jsonObject, MyBean.class, map);
        System.out.println(my.getFirst());

    }

下面是MyBean的代码,

打字与印刷结果,

package com.cn.study.day4;
import java.util.Map;
import com.cn.study.day3.Student;
public class MyBean {
private Student first;
public Student getFirst() {
return first;
}
public void setFirst(Student first) {
this.first = first;
}
}
Student [name=JSON, age=23, address=中国上海]

应用toBean()方法是流传了多个参数,第叁个是JSONObject对象,第2个是MyBean.class,第八个是贰个Map对象。通过MyBean能够掌握此类中要有一个first的属性,且其系列为Student,要和map中的键和值类型对应,即,first对应键 first类型对应值的类型。

下面是MyBean的代码,

如上所述是作者给我们介绍的JSON字符串与java对象的并行转换实例详解,希望对大家全部援救!

package com.cn.study.day4;

import java.util.Map;

import com.cn.study.day3.Student;

public class MyBean {

    private Student first;

    public Student getFirst() {
        return first;
    }

    public void setFirst(Student first) {
        this.first = first;
    }



}

原来的书文链接:

选取toBean()方法是流传了八个参数,第二个是JSONObject对象,第三个是MyBean.class,第多少个是三个Map对象。通过MyBean能够知道此类中要有叁个first的习性,且其项目为Student,要和map中的键和值类型对应,即,first对应键 first类型对应值的类型。

关于复杂的JSON串转化为java对象的剧情,在下篇中会继续评释。

本篇,首要表达了java中的bean、list、map和JSON的互转

有不正之处招待提议。多谢!

招待关怀下一篇内容!

编辑:亚洲城ca88唯一官方网站 本文来源:Java中JSON字符串与java对象的沟通实例详解,双层

关键词: 亚洲城ca88