C#将集合和Json格式互相转换的几种方式（c# 集合转字符串）

25-02-18 18

本文的目的是介绍C#将集合和Json格式互相转换的几种方式的详细情况，特别关注c#集合转字符串的相关信息。我们将通过专业的研究、有关数据的分析等多种方式，为您呈现一个全面的了解C#将集合和Json格式

本文的目的是介绍C#将集合和Json格式互相转换的几种方式的详细情况，特别关注c# 集合转字符串的相关信息。我们将通过专业的研究、有关数据的分析等多种方式，为您呈现一个全面的了解C#将集合和Json格式互相转换的几种方式的机会，同时也不会遗漏关于ABAP和XML数据格式互相转换的两种方式、C# 对象与JSON字符串互相转换的三种方式、C#中对象与JSON字符串互相转换的三种方式、jackson java对象和json对象的互相转换的知识。

本文目录一览：

C#将集合和Json格式互相转换的几种方式（c# 集合转字符串）
ABAP和XML数据格式互相转换的两种方式
C# 对象与JSON字符串互相转换的三种方式
C#中对象与JSON字符串互相转换的三种方式
jackson java对象和json对象的互相转换

C#将集合和Json格式互相转换的几种方式（c# 集合转字符串）

转自http://blog.sina.com.cn/s/blog_84ee61a901018erd.html

使用微软自带的System.Web.Extensions.dll
该DLL文件一般存在于如下路径：c:\Program Files\Reference Assemblies\Microsoft\Framework\v3.5\System.Web.Extensions.dll

//将List集合转换为Json字符串，
JavaScriptSerializer serializer = new JavaScriptSerializer();
List<Person> list = new List<Person>();
for (int i = 0; i < 10; i++)
{
    Person p = new Person("张三" + i, "重庆" + i, "10" + i);
    list.Add(p);
}
MessageBox.Show(serializer.Serialize(list));

//将Json字符串转换为集合，Person为自己定义的实体类
    string json = "[{''Address'':''重庆0'',''Age'':''100'',''Name'':''张三0''},{''Address'':''重庆1'',''Age'':''101'',''Name'':''张三1''}]";
    JavaScriptSerializer serializer = new JavaScriptSerializer();
    List<Person> list = serializer.Deserialize<List<Person>>(json);

2. MVC程序的话，可以直接用Json(sssss)

ABAP和XML数据格式互相转换的两种方式

ABAP和XML数据格式互相转换是广大开发人员经常遇到的需求。本文介绍两种方式。

1. ABAP提供了一个工具类cl_proxy_xml_transform，通过它的两个方法abap_to_xml_xstring和xml_xstring_to_abap实现两种格式的互换。

看具体例子：

REPORT zxm.

DATA: ls_abap TYPE zzcrmost__pro001dotproduct1.

DATA: ls_line LIKE LINE OF ls_abap-item.

ls_line-logsys = ‘AG3‘.

ls_line-object_family = ‘0401‘.

ls_line-product_id = ‘MCF-0001‘.

ls_line-product_type = ‘01‘.

APPEND ls_line TO ls_abap-item.

ls_line-logsys = ‘QDD‘.

ls_line-object_family = ‘0402‘.

ls_line-product_id = ‘MCF-0002‘.

ls_line-product_type = ‘02‘.

APPEND ls_line TO ls_abap-item.

DATA(xml) = cl_proxy_xml_transform=>abap_to_xml_xstring( EXPORTING abap_data = ls_abap ddic_type = ‘ZZCRMOST__PRO001DOTPRODUCT1‘ ).

DATA: ls_abap2 LIKE ls_abap,ls_abap3 LIKE ls_abap.

cl_proxy_xml_transform=>xml_xstring_to_abap( EXPORTING ddic_type = ‘ZZCRMOST__PRO001DOTPRODUCT1‘ xml = xml IMPORTING abap_data = ls_abap2 ).

ASSERT ls_abap2 = ls_abap.

最后一行的ASSERT语句，说明从ABAP格式转换成XML格式，再转换成ABAP格式，转换前的ABAP数据和转换后的ABAP数据是完全相同的。

上述ABAP代码使用到的结构体zzcrmost__pro001dotproduct1类型定义如下：

如果我们单步调试工具类cl_proxy_xml_transform，发现它也没有神奇之处，

内部生成了一个ABAP simple transformation，以此来实现ABAP和XML格式的互相转换。

在调试器里记录下这个生成的transformation ID，然后用事务码STRANS打开，就可以看到明细了。

2. 有了方法1单步调试发现simple transformation的提示，我们可以用另一种更简单的办法实现两种格式的互换，即直接调用simple transformation：

DATA: lv_xml TYPE string.

CALL TRANSFORMATION id SOURCE b = ls_abap RESULT XML lv_xml.

生成的XML的根节点名称为b，因为上面代码调用参数SOURCE，将ABAP变量ls_abap传入时，绑定的参数名为“b”。

CALL TRANSFORMATION id SOURCE XML lv_xml RESULT b = ls_abap3.

ASSERT ls_abap2 = ls_abap3. 用这种方式进行ABAP->XML->ABAP仍然能得到最初的ABAP变量的值。

