JSON解析----个人学习笔记

 

JSON简介

JSON(JavaScriptObject Notation)是一种轻量级的数据交换方式，

将对象转换成字符串对象进行信息发送，

JSON 需要导入第三方jar包

JSON数据作为目前网络中主流的数据传输格式之一，应用十分广泛

 

JSON解析的三种方式：

JSON

GSON

 FASTJSON

JSON可以表示的数据：

     对象:对象表示用“{}”扩起来的内容

          数据结构为：{name:zhangsan,age:20}

    数组：数组表示用“[]”扩起来的内容，

          数据结构为：[“北京”,”上海”,”广州”]

将两种结合起来表示的方式：

{

 “User”[{name:zhangsan,age:20},{name:lisi,age:3}]

}

含义：在对象中有个带有索引的数组，数组里面是以对象为元素

  

JSON解析简单例子《每种对象解析操作代码在不同类中有相同的颜色》：

（1）    Person 类  属于实体类，用于生成类对象，里面有 name,age,address属性

（2）    ServiceBean 生成要进行操作的对象 

           《1》用函数直接返回Person对象

           《2》用函数返回list集合，集合元素为Person对象

         《3》用函数返回list集合，集合元素为String的字符串

         《4》用函数返回list集合 ，集合元素为map《》集合

（3）    Jsonools 类

createJsonString能将所有种类的对象通过json解析调用方法转换成字符串

其他每个类是将对具有不同格式对象的字符串解析成对象

这个业务类实现了生成各种对象，有的类将这些对象装在集合对象里进行返回，有的直接将对象返回

ServiceBean.java

// 自定义业务组件类

public class ServiceBean {

      //返回一个实体对象Person

      publicstatic Person getPerson(){

            Person p=new Person("张三",20,"北京");

            return p;

      }

//返回实体集合对象

      publicstatic List getListPerson(){

            List persons=newArrayList();

            persons.add(new Person("张三",20,"北京"));

            persons.add(new Person("李四",22,"上海"));

            persons.add(new Person("小丽",25,"广州"));

            persons.add(new Person("小梅",23,"深圳"));

            persons.add(new Person("小芳",18,"湖北"));

            persons.add(new Person("小郭",21,"东北"));

            return persons;

      }

//返回字符串的集合

      publicstatic List getListString(){

            List strings=newArrayList();

            strings.add("北京");

            strings.add("上海");

            strings.add("广州");

            strings.add("深圳");

            strings.add("杭州");

            return strings;

      }

//返回map对象的集合

      publicstatic List> getMaps(){

            List>maps=new ArrayList>();

            Map map1=newHashMap();

            map1.put("name","小丽");

            map1.put("age",18);

            map1.put("addr","北京");

            maps.add(map1);        

            Map map2=new HashMap();

            map2.put("name","小梅");

            map2.put("age",28);

            map2.put("addr","上海");

            maps.add(map2);  

            Map map3=newHashMap();

            map3.put("name","小剑");

            map3.put("age",20);

            map3.put("addr","广州");

            maps.add(map3);

            return maps;

      }

}

Person.java

package com.hsj.domain;

 自定义Person类

publicclass Person {

 //这里代码就省了，很简单，声明三个私有的name,age,address属性，并生成它们的get，set，toString方法，以及构造函数

}

//这个类实现了用同一个函数将不同对象转换成字符串，用不同函数将不同种类的字符串转换成相应的对象

JsonTools.java

/**

 *自定义Json工具类.

 * JSON工具类主要干以下两件事：

 * A:将java对象转化成Json字符串

 *  B:将Json字符串还原成相应的Java对象

 */

