json序列化_c# 时间json序列化 - CSDN
  • 一什么是JSON?  中午肚子饿了,到餐厅点餐。向服务员点了几个菜,厨师根据用户的需求,开始烹饪食物,食物烹饪好后,怎么将食物呈现给用户呢?这时就需要用到盛放食物的碗了用户拿到盛放食物的碗,就可以获得点的...

    一什么是JSON?

      中午肚子饿了,到餐厅点餐。向服务员点了几个菜,厨师根据用户的需求,开始烹饪食物,食物烹饪好后,怎么将食物呈现给用户呢?这时就需要用到盛放食物的碗了用户拿到盛放食物的碗,就可以获得点的餐了这个碗就充当了数据交换的容器了。(^ - ^)

     

      客户端向服务器端发送请求后,服务器端怎么才能把用户需要的数据返回给客户端呢。这时我们就需要用一个指定的格式将数据,按照指定格式返回客户端。这时就有了两种数据传输的方式(XMLJson):

      在普通的网络应用中,不管是服务器端还是客户端解析XML代码会非常麻烦,所以这时的Json的就更加满足数据传输解析的要求。采用的的Json格式的方式进行数据的传输,不仅方便传输解析,还特别易于人阅读和编写

    二.XML与Json的的转换:

    1.常规转换:

    <emp>
        <name>fxhl</name>
        <city>深圳</city>
        <age>23</age>
    </emp>

    转换为的Json的为:

      {“名”:“fxhl”,“城市”:“深圳”,“年龄”:23}

    三以以.json的表现形式:

      1.对象:

    {
        "returnCode": "R0000",
        "returnMsg": "成功",
        "lessTimes": "2",
        "domainLink": "",
        "seqNum": "1",
        "identification": "595279",
        "isNeedImageCode": "false"
    }

     

      2.数组:

    {
        "employees": [
            { "firstName":"John" , "lastName":"Doe" },
            { "firstName":"Anna" , "lastName":"Smith" },
            { "firstName":"Peter" , "lastName":"Jones" }
        ]
    }

     

      3.数组对象混合:

        这是截取的一小部分,对于比较复杂的的的Json格式的字符串,可以在线验证JSON。格式化一个格式。方便观看

        • JSON的表现形式一般就三种(对象,数组,字符串),使用过程中,只是将对象与数组进行混合了

     

    {
        "icon": [
            {
                "title": "尚天猫,就购了",
                "icon_category": "baobei",
                "icon_key": "icon-service-tianmao",
                "trace": "srpservice",
                "innerText": "天猫宝贝",
                "url": "//www.tmall.com/"
            },
            {  
                "title": "保险理赔",
                "position": "99",
                "innerText": "分组-保险理赔",
                "iconPopupComplex": 
            {
                    "popup_title": "保险理赔",
                    "subIcons": [
                        {
                            "dom_class": "icon-service-yunfeixian",
                            "icon_content": "卖家赠送退货运费险"
                        }
                    ]
                }
            }
        ]
    }

     

    4. 以以.json序列化和解析

     

    JSON.stringify() - 将对象序列化为JSON字符串

    JSON.parse() - 将JSON数据解析为Javascript对象

    默认情况下JSON.stringify()输出的JSON字符串不包含任何空格字符或缩进;此外,值为未定义的任何属性也都会被跳过,结果都是有效的JSON数据类型。

    实际上,JSON.stringify()除了要序列化的javascript对象之外,还可以接收两个参数(用于指定以不同方式序列化的JavaScript):1第一个参数是过滤器(可为数组或函数))2。第二个参数是一个选项(表示是否在JSON字符串中保留缩进)

    4.1 过滤结果

    •  如果过滤器的参数是数组,那么JSON.stringify()的结果将只包含数组中列出的属性。

          

    注意:第二个数组中的两个字段要与JSON中的属性对应。

    输出结果:(jsonText的值)

     

     

     

    • ü如果第二个参数是函数(传入的函数接收两个属性,属性(键)名和属性值):

     

     

    输出结果:(jsonText的值)

     

    可以看到如果键为”编辑”,通过返回未定义删除该属性。一定要提供默认项,使其他值可以显示在结果中

     

    4.12 字符串的缩进

    JSON.stringify()方法的第三个参数用于控制结果的缩进和空白符。如果这个参数是一个树枝那么他表示的是每个级别的缩进空格。

    例:要每个级别缩进4个空格

    var jsonText = JSON.stringify(book,null,4)

    注:最大缩进空格为10,所有大于10的值都会被自动转换为10。

     

    4.13 tojson()方法

    有时候JSON.stringify()不能满足自动序列化的需求。这时就可以给对象定义的toJSON()方法。

                          

    结果输出:

                        

    的toJSON()方法可以作为函数过滤器的补充假设把一个对象传入JSON.stringify(),序列化该对象的顺序:

    (1)如果存在的toJSON()方法且能通过它取得有效的值,则调用该方法,否则返回JSON本身。

    (2)如果提供了第二个参数,应用这个过滤器,传入过滤器的值是第(1)步返回的值(其实结果就是,上述的jsonText输出结果是的的toJSON()方法返回的值)

    (3)如果提供了第三个参数,执行相应的格式化操作。

     

    4.2解析结果

    JSON.parse()来来方法也可以接收另一个参数,该参数是个函数,将在每个键值对上调用。为了区别去JSON.stringify(),这个函数被称作还原函数

    如果还原函数返回未定义则删除该键,如果返回其他值,则将键插入到结果中去。

    例:在日期字符串转化为日期对象时,经常用到还原函数

                    

    输出结果:

                  

    小结:“JSON对象要求给属性加双引号,忘了给对象属性名加双引号而写成单引号都是常见的错误”。

    展开全文
  • json序列化

    2019-04-26 16:14:55
    https://www.cnblogs.com/yanweidie/p/4605212.html
    展开全文
  • Json数据的序列化与反序列化的三种常用方法介绍

    分享一下我老师大神的人工智能教程!零基础,通俗易懂!http://blog.csdn.net/jiangjunshow

    也欢迎大家转载本篇文章。分享知识,造福人民,实现我们中华民族伟大复兴!

                   

           以下内容是本作者从官网中看相应的教程后所做的demo,其体现了作者对相关知识点的个人理解。。作者才疏学浅,难免会有理解不到位的地方。。还请各位读者批判性对待。。。

           本文主要介绍在Json数据的序列化与反序列化的过程中我经常用到的三种工具的基本使用方法,及其他们之间

    的比较。。。希望能够对读者们有一些帮助。。。

    这里介绍到的三种解析与生成Json数据的方法分别是:标准JSON解析与生成方法、使用gson解析与生成JSON数据

    、使用fastJsson解析与生成JSON数据。


    首先,这些工具都可以到相应的官网中下载。以下给出我所用到的jar包的下载链接:

    1)标准JSON所用到的jar包:http://download.csdn.net/detail/caihongshijie6/6701285

    2)gson所用到的jar包:http://download.csdn.net/detail/caihongshijie6/7260481

    3)fastjson所用到的jar包:http://download.csdn.net/detail/caihongshijie6/7260485


    一、对于JSON数据的描述

           JSON是一种轻量级的数据交换格式(个人认为在很多方面上,其优于XML)。我个人将其数据形式总结如下:

    {}表示一个对象,以  键:值  对的形式给出对象的内部成员及成员变量的值。多个内部成员之间用 逗号,来隔开。

    集合和数组都用[]来表示。

           更详尽的关于JSON的描述请参考其官网:http://www.json.org/   (里面也有各种各样的解析工具)



    二、使用标准JSON的解析与生成方法

     1、首先写一个我们会用到的pojo类

    public class Person private int id; private String name; private String address;  public Person() {   } public Person(int id, String name, String address) {  super();  this.id = id;  this.name = name;  this.address = address; } public int getId() {  return id; } public void setId(int id) {  this.id = id; } public String getName() {  return name; } public void setName(String name) {  this.name = name; } public String getAddress() {  return address; } public void setAddress(String address) {  this.address = address; } @Override public String toString() {  return "Person [id=" + id + ", name=" + name + ", address=" + address    + "]"; }   }

    2、使用标准JSON进行生成与解析

    package com.njupt.pojo;import java.util.ArrayList;import java.util.Arrays;import java.util.HashMap;import java.util.List;import java.util.Map;import net.sf.json.JSONArray;import net.sf.json.JSONObject;public class Main public static void main(String[] args) {    /**   * 生成JSON字符串   *    */  //对象  Person person = new Person(1, "haungjundong","beijing");  JSONObject jsonObject = new JSONObject();  jsonObject.put("hjd", person);//  System.out.println("--------------");//  System.out.println(jsonObject.toString());//  System.out.println("--------------");      //基本数据类型  jsonObject.put("int", 123);//  System.out.println("--------------");//  System.out.println(jsonObject.toString());//  System.out.println("--------------");    jsonObject.put("string", "hello world");//  System.out.println("--------------");//  System.out.println(jsonObject.toString());//  System.out.println("--------------");    //数组  int arr[] = new int[10];  for(int i = 0 ; i < 10 ; ++i){   arr[i] = i;  }  jsonObject.put("arr", arr);//  System.out.println("--------------");//  System.out.println(jsonObject.toString());//  System.out.println("--------------");    /**   * 生成集合类型数据(1)   * 为什么不使用List<基本类型>来距离呢???   * 因为"基本类型的集合"已经有一种形式来表示了:-------->数组   * 如果一定要的话,轻易List<Integer>,然后做一个demo   */  List<String> strList = new ArrayList<String>();  for(int i = 0 ; i < 10 ; ++i){   strList.add("str" + i);  }  jsonObject.put("strList", strList);//  System.out.println("--------------");//  System.out.println(jsonObject.toString());//  System.out.println("--------------");    //生成集合类型数据(2)  List<Person> personList = new ArrayList<Person>();  for(int i = 0 ; i < 10 ; ++i){   personList.add(new Person(i, "hjd" + i, "beijing" + i));  }  jsonObject.put("personList", personList);//  System.out.println("--------------");//  System.out.println(jsonObject.toString());//  System.out.println("--------------");    /**   * 生成集合类型数据(3)   *    * 1)   * Caused by: java.lang.ClassCastException:    * JSON keys must be strings.------->JSON对象中的key必须是一个String类型的(字符串)   *    * 2)对于下面,可以这样理解(可能有一点不太准确,但是方便理解)   * map是一个对象,key为其内部成员,value是key的值   */  List<Map> mapList = new ArrayList<Map>();  for(int i = 0 ; i < 10 ; ++i){   Map map = new HashMap<String, Integer>();   map.put("" + i, 10+i);      mapList.add(map);  }  jsonObject.put("mapList", mapList);  System.out.println("--------------");  System.out.println(jsonObject.toString());  System.out.println("--------------");    System.out.println("------------------->解析json字符串");  String jsonString = jsonObject.toString();//将jsonObject转换成json字符串      JSONObject jsonObject2 = JSONObject.fromObject(jsonString);//利用json字符串生成json对象    //解析Person对象  Person person2 = new Person();  //  JSONObject personObject = (Person) jsonObject2.get("hjd");//*****这种写法是错的,原生的json的解析方法并不支持将json字符串自动转成相应的对象...  JSONObject personObject = (JSONObject) jsonObject2.get("hjd");//第一种写法//  JSONObject personObject = jsonObject2.getJSONObject("hjd");//第二种写法  person2.setId(personObject.getInt("id"));  person2.setName(personObject.getString("name"));  person2.setAddress(personObject.getString("address"));  System.out.println("--------------->person2: " + person2);  //  System.out.println("person2.getId(): " + person2.getId() + ",person2.getAddress(): " + person2.getAddress() + ",person2.getName()" + person2.getName());  //解析基本数据类型  int num = jsonObject2.getInt("int");//  System.out.println("---->num: " + num);      //解析基本类型的数组数组  JSONArray arrArray = jsonObject2.getJSONArray("arr");  int size = arrArray.size();  int arr2[] = new int[size];  for(int i = 0 ; i < size ; ++i){   arr2[i] = arrArray.getInt(i);  }//  System.out.println(Arrays.toString(arr2));    //解析List<String>  JSONArray strArray = jsonObject2.getJSONArray("strList");  List<String> strList2 = new ArrayList<String>();  int size2 = strArray.size();  for(int i = 0 ; i < size2 ; ++i){   strList2.add(strArray.getString(i));  }//  System.out.println("---------->" + strList2);      //解析List<Person>  JSONArray personArray = jsonObject2.getJSONArray("personList");  List<Person> personList2 = new ArrayList<Person>();  int size3 = personArray.size();  for(int i = 0 ; i< size3 ; ++i){   JSONObject jObject = personArray.getJSONObject(i);   Person p = new Person();      p.setId(jObject.getInt("id"));   p.setName(jObject.getString("name"));   p.setAddress(jObject.getString("address"));      personList2.add(p);  }  //  System.out.println("----------->" + personList2);      //解析List<Map>  JSONArray mapArray = jsonObject2.getJSONArray("mapList");  List<Map> mapList2 = new ArrayList<Map>();  int size4 = mapArray.size();  for(int i = 0 ; i < size4 ; ++i){   JSONObject jo = mapArray.getJSONObject(i);   Map m = new HashMap<String, Integer>();   m.put("" + i, jo.getInt("" + i));      mapList2.add(m);  }  System.out.println("--------------->" + mapList2); }}

    小结一下:使用标准JSON进行解析时,主要用到的API如下:

    生成:

    Person person = new Person(1, "haungjundong","beijing");  JSONObject jsonObject = new JSONObject();  jsonObject.put("hjd", person);

    解析时:举例如下

    []:jsonObject2.getJSONArray("arr");

    {}:jsonObject2.getJSONObject("hjd");

    基本数据类型:jsonObject2.getInt("int");


    jsonObject.toString() ---->>将json对象转换成json格式的字符串

    JSONObject jsonObject2 = JSONObject.fromObject(jsonString); -------->>利用json字符串生成json对象

    二、使用gson进行生成与解析

    1、Person类的代码同上


    2、使用gson进行生成与解析

    import java.util.ArrayList;import java.util.Arrays;import java.util.HashMap;import java.util.List;import java.util.Map;import com.google.gson.Gson;public class Main public static void main(String[] args) {    /**   * 使用gson来生成JSON字符串   */  //对象  Person person = new Person(1, "haungjundong","beijing");    Gson gson = new Gson();  String personStr = gson.toJson(person);//  System.out.println( "----------->" + personStr);    Person person2 = gson.fromJson(personStr, Person.class);//  System.out.println("------>person2: " + person2);    //数组  int arr[] = new int[10];  for(int i = 0 ; i < 10 ; ++i){   arr[i] = i;  }  String arrStr = gson.toJson(arr);//  System.out.println(arrStr);    int arr2[] = gson.fromJson(arrStr,int[].class);//****这是要注意的地方之一..//     System.out.println(Arrays.toString(arr2));      /**   * 生成集合类型数据(1)   *    * 无论是List<String>还是List<Person>还是List<Map>   * 其利用json字符串生成对象的时候,其类型都是List.class   */  List<String> strList = new ArrayList<String>();  for(int i = 0 ; i < 10 ; ++i){   strList.add("str" + i);  }  String strListStr = gson.toJson(strList);//  System.out.println("----------->" + strListStr);    List<String> strList2 = gson.fromJson(strListStr, List.class);//  System.out.println(strList2);    //生成集合类型数据(2)  List<Person> personList = new ArrayList<Person>();  for(int i = 0 ; i < 10 ; ++i){   personList.add(new Person(i, "hjd" + i, "beijing" + i));  }  String personListJsonStr = gson.toJson(personList);//  System.out.println(personListJsonStr);    List<Person> personList2 = gson.fromJson(personListJsonStr, List.class);  /**   * [{id=0.0, name=hjd0, address=beijing0}, {id=1.0, name=hjd1, address=beijing1}, {id=2.0, name=hjd2, address=beijing2}, {id=3.0, name=hjd3, address=beijing3}, {id=4.0, name=hjd4, address=beijing4}, {id=5.0, name=hjd5, address=beijing5}, {id=6.0, name=hjd6, address=beijing6}, {id=7.0, name=hjd7, address=beijing7}, {id=8.0, name=hjd8, address=beijing8}, {id=9.0, name=hjd9, address=beijing9}]   *///  System.out.println(personList2);    /**   * 生成集合类型数据(3)   *    * 1)   * Caused by: java.lang.ClassCastException:    * JSON keys must be strings.------->JSON对象中的key必须是一个String类型的(字符串)   *    * 2)对于下面,可以这样理解(可能有一点不太准确,但是方便理解)   * map是一个对象,key为其内部成员,value是key的值   */  List<Map> mapList = new ArrayList<Map>();  for(int i = 0 ; i < 10 ; ++i){   Map map = new HashMap<String, Integer>();   map.put("" + i, 10+i);      mapList.add(map);  }  String mapListJsonStr = gson.toJson(mapList);//  System.out.println(mapListJsonStr);   List<Map> mapList2 = gson.fromJson(mapListJsonStr, List.class);//  System.out.println(mapList2); }}


    小结:

    1)生成JSON数据:举例

    Gson gson = new Gson();String personStr = gson.toJson(person);


    2)解析JSON数据:举例

    Person person2 = gson.fromJson(personStr, Person.class);
    Person person2 = gson.fromJson(personStr, Person.class);

    特别需要注意的是:

    基本类型数据的解析方式: int[].class

    List类型数据的解析方式: List.class  (无论是List<String>还是List<Map>还是,List<Person>都是用的是这个)


    其实大家可以发现,我们在生成与解析的时候只是调一下gson这个对象的方法而已。除此之外,专门生成一个

    gson对象似乎没有什么用。。。

    是的,我是这么认为的。我想阿里巴巴的那帮哥们也是这么想的。所以在对性能进行进一步优化的同时,他们

    把解析的方法对做成静态的了。。。这样就不需要专门生成一个对象才能使用相应的方法


    三、使用fastjson进行生成与解析、

    特别提醒:使用fastjson将json字符串转成List<javabean>对象时,尽量使用以下方式

    List<Person> persons2 = JSON.parseArray(jsonString,Person.class);


    1、Person类的代码是一样的


    2、

    import java.util.ArrayList;import java.util.Arrays;import java.util.HashMap;import java.util.List;import java.util.Map;import com.alibaba.fastjson.JSON;public class Main public static void main(String[] args) {    /**   * 使用gson来生成JSON字符串   */  //对象  Person person = new Person(1, "haungjundong","beijing");  String personStr = JSON.toJSONString(person);//利用对象生成JSON字符串//  System.out.println(personStr);  Person person2 = JSON.parseObject(personStr, Person.class);//利用JSON字符串生成Person对象//  System.out.println(person2);      //数组  int arr[] = new int[10];  for(int i = 0 ; i < 10 ; ++i){   arr[i] = i;  }  String arrStr = JSON.toJSONString(arr);//  System.out.println(arrStr);  int arr2[] = JSON.parseObject(arrStr, int[].class);//  System.out.println(Arrays.toString(arr2));    /**   * 生成集合类型数据(1)   *    * 无论是List<String>还是List<Person>还是List<Map>   * 其利用json字符串生成对象的时候,其类型都是List.class   */  List<String> strList = new ArrayList<String>();  for(int i = 0 ; i < 10 ; ++i){   strList.add("str" + i);  }  String strListJSONStr = JSON.toJSONString(strList);//  System.out.println(strListJSONStr);  List<String> strList2 = JSON.parseObject(strListJSONStr, List.class);//  System.out.println(strList2);    //生成集合类型数据(2)  List<Person> personList = new ArrayList<Person>();  for(int i = 0 ; i < 10 ; ++i){   personList.add(new Person(i, "hjd" + i, "beijing" + i));  }  String personListJSONStr = JSON.toJSONString(personList);  /**   * 以下语句的打印结果   * [{"address":"beijing0","id":0,"name":"hjd0"},{"address":"beijing1","id":1,"name":"hjd1"},{"address":"beijing2","id":2,"name":"hjd2"},{"address":"beijing3","id":3,"name":"hjd3"},{"address":"beijing4","id":4,"name":"hjd4"},{"address":"beijing5","id":5,"name":"hjd5"},{"address":"beijing6","id":6,"name":"hjd6"},{"address":"beijing7","id":7,"name":"hjd7"},{"address":"beijing8","id":8,"name":"hjd8"},{"address":"beijing9","id":9,"name":"hjd9"}]   *///  System.out.println(personListJSONStr);  List<Person> personList2 = JSON.parseObject(personListJSONStr, List.class);  /**   * 以下语句的打印结果   * [Person [id=0, name=hjd0, address=beijing0], Person [id=1, name=hjd1, address=beijing1], Person [id=2, name=hjd2, address=beijing2], Person [id=3, name=hjd3, address=beijing3], Person [id=4, name=hjd4, address=beijing4], Person [id=5, name=hjd5, address=beijing5], Person [id=6, name=hjd6, address=beijing6], Person [id=7, name=hjd7, address=beijing7], Person [id=8, name=hjd8, address=beijing8], Person [id=9, name=hjd9, address=beijing9]]   *///  System.out.println(personList);    /**   * 生成集合类型数据(3)   *    * 1)   * Caused by: java.lang.ClassCastException:    * JSON keys must be strings.------->JSON对象中的key必须是一个String类型的(字符串)   *    * 2)对于下面,可以这样理解(可能有一点不太准确,但是方便理解)   * map是一个对象,key为其内部成员,value是key的值   */  List<Map> mapList = new ArrayList<Map>();  for(int i = 0 ; i < 10 ; ++i){   Map map = new HashMap<String, Integer>();   map.put("" + i, 10+i);      mapList.add(map);  }  String mapListJSONStr = JSON.toJSONString(mapList);//  System.out.println(mapListJSONStr);  List<Map> mapList2 = JSON.parseObject(mapListJSONStr, List.class);//  System.out.println(mapList2);   }}

    小结:

    1)生成JSON格式的数据

    JSON.toJSONString(person);//利用对象生成JSON字符串

    2)解析JSON格式的数据

    JSON.parseObject(arrStr, int[].class);

    注意:

    fastjson与gson的使用方式很像。但是在一些细节方面上还是用有区别的。这些细节上的差别在服务器与客户端的数据进行交互的时候可能产生的影响是很大的。还请各位读者认真思考在使用。个人比较倾向于使用fastjson,个人认为他在一些细节方面处理得要比google的gson处理得好。。。


    四、三者之间的比较

    标准JSON的生成与解析方法与gson、fastjson之间最大的区别就在于:标准JSON的生成与解析方法无法利用JSON

    数据自动生成相应的对象和数据。使用标准JSON进行生成相应的对象时,只能是一个一个的获取器成员变量的数据,然后一个一个地set()。。


    五、写在最后

    更多的只是还请各位读者到相应的官网去查找相应的教程。。如果有错误还请多多包涵并且批评指出(不要吐槽的太厉害哈~~~~吐舌头)



    六、源码下载

    http://download.csdn.net/detail/caihongshijie6/7260637














               

    给我老师的人工智能教程打call!http://blog.csdn.net/jiangjunshow

    这里写图片描述
    展开全文
  • 目前数据交互中最常用的数据交互格式莫过于json了,那么在java开发中经常会遇到json的序列化与反序列化,常用的json序列化工具有阿里的Fastjson、spring mvc内置的Jackson、还有就是我们接下来要说的谷歌的Gson。...

    Java技术交流群:817997079,欢迎“有志之士”的加入。

    阿里云服务器优惠链接:https://www.aliyun.com/minisite/goods?userCode=epd6ezxj

    目前数据交互中最常用的数据交互格式莫过于json了,那么在java开发中经常会遇到json的序列化与反序列化,常用的json序列化工具有阿里的Fastjson、spring mvc内置的Jackson、还有就是我们接下来要说的谷歌的Gson。

    GSON是Google提供的用来在Java对象和JSON数据之间进行映射的Java类库。可以将一个Json字符转成一个Java对象,或者将一个Java转化为Json字符串。

         Gson特点:1:面向对象;2:简洁高效;3:数据传递和解析方便

    下面介绍一下Gson的常用方法

    首先贴一下我用来做示例的实体类Test的代码,如下:

    public class Test {
        /* 姓名*/
        private String name;
        /* 性别*/
        private String sex;
        /* 年龄*/
        private Integer age;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "StudentEntity{" +
                    "name='" + name + '\'' +
                    ", sex='" + sex + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        public Test(String name, String sex, Integer age) {
            this.name = name;
            this.sex = sex;
            this.age = age;
        }
    

    1.gson.tojso();//形参为要序列化的json串

    方法作用:把实体对象转换为json(序列化)

    public static void main(String[] args) {
           //创建实体类
          Test test = new Test("序列化", "男", 25);
          //实例化Gson
          Gson gson = new Gson();
          //把对象序列化为json
          String s = gson.toJson(test);
          //输出---序列化后的结果为:{"name":"序列化","sex":"男","age":25}
          System.out.println("序列化后的结果为:"+s);
          //定义List集合
          List<Test> tests = new ArrayList<>();
          tests.add(test);
          String s1 = gson.toJson(tests);
          //输出---List集合序列化后的结果为:[{"name":"序列化","sex":"男","age":25}]
          System.out.println("List集合序列化后的结果为:"+s1);
          Map<String, Test> testMap = new HashMap<>();
          testMap.put("序列化测试",test);
          //输出--Map集合序列化后的结果为:{序列化测试=StudentEntity{name='序列化', sex='男', age=25}}
          System.out.println("Map集合序列化后的结果为:"+testMap);
    }

    2.gson.fromJson();

    方法作用:

    (1)把json转换为List对象(反序列化)

    public static void main(String[] args) {
          // 定义json
          String json = "[{\"name\":\"转换对象\",\"sex\":\"女\",\"age\":20}]";
          //实例化Gson
          Gson gson = new Gson();
          //把json序列化为List对象
          List<Test> o = gson.fromJson(json, new TypeToken<List<Test>>() {
          }.getType());
          //输出---序列化后的结果为:[StudentEntity{name='转换对象', sex='女', age=20}]
          System.out.println("反序列化成List后的结果为:"+o.toString());
      }

    (2)把json转换为Map对象(反序列化)

    public static void main(String[] args) {
          //实例化Gson
          Gson gson = new Gson();
          //定义json
          String jsonMap = "{'序列化测试':{name='序列化', sex='男', age=25}}";
          //把json序列化为Map对象
          HashMap<String,Test> o1 = gson.fromJson(jsonMap, new TypeToken<HashMap<String,Test>>() {
          }.getType());
          //输出---{序列化测试=StudentEntity{name='序列化', sex='男', age=25}}
          System.out.println("反序列化成Map后的结果为:"+o1);
      }

    (3)把json转换为实体对象(反序列化)

    public static void main(String[] args) {
          // 定义json
          String json = "{\"name\":\"转换对象\",\"sex\":\"女\",\"age\":20}";
          //实例化Gson
          Gson gson = new Gson();
          //把json序列化为实体类(Test)对象
          Test test = gson.fromJson(json, Test.class);
          //输出---反序列化后的结果为:StudentEntity{name='转换对象', sex='女', age=20}
          System.out.println("反序列化成实体类后的结果为:"+test.toString());
      }

    划重点--------------------------------------------------------------------------------------

    一、把实体类序列化为json时,如果实体类某个属性的值为null,gson在序列化该对象是则默认过滤掉该属性,该属性不会参与序列化。

    二、反序列化时需注意json串的格式,如果是数组则最外层是用‘[ ]’来包括的,如果是对象或者是Map则是用‘{ }’来包括的,根据需要反序列化的json格式来选定需要反序列化用的方法gson.fromJson()应该传递哪种参数,反序列化成对象参数应该是这个对象的反射(entity.Class),如果是List或者是Map,参数则是泛型

    分享到这里就结束了,欢迎技术党一起交流技术心得。

                                                                                                                     ---------------------------------------------纯属原创,不喜勿喷。

    展开全文
  • 1、Json序列化为List时需要引用: using System.Collections.Generic; using System.Web.Script.Serialization; using System; using System.Collections.Generic; using System.Web.Script.Serialization; ...

    1、Json序列化为List时需要引用:

    using System.Collections.Generic;
    using System.Web.Script.Serialization;

    using System;
    using System.Collections.Generic;
    using System.Web.Script.Serialization;
    namespace Json_S
    {
        /// <summary>
        /// JsonToList 的摘要说明
        /// </summary>
        public static class JsonToList
        {
            /// <summary>
            /// 原始Json字符串反序列化为泛型集合
            /// </summary>
            /// <typeparam name="T">反序列化的类型</typeparam>
            /// <param name="JsonStr">原始Json字符串</param>
            /// <returns>反序列化后的泛型集合</returns>
            public static List<T> JSONStringToList<T>(this string JsonStr)
            {
                JavaScriptSerializer Serializer = new JavaScriptSerializer();
                List<T> objs = Serializer.Deserialize<List<T>>(JsonStr);
                return objs;
            }
    
    
    
        }
    }

    2、需要序列化为什么类型的定义

    using System;
    using System.Runtime.Serialization;
    
    namespace Shopping
    {
        [DataContract]
        public class SpecificationsList
        {
    
            /// <summary>
            /// 属性1名称
            /// </summary>
            [DataMember]
            public string SpecificationsID1 { set; get; }
    
    
            /// <summary>
            ///  属性1值
            /// </summary>
            [DataMember]
            public string SpecificationsValue1 { set; get; }
    
            /// <summary>
            /// 属性2名称
            /// </summary>
            [DataMember]
            public string SpecificationsID2 { set; get; }
    
            /// <summary>
            /// 属性2值
            /// </summary>
            [DataMember]
            public string SpecificationsValue2 { set; get; }
    
            /// <summary>
            /// 属性3名称
            /// </summary>
            [DataMember]
            public string SpecificationsID3 { set; get; }
    
            /// <summary>
            /// 属性3值
            /// </summary>
            [DataMember]
            public string SpecificationsValue3 { set; get; }
    
            /// <summary>
            /// 进价
            /// </summary>
            [DataMember]
            public string CostPrice { set; get; }
    
            /// <summary>
            /// 单价
            /// </summary>
            [DataMember]
            public string MarketPrice { set; get; }
    
    
            /// <summary>
            /// 市场价
            /// </summary>
            [DataMember]
            public string Price { set; get; }
    
            /// <summary>
            /// 库存
            /// </summary>
            [DataMember]
            public string Inventory { set; get; }
    
        }
    }

    3、使用方法

     List<Shopping.SpecificationsList> model = Json_S.JsonToList.JSONStringToList<Shopping.SpecificationsList>(Json_str);

    4.Json序列化和反序列化方法

     /// <summary>
        /// Json序列化帮助类
        /// 提供一系列的关于Json序列化/反序列化的操作
        public class json
        {
            /// <summary>
            /// 原始泛型对象序列化为Json字符串,返回序列化后的Json字符串
            /// 序列化失败则返回null
            /// </summary>
            /// <typeparam name="T">序列化的类型</typeparam>
            /// <param name="t">原始泛型对象</param>
            /// <returns>序列化后的Json字符串</returns>
            public static string JsonSerializer<T>(T t)
            {
    
                DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T));
    
                MemoryStream ms = new MemoryStream();
    
                ser.WriteObject(ms, t);
    
                string jsonString = Encoding.UTF8.GetString(ms.ToArray());
    
                ms.Close();
    
                return jsonString;
    
            }
    
    
    
            /// <summary>
            /// 原始Json字符串反序列化为泛型对象,返回反序列化后的泛型对象
            /// 序列化失败则返回泛型默认值
            /// </summary>
            /// <typeparam name="T">反序列化的类型</typeparam>
            /// <param name="jsonString">原始Json字符串</param>
            /// <returns>反序列化后的泛型对象</returns>
    
            public static T JsonDeserialize<T>(string jsonString)
            {
                //处理错误参数
                if (String.IsNullOrEmpty(jsonString))
                {
                    return default(T);
                }
                else { }
    
                DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T));
    
                MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonString));
    
                T obj = (T)ser.ReadObject(ms);
    
                return obj;
    
            }
        }

    5、使用方法

           1.反序列化

     Shopping.SpecificationsList list = Njson.json.JsonDeserialize<Shopping.SpecificationsList>(Json_str);

          2.序列化

     List<about> list = new List<about>();
     about bt = new about();
     bt.Adds = rice.Tables[0].Rows[0]["desn"].ToString();
     list.Add(bt);    
     string str= Json.Serialize(list)

    自己做的笔记仅供参考,不喜勿喷,谢谢!!1

    展开全文
  • JSON序列化工具

    2018-07-17 11:06:12
    import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; import com.alibaba.fastjson.JSONPath; import ...
  • 序列化、反序列化与jsoncpp学习
  • 摘要:Java将对象序列化成为JSON格式、JSON格式反序列化为Java对象。 一:引入jackson的依赖: &lt;dependency&gt; &lt;groupId&gt;org.codehaus.jackson&lt;/groupId&gt; &lt;...
  • 【什么是Json】  序列化:将对象转换成字节流的过程,这样就可以轻松将对象保存在磁盘... 当前主流的序列化JSON字符串主要有两种方式:JavaScriptSerializer及Json.net(Nuget标识:Newtonsoft.Json)。JavaS...
  • 一、JSON序列化枚举 1.这个示例使用了一个JsonConverter定制如何序列化JSON与反序列化枚举 using System; using System.Collections.Generic; using System.Linq; using System.Text; using GongHuiNewtonsoft.Json;...
  • json序列化:把python的数据类型转换为json的字符串 json反序列化:把json的字符串转换为python的数据类型 ''' '''字典的序列化与反序列化''' # 字典的序列化 import json dict1 = {'name': 'AI', 'age': 18, '...
  • 分享一下最近被解决的一个问题点——时间类型被Json序列化。 数据查询代码: 结果: 在查询出数据库有关时间的数据后通过return Json 返回往往会导致数据的序列化。 解决时间类型被Json序列化 出生日期(/Date...
  • 项目中竟然遇到了这样的问题,要求客户端请求的方式为:参数按照json序列化,然后使用post方式传递给服务器。第一次看到这个东东有点一头雾水,刚开始开发的时候全部使用的get请求方式,因为当时公司不考虑数据安全...
  • 一:背景 作为一名C++开发人员,我一直很期待能够像C#与JAVA那样,可以轻松的进行对象的...本方案采用JsonCpp来做具体的JSON的读入与输出,再结合类成员变量的映射,最终实现对象的JSON序列化与反序列化。 本文不再
  • 1、JSON序列化 是将对象的属性以键值对的形式组织成字符串(一个编码过程),显然体积会增大很多。 而且解码后也不能直接还原回原来的对象 2、二进制序列化 是将对象的内存映射抽取出来形成字符串,还原时只有...
  • C++对象的JSON序列化与反序列化探索 C++对象的JSON序列化与反序列化探索续-复杂对象的序列化与反序列化 经过一番折腾,总算把带有列表的对象的序列化完成了,目前支持 list 和 vector 的列表,以及自定义的...
  • Newtonsoft.Json,是.Net中开源的Json序列化和反序列化工具,官方地址:http://www.newtonsoft.com/json。 功能比较多,效率比较高,官方给出对比数据 50% faster than DataContractJsonSerializer, and 250% faster...
  • 很多人都知道rapidjson这个json库,大家也都知道他的高效,可是你一定也对他的使用方法,函数API接口感受到非常不适应,你一定非常怀念使用java和C#对一个实体类的那么轻松加简单的直接json序列化,是的本篇博客将...
  • public class JsonSerializer { /// /// json序列化 /// /// /// /// public static string JsonStringSerializer(T t) { Data
  • 序列化:指将数据结构或对象状态转换成可取用格式(例如存成文件,存于缓冲,或经由网络中发送),以留待后续在相同或...json序列化:将有 key-value 结构的数据类型(比如结构体、map、切片)序列化成json字符串的操作。
1 2 3 4 5 ... 20
收藏数 148,130
精华内容 59,252
关键字:

json序列化