要获取更多Jerry的原创技术文章，请关注公众号"汪子熙"或者扫描下面二维码:

C# 对象与JSON字符串互相转换的三种方式

<div id="cnblogs_post_body"><h1>C# 对象与JSON字符串互相转换的三种方式</h1> JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式。 　　关于内存对象和JSON字符串的相互转换，在实际项目中应比较广泛，经过一番搜索，找到如下三种方法来解决此问题 分别是使用 Newtonsoft.Json.dll、DataContractJsonSerializer、 JavaScriptSerializer。  <h2>方法一： Newtonsoft.Json.dll </h2> Newtonsoft.Json.dll在.net2.0之后的版本可以支持我的版本.net framework4.0 <h3>添加Newtonsoft.json的引用</h3> <img src="https://images2018.cnblogs.com/blog/1070330/201803/1070330-20180323094148437-781533868.png" alt=""> <h3>对象与json字符串转换类设计</h3> <div><div><a href="javascript:void(0);" onclick="copyCnblogsCode(this)" title="复制代码"><img src="//common.cnblogs.com/images/copycode.gif" alt="复制代码"></a></div> <pre> 1 class JsonNewtonsoft 2 { 3 /// <summary> 4 /// 把对象转换为JSON字符串 5 /// </summary> 6 /// <param name="o">对象</param> 7 /// <returns>JSON字符串</returns> 8 public static string ToJSON(this object o) 9 { 10 if (o == null) 11 { 12 return null; 13 } 14 return JsonConvert.SerializeObject(o); 15 } 16 /// <summary> 17 /// 把Json文本转为实体 18 /// </summary> 19 /// <typeparam name="T"></typeparam> 20 /// <param name="input"></param> 21 /// <returns></returns> 22 public static T FromJSON<T>(this string input) 23 { 24 try 25 { 26 return JsonConvert.DeserializeObject<T>(input); 27 } 28 catch (Exception ex) 29 { 30 return default(T); 31 } 32 } 33 }</pre> <div><a href="javascript:void(0);" onclick="copyCnblogsCode(this)" title="复制代码"><img src="//common.cnblogs.com/images/copycode.gif" alt="复制代码"></a></div></div> <h2>方法二：DataContractJsonSerializer</h2>  使用这种需要引用 System.Runtime.Serialization.dll <h3>类设计</h3> <div><div><a href="javascript:void(0);" onclick="copyCnblogsCode(this)" title="复制代码"><img src="//common.cnblogs.com/images/copycode.gif" alt="复制代码"></a></div> <pre> 1 class JsonDataContractJsonSerializer 2 { 3 /// <summary> 4 /// 内存对象转换为json字符串 5 /// </summary> 6 /// <param name="obj"></param> 7 /// <returns></returns> 8 public static string ObjectToJson(object obj) 9 { 10 DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType()); 11 MemoryStream stream = new MemoryStream(); 12 serializer.WriteObject(stream, obj); 13 byte[] dataBytes = new byte[stream.Length]; 14 stream.Position = 0; 15 stream.Read(dataBytes, 0, (int)stream.Length); 16 return Encoding.UTF8.GetString(dataBytes); 17 } 18 /// <summary> 19 /// Json字符串转内存对象 20 /// </summary> 21 /// <param name="jsonString"></param> 22 /// <param name="obj"></param> 23 /// <returns></returns> 24 public static object JsonToObject(string jsonString, object obj) 25 { 26 DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType()); 27 MemoryStream mStream = new MemoryStream(Encoding.UTF8.GetBytes(jsonString)); 28 return serializer.ReadObject(mStream); 29 } 30 }</pre> <div><a href="javascript:void(0);" onclick="copyCnblogsCode(this)" title="复制代码"><img src="//common.cnblogs.com/images/copycode.gif" alt="复制代码"></a></div></div> <h2>方法三：JavaScriptSerializer</h2> 需要引用：System.Web.Extensions.dll <h3>类设计</h3> <div><div><a href="javascript:void(0);" onclick="copyCnblogsCode(this)" title="复制代码"><img src="//common.cnblogs.com/images/copycode.gif" alt="复制代码"></a></div> <pre> 1 public static class JsonJavaScriptSerializer 2 { 3 /// <summary> 4 /// 内存对象转换为json字符串 5 /// </summary> 6 /// <param name="obj"></param> 7 /// <returns></returns> 8 public static string ToJSON(object obj) 9 { 10 StringBuilder sb = new StringBuilder(); 11 JavaScriptSerializer json = new JavaScriptSerializer(); 12 json.Serialize(obj, sb); 13 return sb.ToString(); 14 } 15 /// <summary> 16 /// Json字符串转内存对象 17 /// </summary> 18 /// <param name="jsonString"></param> 19 /// <param name="obj"></param> 20 /// <returns></returns> 21 public static T FromJSON<T>(string jsonString) 22 { 23 JavaScriptSerializer json = new JavaScriptSerializer(); 24 return json.Deserialize<T>(jsonString); 25 } 26 27 }</pre> <div><a href="javascript:void(0);" onclick="copyCnblogsCode(this)" title="复制代码"><img src="//common.cnblogs.com/images/copycode.gif" alt="复制代码"></a></div></div> <h2>程序测试：</h2> <h3>新建一个测试对象类Student.cs</h3> <div><div><a href="javascript:void(0);" onclick="copyCnblogsCode(this)" title="复制代码"><img src="//common.cnblogs.com/images/copycode.gif" alt="复制代码"></a></div> <pre> 1 public enum Sex 2 { 3 男=0, 4 女=1 5 } 6 [Serializable()] 7 class Student 8 { 9 private string _name; 10 11 public string Name 12 { 13 get { return _name; } 14 set { _name = value; } 15 } 16 17 private int _age; 18 19 public int Age 20 { 21 get { return _age; } 22 set { _age = value; } 23 } 24 25 private Sex _sex = Sex.男; 26 27 public Sex Sex 28 { 29 get { return _sex; } 30 set { _sex = value; } 31 } 32 public Student() 33 { } 34 public Student(string name,int age,Sex sex) 35 { 36 this._name = name; 37 this._age = age; 38 this._sex = sex; 39 } 40 }</pre> <div><a href="javascript:void(0);" onclick="copyCnblogsCode(this)" title="复制代码"><img src="//common.cnblogs.com/images/copycode.gif" alt="复制代码"></a></div></div> <h3>测试程序</h3> <div><div><a href="javascript:void(0);" onclick="copyCnblogsCode(this)" title="复制代码"><img src="//common.cnblogs.com/images/copycode.gif" alt="复制代码"></a></div> <pre> 1 static void Main(string[] args) 2 { 3 Student st = new Student("笨男孩",22,Sex.男); 4 5 Console.WriteLine("============方法一============================================"); 6 //方法一 7 8 Console.WriteLine("方法一对象转Json字符串"); 9 string jsonStr = JsonNewtonsoft.ToJSON(st); 10 Console.WriteLine(jsonStr); 11 Console.WriteLine("方法一Json字符串转对象"); 12 Student stobj = (Student)JsonNewtonsoft.FromJSON<Student>(jsonStr); 13 Console.WriteLine("姓名:{0} 年龄:{1} 性别:{2}",stobj.Name,stobj.Age,stobj.Sex); 14 15 16 Console.WriteLine("============方法二============================================"); 17 //方法二 18 Console.WriteLine("方法二对象转Json字符串"); 19 string jsonStr2 = JsonDataContractJsonSerializer.ToJSON(st); 20 Console.WriteLine(jsonStr2); 21 Console.WriteLine("方法二Json字符串转对象"); 22 Student stobj2 = (Student)JsonDataContractJsonSerializer.FromJSON(jsonStr2, st); 23 Console.WriteLine("姓名:{0} 年龄:{1} 性别:{2}", stobj2.Name, stobj2.Age, stobj2.Sex); 24 25 26 Console.WriteLine("============方法三============================================"); 27 //方法二 28 Console.WriteLine("方法三对象转Json字符串"); 29 string jsonStr3 = JsonJavaScriptSerializer.ToJSON(st); 30 Console.WriteLine(jsonStr3); 31 Console.WriteLine("方法三Json字符串转对象"); 32 Student stobj3 = (Student)JsonJavaScriptSerializer.FromJSON<Student>(jsonStr3); 33 Console.WriteLine("姓名:{0} 年龄:{1} 性别:{2}", stobj3.Name, stobj3.Age, stobj3.Sex); 34 35 Console.ReadKey(); 36 }</pre> <div><a href="javascript:void(0);" onclick="copyCnblogsCode(this)" title="复制代码"><img src="//common.cnblogs.com/images/copycode.gif" alt="复制代码"></a></div></div> <h3>程序运行结果：</h3> <img src="https://images2018.cnblogs.com/blog/1070330/201803/1070330-20180323105742368-1922534797.png" alt=""> 运行结果： <img src="https://images2018.cnblogs.com/blog/1070330/201803/1070330-20180323105607212-438852582.png" alt=""> <h2><a href="https://files.cnblogs.com/files/JiYF/ObjectJsonTest.rar" target="_blank"> 程序工程源文件下载</a></h2> <h2>功能对比：</h2>  <img src="https://images2018.cnblogs.com/blog/1070330/201803/1070330-20180323105422606-1993277357.png" alt=""> <h2>性能对比：</h2> <img src="https://images2018.cnblogs.com/blog/1070330/201803/1070330-20180323105448804-65071066.png" alt=""> <h2>综上所述，一般采用Json.NET方法一比较好！</h2> 参考： <a href="%20https://msdn.microsoft.com/zh-cn/library/system.web.script.serialization.javascriptserializer(v=vs.110).aspx" target="_blank">JavaScriptSerializer</a> 类介绍 https://msdn.microsoft.com/zh-cn/library/system.web.script.serialization.javascriptserializer(v=vs.110).aspx <a href="%20https://msdn.microsoft.com/zh-cn/library/system.runtime.serialization.json.datacontractjsonserializer(v=vs.110).aspx" target="_blank">DataContractJsonSerializer</a>类介绍 https://msdn.microsoft.com/zh-cn/library/system.runtime.serialization.json.datacontractjsonserializer(v=vs.110).aspx https://blog.csdn.net/testcs_dn/article/details/78150046?locationNum=6&fps=1  </div>