public classJsonTools {

       /**

        *将java对象转化成Json字符串

        *@param key json字符串中的键

        *@param value json字符串中的对象

        *@return json字符串

        */

       public static StringcreateJsonString(String key,Object value){

              //1.实例化Json对象

              JSONObjectjsonObject=new JSONObject();

              //2.将指定的键和value添加到Json对象中

              jsonObject.put(key,value);

              //3.将json对象转化成json字符串

              StringjsonString=jsonObject.toString();

              returnjsonString;

       }

      

       /**

        * {"person":{"addr":"北京","age":20,"name":"张三"}}

        *

        * 将json字符串还原成java对象

        *@param json json字符串

        *@return java对象

        */

       public static Person getPerson(Stringjson){

              //1.实例化JSON对象

              JSONObjectjsonObject=new JSONObject();

              //2.将给定的json字符串还原成JSON对象

              jsonObject=jsonObject.fromObject(json);

              //3.解析JSON对象得到需要的数据

              jsonObject=jsonObject.getJSONObject("person");

              Stringname=jsonObject.getString("name");

              intage=jsonObject.getInt("age");

              Stringaddr=jsonObject.getString("addr");       

              Personp=new Person(name,age,addr);

              return p;

       }

       /**

        * {"persons":[

        *               {"addr":"北京","age":20,"name":"张三"},

        *                {"addr":"上海","age":22,"name":"李四"},

        *                {"addr":"广州","age":25,"name":"小丽"},

        *                {"addr":"深圳","age":23,"name":"小梅"},

        *                {"addr":"湖北","age":18,"name":"小芳"},

        *              {"addr":"东北","age":21,"name":"小郭"}

        *         ]

              }

        * 将给定的json字符串还原成java对象

        *@param json json字符串

        *@return java对象

        */

       public static ListgetListPerson(String json){

              Listpersons=new ArrayList();

             

              //1.实例化JSON对象

              JSONObjectjsonObject=new JSONObject();

              //2.将指定的json字符串传递给json对象返回json对象

              jsonObject=jsonObject.fromObject(json);

              //3.解析Json字符串

              JSONArrayjsonArray=jsonObject.getJSONArray("persons");

              //获取json数组中元素的个数

              intsize=jsonArray.size();

              for(inti=0;i

                     jsonObject=jsonArray.getJSONObject(i);

                     Stringname=jsonObject.getString("name");

                     int age=jsonObject.getInt("age");

                     Stringaddr=jsonObject.getString("addr");

                     Person p=new Person(name,age,addr);

                     persons.add(p);

              }

              returnpersons;

       }

       /**

        * {"citys":["北京","上海","广州","深圳","杭州"]}

        * 将给定的json字符串还原成java对象

        *@param json json字符串

        *@return java对象

        */

       public static ListgetListString(String json){

              Liststrings=new ArrayList();

             

              JSONObjectjsonObject=new JSONObject();

              jsonObject=jsonObject.fromObject(json);

              JSONArrayjsonArray=jsonObject.getJSONArray("citys");

              intsize=jsonArray.size();

              for(inti=0;i

                     String city=jsonArray.get(i).toString();

                     strings.add(city);

              }

              returnstrings;

       }

      

       /**

        * {"maps":[

        *               {"age":18,"name":"小丽","addr":"北京"},

        *               {"age":28,"name":"小梅","addr":"上海"},

        *               {"age":20,"name":"小剑","addr":"广州"}

        *          ]

     * }

        * 将给定的json字符串还原成java对象

        *@param json json字符串

        *@return java对象

        */

       public staticList> getMaps(String json){

              List>maps=new ArrayList>();

              JSONObjectjsonObject=new JSONObject();

              jsonObject=jsonObject.fromObject(json);

              JSONArrayjsonArray=jsonObject.getJSONArray("maps");

              intsize=jsonArray.size();

              for(inti=0;i

                     jsonObject=jsonArray.getJSONObject(i);

                     Stringname=jsonObject.getString("name");

                     intage=jsonObject.getInt("age");

                     Stringaddr=jsonObject.getString("addr");

                     Map map=newHashMap();

                     map.put("name",name);

                     map.put("age",age);

                     map.put("addr",addr);

                     maps.add(map);

              }

              returnmaps;

       }

}

//这个类是主类 ，负责获取ServiceBean中的对象内容，通过JsonTools方法转换成字符串，再将字符串通过对应的方法转换成相应的对象

TestRawParseJsonDemo01.java

publicclass TestRawParseJsonDemo01 {

       public static void main(String[] args) {

       /*    //1.从数据源中得到数据

              Personp1=ServiceBean.getPerson();

              //2.将对象转化成json字符串

              StringjsonString=JsonTools.createJsonString("person",p1);

              //{"person":{"addr":"北京","age":20,"name":"张三"}}

              System.out.println("jsonString="+jsonString);

              //3.将给定的json字符串还原成java对象

              Personp=JsonTools.getPerson(jsonString);

              System.out.println("p="+p);

              */

              /*//1.从数据源中得到数据

              Listpersons=ServiceBean.getListPerson();

              //2.将java对象转化成json字符串

              StringjsonString=JsonTools.createJsonString("persons",persons); 

               *{"persons":[

               *          {"addr":"北京","age":20,"name":"张三"},

               *         {"addr":"上海","age":22,"name":"李四"},

               *         {"addr":"广州","age":25,"name":"小丽"},

               *         {"addr":"深圳","age":23,"name":"小梅"},

               *         {"addr":"湖北","age":18,"name":"小芳"},

               *         {"addr":"东北","age":21,"name":"小郭"}

               *  ]

               * }

              System.out.println("jsonString="+jsonString);

              //3.将给定的json字符串还原成java对象

              Listjson_persons=JsonTools.getListPerson(jsonString);

              System.out.println("json_persons="+json_persons);

              */

              /*//1.得到数据源

              Liststrings=ServiceBean.getListString();

              //2.将给定的java对象转化成json字符串

              StringjsonString=JsonTools.createJsonString("citys",strings);

              //{"citys":["北京","上海","广州","深圳","杭州"]}

              System.out.println("jsonString="+jsonString);

              //3.根据json字符串还原java对象

              Listjson_strings=JsonTools.getListString(jsonString);

              System.out.println("json_strings="+json_strings);*/

              //1.得到数据源

              List> maps=ServiceBean.getMaps();

              //2.将给定的java对象转化成json字符串

              StringjsonString=JsonTools.createJsonString("maps",maps);

              /*

               * {"maps":[

               *                 {"age":18,"name":"小丽","addr":"北京"},

               *                 {"age":28,"name":"小梅","addr":"上海"},

               *                 {"age":20,"name":"小剑","addr":"广州"}

               *            ]

               * }

               */

              System.out.println("jsonString="+jsonString);

              //3.将给定的json字符串还原成java对象

              List>json_maps=JsonTools.getMaps(jsonString);

              System.out.println("json_maps="+json_maps);

       }

}