C#中对象与JSON字符串互相转换的三种方式

JSON(JavaScriptObject Notation, JS 对象标记) 是一种轻量级的数据交换格式。

关于内存对象和JSON字符串的相互转换，在实际项目中应比较广泛，经过一番搜索，找到如下三种方法来解决此问题

分别是使用Newtonsoft.Json.dll、DataContractJsonSerializer、JavaScriptSerializer。

方法一：Newtonsoft.Json.dll

Newtonsoft.Json.dll在.net2.0之后的版本可以支持我的版本.net framework4.0

添加Newtonsoft.json的引用

对象与json字符串转换类设计

    class JsonNewtonsoft
    {
        /// <summary>
        /// 把对象转换为JSON字符串
        /// </summary>
        /// <param name="o">对象</param>
        /// <returns>JSON字符串</returns>
        public static string ToJSON(this object o)
        {
            if (o == null)
            {
                return null;
            }
            return JsonConvert.SerializeObject(o);
        }
        /// <summary>
        /// 把Json文本转为实体
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="input"></param>
        /// <returns></returns>
        public static T FromJSON<T>(this string input)
        {
            try
            {
                return JsonConvert.DeserializeObject<T>(input);
            }
            catch (Exception ex)
            {
                return default(T);
            }
        }
    }

方法二：DataContractJsonSerializer

使用这种需要引用System.Runtime.Serialization.dll

类设计

    class JsonDataContractJsonSerializer
    {
        /// <summary>
        /// 内存对象转换为json字符串
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static string ObjectToJson(object obj)
        {
           DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType());
           MemoryStream stream = new MemoryStream();
           serializer.WriteObject(stream, obj);
           byte[] dataBytes = new byte[stream.Length];
           stream.Position = 0;
           stream.Read(dataBytes, 0, (int)stream.Length);
           return Encoding.UTF8.GetString(dataBytes);
        }
       /// <summary>
       /// Json字符串转内存对象
       /// </summary>
       /// <param name="jsonString"></param>
       /// <param name="obj"></param>
       /// <returns></returns>
        public static object JsonToObject(string jsonString, object obj)
        {
           DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType());
           MemoryStream mStream = new MemoryStream(Encoding.UTF8.GetBytes(jsonString));
           return serializer.ReadObject(mStream);
        }
    }

方法三：JavaScriptSerializer

需要引用：System.Web.Extensions.dll

类设计

    public static class JsonJavaScriptSerializer
    {
        /// <summary>
        /// 内存对象转换为json字符串
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static string ToJSON(object obj)
        {
            StringBuilder sb = new StringBuilder();
            JavaScriptSerializer json = new JavaScriptSerializer();
            json.Serialize(obj, sb);
            return sb.ToString();
        }
        /// <summary>
        /// Json字符串转内存对象
        /// </summary>
        /// <param name="jsonString"></param>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static T FromJSON<T>(string jsonString)
        {
            JavaScriptSerializer json = new JavaScriptSerializer();
            return json.Deserialize<T>(jsonString);
        }

    }

程序测试：

新建一个测试对象类Student.cs

    public enum Sex
    {
        男=0,
        女=1
    }
    [Serializable()]
    class Student
    {
        private string _name;

        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

        private int _age;

        public int Age
        {
            get { return _age; }
            set { _age = value; }
        }

        private Sex _sex = Sex.男;

        public Sex Sex
        {
            get { return _sex; }
            set { _sex = value; }
        }
        public Student()
        { }
        public Student(string name,int age,Sex sex)
        {
            this._name = name;
            this._age = age;
            this._sex = sex;
        }
    }

测试程序

        static void Main(string[] args)
        {
            Student st = new Student("笨男孩",22,Sex.男);

            Console.WriteLine("============方法一============================================");
            //方法一

            Console.WriteLine("方法一对象转Json字符串");
            string jsonStr = JsonNewtonsoft.ToJSON(st);
            Console.WriteLine(jsonStr);
            Console.WriteLine("方法一Json字符串转对象");
            Student stobj = (Student)JsonNewtonsoft.FromJSON<Student>(jsonStr);
            Console.WriteLine("姓名:{0} 年龄:{1} 性别:{2}",stobj.Name,stobj.Age,stobj.Sex);


            Console.WriteLine("============方法二============================================");
            //方法二
            Console.WriteLine("方法二对象转Json字符串");
            string jsonStr2 = JsonDataContractJsonSerializer.ToJSON(st);
            Console.WriteLine(jsonStr2);
            Console.WriteLine("方法二Json字符串转对象");
            Student stobj2 = (Student)JsonDataContractJsonSerializer.FromJSON(jsonStr2, st);
            Console.WriteLine("姓名:{0} 年龄:{1} 性别:{2}", stobj2.Name, stobj2.Age, stobj2.Sex);


            Console.WriteLine("============方法三============================================");
            //方法二
            Console.WriteLine("方法三对象转Json字符串");
            string jsonStr3 = JsonJavaScriptSerializer.ToJSON(st);
            Console.WriteLine(jsonStr3);
            Console.WriteLine("方法三Json字符串转对象");
            Student stobj3 = (Student)JsonJavaScriptSerializer.FromJSON<Student>(jsonStr3);
            Console.WriteLine("姓名:{0} 年龄:{1} 性别:{2}", stobj3.Name, stobj3.Age, stobj3.Sex);

            Console.ReadKey();
        }

程序运行结果：

运行结果：

性能对比：

综上所述，一般采用Json.NET方法一比较好！

参考：

JavaScriptSerializer类介绍：https://msdn.microsoft.com/zh-cn/library/system.web.script.serialization.javascriptserializer(v=vs.110).aspx

DataContractJsonSerializer类介绍：https://msdn.microsoft.com/zh-cn/library/system.runtime.serialization.json.datacontractjsonserializer(v=vs.110).aspx

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对的支持。如果你想了解更多相关内容请查看下面相关链接

您可能感兴趣的文章:

C#实现JSON和对象之间互相转换功能示例
C#编程实现对象与JSON串互相转换实例分析
C#实现json格式转换成对象并更换key的方法
C#中的DataSet、string、DataTable、对象转换成Json的实现代码

jackson java对象和json对象的互相转换

概述

Jackson框架是基于Java平台的一套数据处理工具，被称为“最好的Java Json解析器”。
Jackson框架包含了3个核心库：streaming,databind,annotations.Jackson还包含了其它数据处理类库，此外不作说明。
Jackson版本： 1.x (目前版本从1.1~1.9)与2.x。1.x与2.x从包的命名上可以看出来，1.x的类库中，包命名以：org.codehaus.jackson.xxx开头，而2.x类库中包命令：com.fastxml.jackson.xxx开头

Jackson Home Page：https://github.com/FasterXML/jackson
Jackson Wiki：http://wiki.fasterxml.com/JacksonHome
Jackson doc: https://github.com/FasterXML/jackson-docs
Jackson Download Page：http://wiki.fasterxml.com/JacksonDownload

准备工作

本文所有程序都基于JDK1.7,依赖jackon的三个核心类库：
jackson-core-2.5.3.jar
jackson-annotations-2.5.3.jar
jackson-databind-2.5.3.jar

Jackson处理Json

Jackson提供了三种可选的Json处理方法：流式API(Streaming API) 、树模型(Tree Model)、数据绑定(Data Binding)。从使用角度来看，比较一下这三种处理Json的方式的特性：

Streaming API：是效率最高的处理方式(开销低、读写速度快，但程序编写复杂度高)
Tree Model：是最灵活的处理方式
Data Binding：是最常用的处理方式

下面我们通过例子程序分别使用DataBinding,TreeModel,Streaming的方式来创建和解析Json字符串

1.DataBinding处理Json

Jackson支持Java对象与Json之间的相互转化。java对象序列化为json字符串，json字符串也可以反序列化为相同的java对象。

(1)java对象转化成json:

Province.java

[java] view plain copy

package com.jackson.json.databinding;
public class Province {
public String name;
public int population;
public String[] city;
}

Country.java

[java] view plain copy

package com.jackson.json.databinding;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class Country {
// 注意：被序列化的bean的private属性字段需要创建getter方法或者属性字段应该为public
private String country_id;
private Date birthDate;
private List<String> nation = new ArrayList<String>();
private String[] lakes;
private List<Province> provinces = new ArrayList<Province>();
private Map<String, Integer> traffic = new HashMap<String, Integer>();
public Country() {
// TODO Auto-generated constructor stub
}
public Country(String countryId) {
this.country_id = countryId;
}
public String getCountry_id() {
return country_id;
}
public void setCountry_id(String country_id) {
this.country_id = country_id;
}
public Date getBirthDate() {
return birthDate;
}
public void setBirthDate(Date birthDate) {
this.birthDate = birthDate;
}
public List<String> getNation() {
return nation;
}
public void setNation(List<String> nation) {
this.nation = nation;
}
public String[] getLakes() {
return lakes;
}
public void setLakes(String[] lakes) {
this.lakes = lakes;
}
public Integer get(String key) {
return traffic.get(key);
}
public Map<String, Integer> getTraffic() {
return traffic;
}
public void setTraffic(Map<String, Integer> traffic) {
this.traffic = traffic;
}
public void addTraffic(String key, Integer value) {
traffic.put(key, value);
}
public List<Province> getProvinces() {
return provinces;
}
public void setProvinces(List<Province> provinces) {
this.provinces = provinces;
}
@Override
public String toString() {
return "Country [country_id=" + country_id + ", birthDate=" + birthDate
+ ", nation=" + nation + ", lakes=" + Arrays.toString(lakes)
+ ", province=" + provinces + ", traffic=" + traffic + "]";
}
}

JavaBeanSerializeToJson.java

[java] view plain copy

package com.jackson.json.databinding;
import java.io.File;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
public class JavaBeanSerializeToJson {
public static void convert() throws Exception {
// 使用ObjectMapper来转化对象为Json
ObjectMapper mapper = new ObjectMapper();
// 添加功能，让时间格式更具有可读性
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
mapper.setDateFormat(dateFormat);
Country country = new Country("China");
country.setBirthDate(dateFormat.parse("1949-10-01"));
country.setLakes(new String[] { "Qinghai Lake", "Poyang Lake",
"Dongting Lake", "Taihu Lake" });
List<String> nation = new ArrayList<String>();
nation.add("Han");
nation.add("Meng");
nation.add("Hui");
nation.add("WeiWuEr");
nation.add("Zang");
country.setNation(nation);
Province province = new Province();
province.name = "Shanxi";
province.population = 37751200;
Province province2 = new Province();
province2.name = "ZheJiang";
province2.population = 55080000;
List<Province> provinces = new ArrayList<Province>();
provinces.add(province);
provinces.add(province2);
country.setProvinces(provinces);
country.addTraffic("Train(KM)", 112000);
country.addTraffic("HighWay(KM)", 4240000);
// 为了使JSON视觉上的可读性，增加一行如下代码，注意，在生产中不需要这样，因为这样会增大Json的内容
mapper.configure(SerializationFeature.INDENT_OUTPUT, true);
// 配置mapper忽略空属性
mapper.setSerializationInclusion(Include.NON_EMPTY);
// 默认情况，Jackson使用Java属性字段名称作为 Json的属性名称,也可以使用Jackson annotations(注解)改变Json属性名称
mapper.writeValue(new File("country.json"), country);
}
public static void main(String[] args) throws Exception {
convert();
}
}

程序运行后生成country.json，内容如下：

[html] view plain copy

{
"country_id" : "China",
"birthDate" : "1949-10-01",
"nation" : [ "Han", "Meng", "Hui", "WeiWuEr", "Zang" ],
"lakes" : [ "Qinghai Lake", "Poyang Lake", "Dongting Lake", "Taihu Lake" ],
"provinces" : [ {
"name" : "Shanxi",
"population" : 37751200
}, {
"name" : "ZheJiang",
"population" : 55080000
} ],
"traffic" : {
"HighWay(KM)" : 4240000,
"Train(KM)" : 112000
}
}

(2)Json字符串反序列化为java对象：

[java] view plain copy

package com.jackson.json.databinding;
import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Iterator;
import java.util.List;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
/**
* 将Json字符串反序列化为Java对象
*/
public class JsonDeserializeToJava {
public static void main(String[] args) throws Exception {
//ObjectMapper类用序列化与反序列化映射器
ObjectMapper mapper = new ObjectMapper();
File json = new File("country.json");
//当反序列化json时，未知属性会引起的反序列化被打断，这里我们禁用未知属性打断反序列化功能，
//因为，例如json里有10个属性，而我们的bean中只定义了2个属性，其它8个属性将被忽略
mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
//从json映射到java对象，得到country对象后就可以遍历查找,下面遍历部分内容，能说明问题就可以了
Country country = mapper.readValue(json, Country.class);
System.out.println("country_id:"+country.getCountry_id());
//设置时间格式，便于阅读
SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd");
String birthDate = dateformat.format(country.getBirthDate());
System.out.println("birthDate:"+birthDate);
List<Province> provinces = country.getProvinces();
for (Province province : provinces) {
System.out.println("province:"+province.name + "\n" + "population:"+province.population);
}
}
}

程序运行结果：

[html] view plain copy

country_id:China
birthDate:1949-10-01
province:Shanxi
population:37751200
province:ZheJiang
population:55080000

2.Tree Model处理Json

(1)tree model生成json:

[java] view plain copy

package com.jackson.json.treemodel;
import java.io.File;
import java.io.FileWriter;
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.JsonNodeFactory;
import com.fasterxml.jackson.databind.node.ObjectNode;
public class SerializationExampleTreeModel {
public static void main(String[] args) throws Exception {
//创建一个节点工厂,为我们提供所有节点
JsonNodeFactory factory = new JsonNodeFactory(false);
//创建一个json factory来写tree modle为json
JsonFactory jsonFactory = new JsonFactory();
//创建一个json生成器
JsonGenerator generator = jsonFactory.createGenerator(new FileWriter(new File("country2.json")));
//注意，默认情况下对象映射器不会指定根节点，下面设根节点为country
ObjectMapper mapper = new ObjectMapper();
ObjectNode country = factory.objectNode();
country.put("country_id", "China");
country.put("birthDate", "1949-10-01");
//在Java中，List和Array转化为json后对应的格式符号都是"obj:[]"
ArrayNode nation = factory.arrayNode();
nation.add("Han").add("Meng").add("Hui").add("WeiWuEr").add("Zang");
country.set("nation", nation);
ArrayNode lakes = factory.arrayNode();
lakes.add("QingHai Lake").add("Poyang Lake").add("Dongting Lake").add("Taihu Lake");
country.set("lakes", lakes);
ArrayNode provinces = factory.arrayNode();
ObjectNode province = factory.objectNode();
ObjectNode province2 = factory.objectNode();
province.put("name","Shanxi");
province.put("population", 37751200);
province2.put("name","ZheJiang");
province2.put("population", 55080000);
provinces.add(province).add(province2);
country.set("provinces", provinces);
ObjectNode traffic = factory.objectNode();
traffic.put("HighWay(KM)", 4240000);
traffic.put("Train(KM)", 112000);
country.set("traffic", traffic);
mapper.configure(SerializationFeature.INDENT_OUTPUT, true);
mapper.writeTree(generator, country);
}
}

程序运行生成country2.json,内容如下：

[html] view plain copy

{"country_id":"China","birthDate":"1949-10-01","nation":["Han","Meng","Hui","WeiWuEr","Zang"],"lakes":["QingHai Lake","Poyang Lake","Dongting Lake","Taihu Lake"],"provinces":[{"name":"Shanxi","population":37751200},{"name":"ZheJiang","population":55080000}],"traffic":{"HighWay(KM)":4240000,"Train(KM)":112000}}

(2) json字符串反序列化为tree mode

DeserializationExampleTreeModel1.java,请注意观察程序中不同的JsonNode的类型变化

[java] view plain copy

package com.jackson.json.treemodel;
import java.io.File;
import java.util.Iterator;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
public class DeserializationExampleTreeModel1 {
public static void main(String[] args) throws Exception {
ObjectMapper mapper = new ObjectMapper();
// Jackson提供一个树节点被称为"JsonNode",ObjectMapper提供方法来读json作为树的JsonNode根节点
JsonNode node = mapper.readTree(new File("country2.json"));
// 看看根节点的类型
System.out.println("node JsonNodeType:"+node.getNodeType());
// 是不是一个容器
System.out.println("node is container Node ? "+node.isContainerNode());
// 得到所有node节点的子节点名称
System.out.println("---------得到所有node节点的子节点名称-------------------------");
Iterator<String> fieldNames = node.fieldNames();
while (fieldNames.hasNext()) {
String fieldName = fieldNames.next();
System.out.print(fieldName+" ");
}
System.out.println("\n-----------------------------------------------------");
// as.Text的作用是有值返回值，无值返回空字符串
JsonNode country_id = node.get("country_id");
System.out.println("country_id:"+country_id.asText() + " JsonNodeType:"+country_id.getNodeType());
JsonNode birthDate = node.get("birthDate");
System.out.println("birthDate:"+birthDate.asText()+" JsonNodeType:"+birthDate.getNodeType());
JsonNode nation = node.get("nation");
System.out.println("nation:"+ nation+ " JsonNodeType:"+nation.getNodeType());
JsonNode lakes = node.get("lakes");
System.out.println("lakes:"+lakes+" JsonNodeType:"+lakes.getNodeType());
JsonNode provinces = node.get("provinces");
System.out.println("provinces JsonNodeType:"+provinces.getNodeType());
boolean flag = true;
for (JsonNode provinceElements : provinces) {
//为了避免provinceElements多次打印，用flag控制打印，能体现provinceElements的JsonNodeType就可以了
if(flag){
System.out.println("provinceElements JsonNodeType:"+provinceElements.getNodeType());
System.out.println("provinceElements is container node? "+provinceElements.isContainerNode());
flag = false;
}
Iterator<String> provinceElementFields = provinceElements.fieldNames();
while (provinceElementFields.hasNext()) {
String fieldName = (String) provinceElementFields.next();
String province;
if ("population".equals(fieldName)) {
province = fieldName + ":" + provinceElements.get(fieldName).asInt();
}else{
province = fieldName + ":" + provinceElements.get(fieldName).asText();
}
System.out.println(province);
}
}
}
}

程序运行后打印结果如下：

[html] view plain copy

node JsonNodeType:OBJECT
node is container Node ? true
---------得到所有node节点的子节点名称-------------------------
country_id birthDate nation lakes provinces traffic
-----------------------------------------------------
country_id:China JsonNodeType:STRING
birthDate:1949-10-01 JsonNodeType:STRING
nation:["Han","Meng","Hui","WeiWuEr","Zang"] JsonNodeType:ARRAY
lakes:["QingHai Lake","Poyang Lake","Dongting Lake","Taihu Lake"] JsonNodeType:ARRAY
provinces JsonNodeType:ARRAY
provinceElements JsonNodeType:OBJECT
provinceElements is container node? true
name:Shanxi
population:37751200
name:ZheJiang
population:55080000

在来看一下DeserializationExampleTreeModel2.java,本例中使用JsonNode.path的方法，path方法类似于DeserializationExampleTreeModel1.java中使用的get方法，

但当node不存在时,get方法返回null,而path返回MISSING类型的JsonNode

[java] view plain copy

package com.jackson.json.treemodel;
import java.io.File;
import java.io.IOException;
import java.util.Iterator;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
public class DeserializationExampleTreeModle2 {
public static void main(String[] args) throws JsonProcessingException, IOException{
ObjectMapper mapper = new ObjectMapper();
JsonNode node = mapper.readTree(new File("country2.json"));
//path方法获取JsonNode时，当对象不存在时，返回MISSING类型的JsonNode
JsonNode missingNode = node.path("test");
if(missingNode.isMissingNode()){
System.out.println("JsonNodeType : " + missingNode.getNodeType());
}
System.out.println("country_id:"+node.path("country_id").asText());
JsonNode provinces = node.path("provinces");
for (JsonNode provinceElements : provinces) {
Iterator<String> provincesFields = provinceElements.fieldNames();
while (provincesFields.hasNext()) {
String fieldName = (String) provincesFields.next();
String province;
if("name".equals(fieldName)){
province = fieldName +":"+ provinceElements.path(fieldName).asText();
}else{
province = fieldName +":"+ provinceElements.path(fieldName).asInt();
}
System.out.println(province);
}
}
}
}

程序运行打印结果：

[html] view plain copy

JsonNodeType : MISSING
country_id:China
name:Shanxi
population:37751200
name:ZheJiang
population:55080000

3.Stream处理Json

(1)stream生成json

[java] view plain copy

package com.jackson.json.streaming;
import java.io.File;
import java.io.FileWriter;
import java.io.Exception;
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonGenerator;
public class StreamGeneratorJson {
public static void main(String[] args) throws Exception {
JsonFactory factory = new JsonFactory();
//从JsonFactory创建一个JsonGenerator生成器的实例
JsonGenerator generator = factory.createGenerator(new FileWriter(new File("country3.json")));
generator.writeStartObject();
generator.writeFieldName("country_id");
generator.writeString("China");
generator.writeFieldName("provinces");
generator.writeStartArray();
generator.writeStartObject();
generator.writeStringField("name", "Shanxi");
generator.writeNumberField("population", 33750000);
generator.writeEndObject();
generator.writeEndArray();
generator.writeEndObject();
generator.close();
}
}

程序运行后生成country3.json文件内容：

[html] view plain copy

{"country_id":"China","provinces":[{"name":"Shanxi","population":33750000}]}

(2)stream解析json:
现在adgcountry3.json，我们用Streaming API的方式来解析上面的Json,并查找json中population的值。

[java] view plain copy

package com.jackson.json.streaming;
import java.io.File;
import java.io.IOException;
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
/*Jackson API提供了token对每个Json对象，例如，Json开始符号“{”是token指向的第一个解析的对象，
key:value键值对是另一个单独的对象。这个API很强大，但也需要编写大量代码。不推荐使用，平时更多的是使用DataBinding和TreeModel来处理json
*/
public class StreamParserJson {
public static void main(String[] args) throws JsonParseException,
IOException {
JsonFactory factory = new JsonFactory();
// 从JsonFactory创建JsonParser解析器的实例
JsonParser parser = factory.createParser(new File("country3.json"));
while (!parser.isClosed()) {
// 得到一个token,第一次遍历时，token指向json文件中第一个符号"{"
JsonToken token = parser.nextToken();
if (token == null) {
break;
}
// 我们只查找 country3.json中的"population"字段的值，能体现解析的流程就可以了
// 当key是provinces时，我们进入provinces,查找population
if (JsonToken.FIELD_NAME.equals(token)
&& "provinces".equals(parser.getCurrentName())) {
token = parser.nextToken();
if (!JsonToken.START_ARRAY.equals(token)) {
break;
}
// 此时，token指向的应该是"{"
token = parser.nextToken();
if (!JsonToken.START_OBJECT.equals(token)) {
break;
}
while (true) {
token = parser.nextToken();
if (token == null) {
break;
}
if (JsonToken.FIELD_NAME.equals(token)
&& "population".equals(parser.getCurrentName())) {
token = parser.nextToken();
System.out.println(parser.getCurrentName() + " : "
+ parser.getIntValue());
}
}
}
}
}
}

程序运行后，在控制台打印结果如下：

[html] view plain copy

population : 33750000

总结

上面的例子中，分别用3种方式处理Json，我的体会大致如下：

Stream API方式是开销最低、效率最高，但编写代码复杂度也最高，在生成Json时，需要逐步编写符号和字段拼接json,在解析Json时，需要根据token指向也查找json值，生成和解析json都不是很方便，代码可读性也很低。

Databinding处理Json是最常用的json处理方式，生成json时，创建相关的java对象，并根据json内容结构把java对象组装起来，最后调用writeValue方法即可生成json,

解析时，就更简单了，直接把json映射到相关的java对象，然后就可以遍历java对象来获取值了。

TreeModel处理Json，是以树型结构来生成和解析json，生成json时，根据json内容结构，我们创建不同类型的节点对象，组装这些节点生成json。解析json时，它不需要绑定json到java bean，根据json结构，使用path或get方法轻松查找内容。

今天关于C#将集合和Json格式互相转换的几种方式和c# 集合转字符串的分享就到这里，希望大家有所收获，若想了解更多关于ABAP和XML数据格式互相转换的两种方式、C# 对象与JSON字符串互相转换的三种方式、C#中对象与JSON字符串互相转换的三种方式、jackson java对象和json对象的互相转换等相关知识，可以在本站进行查询。

本文标签：