《JSON数据结构》

版本

作者

参与者

完成日期

备注

Data_JSON_V01_1.0

严立钻

2018.08.24

#第一篇：快速入门篇

##A.1、前言

##A.2、JSON简介

##A.3、JSON基本结构

{

“name” : ”立钻哥哥”,

“age” : “18”

};

{

“Persons” : [

{

“name” : “立钻哥哥”,

“age” : “28”

},

{

“name” : “小珏妹妹”,

“age” : “18”

}

]

}

{

“name” : “立钻哥哥”,

“age” : 28,

“height” : 1.90,

“school” : {

“name” : “清华大学”,

“address” : “北京海淀”

},

“photos” : [

{

“icon” : “helloworld.png”,

“time” : “2017-08-08”

},

{

“icon” : “nice.png”,

“time” : “2017-09-09”

},

{

“icon” : “lovezuanzuan.png”,

“time” : “2018-08-08”

}

]

}

##A.4、JSON开发

//创建一个JSON对象，相当于一个大括号

JsonObject jsonTransform = new JsonObject();

//创建一个JSON值对象，存储一个Value

JsonValue jsonPosition = “10, 20, 30”;

//JSON对象，也就是大括号，添加一个key:value

jsonTransform.Add(“position”, jsonPosition);

//打印结果

Debug.Log(jsonTransfrom.ToString());

显示：{“position”:”10,20,30”}

//定义一个值数组，用来存储，中括号中的一个个的值

JsonValue[] rotationXYZ = new JsonValue[]{20, 30, 40};

//将这个数组中的一个个的值放到JsonArray数组对象中

JsonArray jsonRotation = new JsonArray(rotationXYZ);

//一个JsonArray对象，也可以是一个Value，所以可以用jsonTransform来Add

jsonTransform.Add(“rotation”, jsonRotation);

//打印结果

Debug.Log(jsonTransform);

结果显示：

{“position”:”10,20,30”, “rotation”:[20,30,40]}

//jsonArray中添加对象（大括号中包含的所有内容）

JsonObject x = new JsonObject();

x.Add(“x”, 10);

JsonObject y = new JsonObject();

y.Add(“y”, 20);

JsonObject z = new JsonObject();

z.Add(“z”, 30);

//实例一个jsonValues数组（所有类型都可以转换成jsonValue）

JsonValue[] scaleXYZ = new JsonValue[]{ x, y, z };

//将实例好的数组，添加到jsonArray对象中，形成一个jsonArray对象（作用：给这个整体，添加一个中括号[]）

JsonArray jsonScale = new JsonArray(scaleXYZ);

//将这个整体，放入到jsonTransform中

jsonTransform.Add(“scale”, jsonScale);

//打印结果

Debug.Log(jsonTransform);

结果显示：

{“position”:”10,20,30”, “rotation”:[20,30,40], “scale”:[{“x”:10}, {“y”:20}, {“z”:30}]}

public class MyPerson{

    public string Name{  get;  set;  }

    public int Age{  get;  set;  }

}    //立钻哥哥：public class MyPerson{}

    MyPerson myPer = new MyPerson(){

    Name = “立钻哥哥”,

    Age = “28”

};

++++结果：{“Name”:”立钻哥哥”, “Age”:28}

MyPerson yanlz = new MyPerson();

yanlz.Name = “立钻哥哥”;

yanlz.Age = 28;

string jsonYanlz = JsonMapper.ToJson(yanlz);

Debug.Log(jsonYanlz);

string json = @”{

“mxy”:{

“name”:”Albert”,

“artist”:”Sing Song”,

“year”:1999,

“tracks”:[“Bistu”, “CSS”, “立钻哥哥”]

}

}

”;

JsonData data = JsonMapper.ToObject(json);

Debug.Log(“立钻哥哥： mxy’s name:” + data[“mxy”][“name”]);

string artist = (string)data[“mxy”][“artist”];

int year = (int)data[“mxy”][“year”];

Debug.Log(“立钻哥哥：Recorded by” + artist + “ in ” + year);

Debug.Log(“立钻哥哥：First track: ” + data[“mxy”][“tracks”][0]);

JSON

XML

语法格式

数组与键值对（字典/对象）

用节点表示的树形结构

数据量

轻量级

文件庞大

可读性

较弱

较强

解析难度

相对容易

相对麻烦

执行效率

较高

较低

++立钻哥哥：同一份数据，既可以用JSON来表示，也可以用XML来表示；JSON的体积小于XML，所以服务器返回给移动端的数据格式以JSON居多，而对于客户端两者都可以；

##A.5、JSON简单示例

###A.5.1、编写代码，完成一个JsonObject储存英雄信息？

using System.Json;

using System.IO;

using UnityEditor;

public class CreateJsonScript : MonoBehaviour{

//Use this for initialization

    void Start(){

CreateJson();

}

    void CreateJson(){

JsonObject hero = new JsonObject();    //创建json对象

//添加键值对

hero.Add(“英雄名称”, “立钻哥哥”);

hero.Add(“生命值”, 800.00);

hero.Add(“攻击伤害”, 66.88);

//添加技能组

JsonObject bSkill = new JsonObject();

bSkill.Add(“被动技能”, “出血”);

JsonObject qSkill = new JsonObject();

qSkill.Add(“Q技能”, “大杀四方”);

qSkill.Add(“冷却时间”, new JsonArray(9,8,7,6,5));  //将jsonArray当做value

qSkill.Add(“消耗”, 30);

JsonObject wSkill = new JsonObject();

wSkill.Add(“W技能”, “致残打击”);

wSkill.Add(“冷却时间”, new JsonArray(9,8,7,6,5));

wSkill.Add(“消耗”, 30);

JsonObject eSkill = new JsonObject();

eSkill.Add(“E技能”, “无情铁手”);

eSkill.Add(“冷却时间”, new JsonArray(24, 21, 18, 15, 12));

hero.Add(“技能” , new JsonArray(bSkill, qSkill, wSkill, eSkill));

//保存json对象

string path = Application.dataPath + “/YanlzDemo/myLoL.txt”;

Debug.Log(path);

StreamWriter writer = new StreamWriter(path);

hero.Save(writer);

writer.AutoFlush = true;

writer.Close();

AssetDatabase.Refresh();

}    //立钻哥哥：void CreateJson(){}

}    //立钻哥哥：public class CreateJsonScript:MonoBehaviour{}

###A.5.2、使用LitJson格式保存一个角色的transform？

{

“position” : {“x”:10, “y”:10, “z”:3.2},

“rotation” : {“x”:20.0, “y”:10.0, “z”:3},

“scale” : {“x”:1, “y”:3, “z”:3},

};

using System.IO;

using LitJson;

public class MyParseJson : MonoBehaviour{

//Use this for initialization

    void Start(){

ReadJson();

}

    void ReadJson(){

//根据文件路径读取json格式字符串

string path = Application.dataPath + “/YanlzDemo/MyTransform.txt”;

StreamReader reader = new StreamReader(path);

string jsonStr = reader.ReadToEnd();

reader.Close();

//将json格式的字符串转成jsondata

JsonData data = JsonMapper.ToObject(jsonStr);

//获取内容

string x = data[“position”][“x”].ToString();

string y = data[“position”][“y”].ToString();

string z = data[“position”][“z”].ToString();

Debug.Log(x);

Debug.Log(y);

Debug.Log(z);

}    //立钻哥哥：void ReadJson(){}

}    //立钻哥哥：public class MyParseJson:MonoBehaviour{}

###A.5.3、解析服务器返回的JSON数据？

[

{“id”:10, “Name”:”立钻哥哥”, “age”:28},

{“id”:20, “Name”:”小珏妹妹”, “age”:20},

{“id”:30, “Name”:”小飞弟弟”, “age”:18}

]

//解析出我们可以识别的对象

string path = “Assets/Resources/MyTextFile.txt”;

string textOne = File.ReadAllText(path);

JsonData data1 = JsonMapper.ToObject(textOne);

for(int i = 0;  i < data1.Count;  i++){

    JsonData nameValue = data1[i][“Name”];

NameText.text = nameValue.ToString();

    JsonData IDValue = data1[i][“id”];

IDText.text = IDValue.ToString();

    JsonData AgeValue = data1[i][“age”];

AgeText.text = AgeValue.ToString();

Debug.Log(nameValue);

Debug.Log(“立钻哥哥：名字是：” + NameText + “ID: ” + IDText);

}

MyPerson[] myPer = new MyPerson[]{

p1 = new MyPerson(),

p2 = new MyPerson(),

p3 = new MyPerson()

};

string path = “Assets/Resources/MyTextFile.txt”;

string textOne = File.ReadAllText(path);

JsonData data = JsonMapper.ToObject(textOne);

Debug.Log(myPer.Length);

for(int i = 0;  i < data.Count;  i++){

    JsonData idValue = data[i][“id”];

myPer[i].id = int.Parse(idValue.ToString());

    JsonData ageValue = data[i][“age”];

myPer[i].age = int.Parse(ageValue.ToString());

    JsonData nameValue = data[i][“Name”];

myPer[i].name = nameValue.ToString();

Debug.Log(“立钻哥哥：name:” + nameValue.ToString());

}

##A.6、Unity中JSON应用

###A.6.1、json.txt

{“PosX”:”0”, “PosY”:”0”, “PosZ”:”0”}

###A.6.2、CubeItem.cs

using UnityEngine;

using System.Collections;

public class CubeItem{

    public string PosX{  get;  set;  }

    public string PosY{  get;  set;  }

    public string PosZ{  get;  set;  }

    public CubeItem(){

}

    public CubeItem(string x, string y, string z){

this.PosX = x;

this.PosY = y;

this.PosZ = z;

}

    public override string ToString(){

return string.Format(“立钻哥哥：X:” + PosX + “  Y:” + PosY + “  Z:” + PosZ);

}

}    //立钻哥哥：public class CubeItem{}

###A.6.3、CubeManager.cs

using UnityEngine;

using System.Collections;

using LitJson;

using System.Collections.Generic;

using System;

using System.IO;

public class CubeManager : MonoBehaviour{

    private Transform m_Transform;    //父物体的Transform

    private Transform[] allCubeTran;    //所有子物体的Transform

    private List<CubeItem> cubeList;    //Cube对象

    private List<CubeItem> posList;    //json数据里的对象

    private string jsonPath = null;

    private GameObject cubePrefab;

    void Start(){

m_Transform = GetComponent<Transform>();

cubeList = new List<CubeItem>();

posList = new List<CubeItem>();

jsonPath = Application.dataPath + “/Resources/json.txt”;

cubePrefab = Resources.Load<GameObject>(“Prefabs/Cube”);

}

    void Update(){

if(Input.GetKeyDown(KeyCode.A)){

ObjectToJson();

}

        if(Input.GetKeyDown(KeyCode.B)){

JsonToObject();

}

}

//对象转Json字符串数据

    void ObjectToJson(){

cubeList.Clear();

allCubeTran = m_Transform.GetComponentsInChildren<Transform>();

for(int i = 1;  i < allCubeTran.Length;  i++){

//print(allCubeTran[i].position);

Vector3 pos = allCubeTran[i].position;

CubeItem item = new CubeItem(

Math.Round(pos.x, 2).ToString(),

Math.Round(pos.y, 2).ToString(),

Math.Round(pos.z, 2).ToString()

);

cubeList.Add(item);

}

        string str = JsonMapper.ToJson(cubeList);

print(str);

//IO持久化json数据，把它以文本的形式存储在本地中

        StreamWriter sw = new StreamWriter(jsonPath);

sw.Write(str);

sw.Close();

}    //立钻哥哥：void ObjectToJson(){}

//Json数据转对象

    void JsonToObject(){

//读取Json数据信息

TextAsset textAsset = Resources.Load<TextAsset>(“json”);

print(textAsset.text);

//把数据转换为对象

JsonData data = JsonMapper.ToObject(textAsset.text);

for(int i = 0;  i < data.Count;  i++){

//print(data[i].ToJson());

//指定对象接收数据

CubeItem item = JsonMapper.ToObject<CubeItem>(data[i].ToJson());

posList.Add(item);

}

        for(int i = 0;  i < posList.Count;  i++){

//print(posList[i].ToString());

Vector3 pos = new Vector3(

                float.Parse(posList[i].PosX),

                float.Parse(posList[i].PosY),

                float.Parse(posList[i].PosZ)

);

            GameObject.Instantiate(cubePrefab, pos, Quaternion.identity, m_Transform);

}

}    //立钻哥哥：void JsonToObject(){}

}    //立钻哥哥：public class CubeManager:MonoBehaviour{}

###A.6.4、CubeTest.cs

using UnityEngine;

using System.Collections;

using LitJson;

public class CubeTest : MonoBehaviour{

    private Transform m_Transform;

    void Start(){

m_Transform = GetComponent<Transform>();

Vector3 pos = m_Transform.position;

//string str = JsonMapper.ToJson(pos);

//print(str);

//LitJson不支持float

//CubeItem item = new CubeItem(pos.x, pos.y, pos.z);

//string str = JsonMapper.ToJson(item);

//print(str);

}

}    //立钻哥哥：public class CubeTest:MonoBehaviour{}

###A.6.5、JsonDemo.cs

using UnityEngine;

using System.Collections;

using LitJson;

using System.Collections.Generic;

public class JsonDemo : MonoBehaviour{

    private List<Person> persons;    //Persons对象

    private List<Person> personsOne;    //Json数据里的对象

    void Start(){

ChangeSingleObject();    //立钻哥哥：单个对象转换

ChangeMultiObjects();    //立钻哥哥：多个对象转换

}    //立钻哥哥：void Start(){}

//单个对象转换

    void ChangeSingleObject(){

//单个对象转Json

Person p1 = new Person(“aaa”, 18, “bbb”);

string str = JsonMapper.ToJson(p1);

print(str);

//Json转当个对象

Person p2 = JsonMapper.ToObject<Person>(str);

print(p2.ToString());

}

//多个对象转换

    void ChangeMultiObjects(){

//多个对象转Json

persons = new List<Person>();

Person p1 = new Person(“aaa”, 18, “bbb”);

Person p2 = new Person(“bbb”, 20, “ddd”);

persons.Add(p1);

persons.Add(p2);

string str = JsonMapper.ToJson(persons);

//print(str);

//Json转多个对象

personOne = new List<Person>();

JsonData data = JsonMapper.ToObject(str);

for(int i = 0;  i < data.Count;  i++){

//print(data.ToJson());

Person item = JsonMapper.ToObject<Person>(data[i].ToJson());

personOne.Add(item);

}

        for(int i = 0;  i < personOne.Count;  i++){

print(personsOne[i].ToString());

}

}    //立钻哥哥：void ChangeMultiObjects(){}

}    //立钻哥哥：public class JsonDemo:MonoBehaviour{}

###A.6.6、Person.cs

using UnityEngine;

using System.Collections;

public class Person{

    public string Name{  get;  set;  }

    public int Age{  get;  set;  }

    public string Address{  get;  set;  }

    public Person(){

}

    public Person(string name, int age, string address){

this.Name = name;

this.Age = age;

this.Address = address;

}

    public override string ToString(){

return string.Format(“名字” + Name + ”年龄” + Age + “住址” + Address);

}

}    //立钻哥哥：public class Person{}

##A.7、立钻哥哥带您JSON实战

###A.7.1、Json在Unity中的使用

###A.7.2、Unity读写Json数据：LitJSON

using LitJson;

using System;

public class Person{

    public string Name{  get;  set;  }

    public int Age{  get;  set;  }

    public DateTime Birthday{  get;  set;  }

}    //立钻哥哥：public class Person{}

public class JsonSample{

    public static void Main(){

PersonToJson();

JsonToPerson();

}

    public static void PersonToJson(){

Person bill = new Person();

bill.Name = “立钻哥哥”;

bill.Age = 28;

bill.Birthday = new DateTime(1990, 08, 08);

string json_bill = JsonMapper.ToJson(bill);

Console.WriteLine(json_bill);

}

    public static void JsonToPerson(){

string json = @”{

“”Name””:””立钻哥哥””,

“”Age”” : 57,

“”Birthday”” : “08/08/1990 00:00:00”

}”;

        Person yanlz = JsonMapper.ToObject<Person>(json);

Console.WriteLine(“立钻哥哥：age:{0}”, yanlz.Age);

}

}    //立钻哥哥：public class JsonSample{}

++输出：

{“Name”:”立钻哥哥”, “Age”:28, “Birthday”:”08/08/1990 00:00:00”}

立钻哥哥：age: 28

++立钻哥哥：ToObject方法有一个泛型参数，来指定返回的某种特定的数据类型：

--JsonMapper.ToObject<T>();

--Person yanlz = JsonMapper.ToObject<Person>(json);

using LitJson;

using System;

public class JsonSample{

    public static void Main(){

string json = @”{

““album””:{

“”name”” : “立钻哥哥的专辑”,

“”artist”” : “立钻哥哥”,

“”year”” : 2018,

“”tracks”” : [

“”爱在路上””,

“为爱痴狂”,

“世上只有妈妈好”

]

}

}”;

        LoadAlbumData(json);

}    //立钻哥哥：public static void Main(){}

    public static void LoadAlbumData(string json_text){

Console.WriteLine(“立钻哥哥：JSON string: {0}”, json_text);

JsonData data = JsonMapper.ToObject(json_text);

string artist = (string)data[“album”][“artist”];

int year = (int)data[“album”][“year”];

Console.WriteLine(“立钻哥哥：Album’s name:{0} ”, data[“album”][“name”]);

Console.WriteLine(“立钻哥哥：Recorded by {0} in {1}”, artist, year);

Console.WriteLine(“立钻哥哥：First track: {0}”, data[“album”][“tracks”][0]);

}    //立钻哥哥：public static void LoadAlbumData(){}

}    //立钻哥哥：public class JsonSample{}

++输出：

立钻哥哥：JSON string:

{

“album” : {

“name” : “立钻哥哥的专辑”,

“artist” : “立钻哥哥”,

“year” : 2018,

“tracks” : [

“爱在路上”,

“为爱痴狂”,

“世上只有妈妈”

]

}

}

Album’s name: 立钻哥哥的专辑

Recorded by 立钻哥哥 in 2018

First track: 爱在路上

++立钻哥哥：当不存在特定的JSON数据类时，它将返回一个JsonData实例；

++++JSONData是一种通用型可以保存任何数据类型，包括：List和Dictionary；

using LitJson;

using System;

public class DataReader{

    public static void Main(){

string sample = @”{

“”name”” : “立钻哥哥”,

“”age”” : 28,

“”awake”” : true,

“”n”” : 2018.0828,

“”note”” : [“”life””, “”is””, “”but””, “”a””, “”dream””]

}”;

        PrintJson(sample);

}

}    //立钻哥哥：public class DataReader{}

public static void PrintJson(){

    JsonReader reader = new JsonReader(json);

Console.WriteLine(“{0, 14} {1,10} {2,16}”, “Token”, “Value”, “Type”);

Console.WriteLine(new string(‘-’, 42));

    while(reader.Read()){

string type = reader.Value != null ? reader.Value.GetType().ToString() : “”;

Console.WriteLine(“{0,14} {1, 10} {2, 16}”, reader.Token, reader.Value, type);

}

}    //立钻哥哥：public static void PrintJson(){}

++输出

Token         Value      Type

ObjectStart

PropertyName  name      System.String

String         立钻哥哥   System.String

PropertyName  age        System.String

Int            28         System.Int32

PropertyName  awake    System.String

Boolean       True      System.Boolean

PropertyName  n        System.String

Double        2018.0828  System.Double

PropertyName  note      System.String

ArrayStart

String         life       System.String

String         is        System.String

String         but       System.String

String         a         System.String

String         dream    System.String

ArrayEnd

ObjectEnd

++立钻哥哥：一些人喜欢使用stream的方式处理JSON数据，提供的接口是JsonReader和JsonWriter；

++++JsonMapper实际上是建立在以上两个类基础上的，可以把[JsonReader]和[JsonWriter]当成是[LitJson]的底层接口；

###A.7.3、Unity中生成JSON以及对应的解析方法

using LitJson;    //引用Json命名空间

using UnityEngine;

public class LitJsonDemo : MonoBehaviour{

//Use this for initialization

    void Start(){

JsonDataToJson();

JsonMapperToJson();

JsonWriterToJson();

}    //立钻哥哥：void Start(){}

//JSON的生成

    void JsonDataToJson(){

JsonData data = new JsonData();

data[“name”] = “立钻哥哥”;

//生成嵌套结构的json

data[“info”] = new JsonData();

data[“info”][“age”] = 28;

data[“info”][“sex”] = “男”;

string js1 = data.ToJson();

Debug.Log(js1);

//解析JSON

JsonData jsdata1 = JsonMapper.ToObject(js1);

Debug.Log(“立钻哥哥：解析json1 ” + jsdata1[“name”] + “ ” + jsdata1[“info”][“age”]);

//遍历JsonData的key（由于JsonData实现了IDictionary接口，可用foreach）

IDictionary dic = jsdata1 as IDictionary;

foreach(string item in dic.Keys){

Debug.Log(item);

}

}

//使用jsonMapper生成Json

//此方法使用的前提是有一个玩家类

    void JsonMapperToJson(){

Player play1 = new Player();

play1.Name = “小珏妹妹”;

play1.Age = 18;

play1.Sex = “女”;

string js2 = JsonMapper.ToJson(play1);

Debug.Log(js2);

//解析Json

Player play2 = JsonMapper.ToObject<Player>(js2);

Debug.Log(“立钻哥哥：解析js2 ” + play2.name + “ ” + play2.age);

}

//使用JsonWritter生成Json

    void JsonWriterToJson(){

JsonWriter js3 = new JsonWriter();

//对象类型的json

js3.WriteObjectStart();

js3.WritePropertyName(“name”);

js3.Write(“小飞弟弟”);

js3.WritePropertyName(“age”);

js3.Write(“15”);

js3.WritePropertyName(“sex”);

js3.Write(“男”);

js3.WriteObjectEnd();

Debug.Log(js3.ToString());

JsonWriter js4 = new JsonWriter();

//生成数组型json

js4.WriteArrayStart();

js4.Write(“成龙大哥”);

js4.Write(“45”);

js4.Write(“男”);

js4.WriteArrayEnd();

Debug.Log(js4.ToString());

//========================================

//需要注意的是由开始就要写结束

JsonWriter js5 = new JsonWriter();

//生成数组含对象

js5.WriteArrayStart();

//第一个对象

js5.WriteObjectStart();

js5.WritePropertyName(“name”);

js5.Write(“小飞弟弟”);

js5.WritePropertyName(“age”);

js5.Write(“15”);

js5.WriteProperyName(“sex”);

js5.Write(“男”);

js5.WriteObjectEnd;

//第二个对象

js5.WriteObjectStart();

js5.WritePropertyName(“name”);

js5.Write(“成龙大哥”);

js5.WritePropertyName(“AGE”);

js5.Write(“45”);

js5.WritePropertyName(“SEX”);

js5.Write(“男”);

js5.WriteArrayEnd();

Debug.Log(js5.ToString());

//解析JSON（以js3为例）

string json3 = js3.ToString();

JsonData jsdata3 = JsonMapper.ToObject(json3);

Debug.Log(“立钻哥哥：解析js3 ” + jsdata3[“name”] + jsdata3[“age”] + jsdata3[“sex”]);

}    //立钻哥哥：void JsonWriterToJson(){}

//玩家类

    public class Player{

public string Name{  get;   set;  }

public int Age{  get;  set;  }

public string Sex{  get;  set;  }

}    //立钻哥哥：public class Player{}

}    //立钻哥哥：public class LitJsonDemo:MonoBehaviour{}

++输出：

{“name”:”立钻哥哥”, “info”:{“age”:28, “sex”:”男”}}    //js1（JsonDataToJson）

{“name”:”小珏妹妹”, “age”:18, ”sex”:”女”}    //js2（JsonMapperToJson）

{“name”:”小飞弟弟”, “age”:”15”, “sex”:”男”}    //js3（JsonWriterToJson）

{“成龙大哥”, “45”, “男”}    //js4（JsonWriterToJson）

[{“name”:”小飞弟弟”, “age”:”15”, “sex”:”男”}, {“name”:”成龙大哥”, “AGE”:”45”, “SEX”:”男”}]  //js5

解析json1 立钻哥哥 28

name

info

解析js2 小珏妹妹 18

解析js3 小飞弟弟 15 男

###A.7.4、Unity中使用Json解析字符串

private static void MyJson(){

//创建一个字典

    Dictionary<string, int>  dic = new Dictionary<string, int>{

{“yanlz01”, 001},

{“yanlz02”, 002},

{“yanlz03”, 003}

};

//将字典转换成Json字符串

    string json = JsonConvert.SerializeObject(dic, Newtonsoft.Json.Formatting.Indented);

}    //立钻哥哥：private static void MyJson(){}

//创建一个新的字典保存结果

Dictionary<string, int> newDic = JsonConvert.DeserializeObject<Dictionary<string, int>>(json);

List<List<string>> list = new List<List<string>>{

    new List<string>{“yanlz01”, “yanlz02”, “yanlz03”},

    new List<string>{“1001”, “1002”, “1003”}

};

string json = JsonConvert.SerializeObject(list, Newtonsoft.Json.Formatting.Indented);

List<List<string>> newList = JsonConvert.DeserializeObject<List<List<string>>>(json);

foreach(List<string> child0 in newList){

    for(int i = 0;  i < child0.Count;  i++){

Debug.Log(child0[i]);

}

}

string jsonArray = “[[” + “\”” + “yanlz01” + “\”” + “,1,2,1],[” + “\”” + “yanlz02” + “\”” + “,1,2,3” + “]]”;

JArray jar = (JArray)JsonConvert.DeserializeObject(jsonArray);

for(int i = 0;  i < jar.Count;  i++){

ja = (JArray)JsonConvert.DeserializeObject(jar[i].ToString());

    if(ja != null){

string name = ja[0].ToString();

string str1 = ja[1].ToString();

}

}

###A.7.5、Unity常用的几种解析Json方式

++Json：

string json = @”{

“”d”” : “”d””,

“”album”” : {

“”name”” : “”立钻哥哥的专辑””,

“”artist”” : “”立钻哥哥””,

“”year”” : 2018,

“”tracks”” : [

“”为爱痴狂””,

“”摇滚王子””,

“"世上只有妈妈好"”

],

“”tt”” : “”tt””,

“”tracksOb”” : [

{“”trackOb”” : “”11””},

{“”trackOb”” : “”22””}

],

“”bb”” : “”bb””

}

}”;

++对应Json的mode有3个：MyOO，MyTestModel，MyTestModel2

public class MyOO{

    public string d;

    pubic MyTestModel album;

    pubic string bb;

}    //立钻哥哥：public class MyOO{}

public class MyTestModel{

    public string name;

    public string artist;

    public int year;

    public string[] tracks;

    public MyTestModel2[] tracksOb;

}    //立钻哥哥：public class MyTestModel{}

public class MyTestModel2{

public string trackOb;

}    //立钻哥哥：public class MyTestModel2{}

++解析方法

public static T GetJsonData<T>(string text) where T : class{

    T data = JsonMapper.ToObject<T>(table.ToJson());

    return data;

}

++调用：

MyOO myOO = GetJsonData<MyOO>(json);

++运行：

++++立钻哥哥：运行解析会报错，因为Json字符串，包含了很多对象和字段，而数据MyOO，MyTestModel，MyTestModel2对象，并没有全部和Json字符串字段一一对应，LitJson解析很严谨；

++解析方法

public static T GetJsonData<T>(string text) where T : class{

    T data = JsonConvert.DeserializeObject<T>(text);

    return data;

}

++调用：

MyOO myOO = GetJsonData<MyOO>(json);

++运行：

++++立钻哥哥：运行不会报错，完全解析；

++解析方法：

public static T GetJsonData<T>(string text) where T : class{

    T data = JsonUtility.FromJson<T>(text);

    return data;

}

++调用：

MyOO myOO = GetJsonData<MyOO>(json);

++运行：

++++立钻哥哥：有的对象解析不出，会报错；

###A.7.6、Unity的Json解析（读取Json文件）

namespace UnityEngine{

public static class JsonUtility{

//Static Methods

    public static T FromJson<T>(string json);

[ThreadAndSerializationSafe]

[MethodImpl(MethodImplOptions.InternalCall)]

    public static extern object FromJson(string json, Type type);

[ThreadAndSerializationSafe]

[MethodImpl(MethodImplOptions.InternalCall)]

    public static extern void FromJsonOverwrite(string json, object objectToOverwrite);

    public static string ToJson(object obj);

[ThreadAndSerializationSafe]

[MethodImpl(MethodImplOptions.InternalCall)]

    public static extern string ToJson(object obj, bool prettyPrint);

}    //立钻哥哥：public static class JsonUtility

}    //立钻哥哥：namespace UnityEngine{}

++1、首先准备一个Json文件

{“gameName”:”立钻哥哥Json测试”, “version”:”1.0”, “isStereo”:”false”, “isUseHardWare”:”true”, “statusList”:[{“name”:”test”, “id”:”yanlz2018”}]}

++2、创建对象类（用来存放从Json文本中读取的内容）

using UnityEngine;

using System;

using System.Collections;

[Serializable]

public class MyGameStatus{

    public string gameName;

    public string version;

    public bool isStereo;

    public bool isUseHardWare;

    public MyReferences[] statusList;

}    //立钻哥哥：public class GameStatus{}

[Serializable]

public class MyReferences{

    public string name;

    public int id;

}    //立钻哥哥：public class MyReferences{}

++3、需要一个读取类

using UnityEngine;

using System.Collections;

using System.IO;

using System.Runtime.Serialization.Formatters.Binary;

public class MyLoadJson : MonoBehaviour{

    public static MyGameStatus LoadJsonFromFile(){

BinaryFormatter bf = new BinaryFormatter();

string jsonPath = Application.dataPath + “/Resources/MyJonsTest.json”;

if(!File.Exists(jsonPath)){

return null;

}

        StreamReader sr = new StreamReader(jsonPath);

        if(sr == null){

return null;

}

        string json = sr.ReadToEnd();

        if(json.Length > 0){

return JsonUtility.FromJson<MyGameStatus>(json);

}

        return null;

}    //立钻哥哥：public static MyGameStatus LoadJsonFromFile(){}

}    //立钻哥哥：public class MyLoadJson:MonoBehaviour{}

++==========================================

++利用Deserialize()：解析Json为二进制格式，然后在反序列化为字符串，可能是编码格式问题，不能正确反序列化，可能报错！？（所以使用了以上的StreamReader来处理）

FileStream file = File.Open(jsonPath);

if(file.Length == 0){

return null;

}

string json = (string)bf.Deserialize(file);

file.Close();

++4、调用（在Update中，使用L键来加载Json文件）

using UnityEngine;

using System.Collections;

using System;

using System.Runtime.Serialization.Formatters.Binary;

using System.IO;

public class MyReadJson : MonoBehaviour{

    void Update(){

if(Input.GetKeyDown(KeyCode.S)){

//DoMySave();

}

        if(Input.GetKeyDown(KeyCode.L)){

MyGameStatus status = MyLoadJson.LoadJsonFromFile();

Debug.Log(status);

}

}

}    //立钻哥哥：public class MyReadJson:MonoBehaviour{}

++5、运行测试

++++立钻哥哥：在场景中，建立一个空对象，然后把MyReadJson拖拽到对象上，运行，按下L键，就可以使用断点查看，也可以看Log输出；

public void DoMySave(){

    string json = JsonUtility.ToJson(gameStatus);

    string savePath = Application.dataPath + “/Resources/MyJsonTest.json”;

    File.WriteAllText(savePath, json, Encoding.UTF8);

Debug.Log(“立钻哥哥：save:===>” + savePath);

}

using UnityEngine;

using System.Collections;

using System.IO;

using System.Runtime.Serialization.Formatters.Binary;

using System.Text;

public class MyWriteJson : MonoBehaviour{

    public MyGameStatus gameStatus;

    public GameObject[] objects;

    void Start(){

gameStatus = new MyGameStatus();

gameStatus.statusList = new MyReferences[objects.Length];

gameStatus.gameName = “立钻哥哥Json测试”;

for(int i = 0;  i < objects.Length;  i++){

gameStatus.statusList[i] = new MyReferences();

gameStatus.statusList[i].id = i;

gameStatus.statusList[i].name = object[i].name;

}

}

    public void DoMySave(){

        string json = JsonUtility.ToJson(gameStatus);

        string savePath = Application.dataPath + “/Resources/MyJsonTest.json”;

        File.WriteAllText(savePath, json, Encoding.UTF8);

Debug.Log(“立钻哥哥：save:===>” + savePath);

}

}    //立钻哥哥：public class WriteJson:MonoBehaviour{}

++调试运行：

++++立钻哥哥：在MyWriteJson的属性面板上，给objects拖拽几个cube，作为保存到Json文件中的内容的一部分，然后运行Unity，按下“S”保存键，就会在当前工程下的/Asset/Resources/下生成一个MyJsonTest.json的文件；

++++Json内容：{“gameName”:”立钻哥哥Json测试”, “version”:””, “isStereo”:true, “isUserHardWare”:false, “statusList”:[{“name”:”Cube01”, “id”:0}, {“name”:”Cube02”, “id”:1}]}

###A.7.7、Unity解析Json字符串

{“name”:”立钻哥哥”, “friend”:”小珏妹妹”, “sex”:”male”}

JsonData myData = new JsonData();

myData[“name”] = “立钻哥哥”;

myData[“friend”] = “小珏妹妹”;

myData[“sex”] = “male”;

string myJson = myData.ToJson();

print(myJson);

{“name”:”立钻哥哥”, “like”:”study”, “sister”:{“name”:”亦菲妹妹”, “like”:”run”}}

void Start(){

    JsonData myData = new JsonData();

myData[“name”] = “立钻哥哥”;

myData[“like”] = “study”;

myData[“sister”] = new JsonData();

myData[“sister”][“name”] = “亦菲妹妹”;

myData[“sister”][“like”] = “run”;

    string myJson = myData.ToJson();

print(myJson);

}

void Start(){

    JsonData myData = JsonMapper.ToObject(“{‘name’:’立钻哥哥’, ‘friend’:’小珏妹妹’, ‘sex’:’male’}”);

print(myData[“name”]);

}

++输出：立钻哥哥

JsonData myData = JsonMapper.ToObject(“{‘name’=’立钻哥哥’, ‘like’:’study’, ‘sister’:{‘name’:’亦菲妹妹’, ‘like’:’run’}}”);

print(myData[“sister”][“name”] + “ : ” + myData[“sister”][“like”]);

++输出：亦菲妹妹 : run

void Start(){

    MyPlayer myPlayer = new MyPlayer();

myPlayer.name = “立钻哥哥”;

myPlayer.age = 28;

    string myJson = JsonMapper.ToJson(myPlayer);

print(myJson);

}

++打印结果：{“name”:”立钻哥哥”, “age”:28}

class MyPlayer{

    public string name;

    public int age;

    public MyPlayer(string name, int age){

this.name = name;

this.age = age

}

}    //立钻哥哥：class MyPlayer{}

void Start(){

    MyPlayer myPlayer01 = new MyPlayer(“立钻哥哥”, 28);

    MyPlayer myPlayer02 = new MyPlayer(“小珏妹妹”, 18);

    MyPlayer myPlayer03 = new MyPlayer(“亦菲妹妹”, 20);

    MyPlayer[] playerArr = { myPlayer01, myPlayer02, myPlayer03};

print(JsonMapper.ToJson(playerArr));

}

++打印结果：[{“name”:”立钻哥哥”, “age”:28}, {“name”:”小珏妹妹”, “age”:25}, {“name”:”亦菲妹妹”, “age”:20}]

void Start(){

    string myJson = “{‘name’:’立钻哥哥’, ‘age’:’28’, ‘friend’:[‘小珏妹妹’, ‘18’, ‘run’]}”;

    JsonData myData = JsonMapper.ToObject(myJson);

print(myData[“name”]);    //输出：立钻哥哥

print(myData[“age”]);    //输出：28

print(myData[“friend”][0]);    //输出：小珏妹妹

print(myData[“friend”][1]);    //输出：18

print(myData[“friend”][2]);    //输出：run

}

public class MyPlayer{

    public string name;

    public string age;

    public MyFriend friend;

}    //立钻哥哥：public class MyPlayer{}

public class MyFriend{

    public string name;

    public stirng age;

    public string[] friends;

}    //立钻哥哥：public class MyFriend{}

void Start(){

    MyFriend myFriend = new MyFriend();

myFriend.name = “小珏妹妹”;

myFriend.age = “18”;

myFriend.friends = new string[3];

myFriend.friends[0] = “Jue01”;

myFriend.friends[1] = “Jue02”;

myFriend.friends[2] = “Jue03”;

    MyPlayer myPlayer = new MyPlayer();

myPlayer.name = “立钻哥哥”;

myPlayer.age = “28”;

myPlayer.friend = myFriend;

print(JsonMapper.ToJson(myPlayer));

}

++输出：{“name”:”立钻哥哥”, “age”:”28”, “friend”:{“name”:”小珏妹妹”, “age”:”18”, “friends”:[“Jue01”, “Jue02”, “Jue03”]}}

public class MyPlayer{

    public string name;

    public string age;

    public MyFriend friend;

}    //立钻哥哥：public class MyPlayer{}

public class MyFriend{

    public string name;

    public stirng age;

    public string[] friends;

}    //立钻哥哥：public class MyFriend{}

void Start(){

    string myJson = “{‘name’:’立钻哥哥’, ‘age’:’28’, ‘friend’:{‘name’:’小珏妹妹’, ‘age’:’18’, ‘friends’:[‘Jue01’, ‘Jue02’, ‘Jue03’]}}”;

    MyPlayer myPlayer = JsonMapper.ToObject<MyPlayer>(myJson);

print(myPlayer.friend.friends[0]);    //输出：Jue01

}

void Start(){

    JsonData myData = new JsonData();

myData[“name”] = “立钻哥哥”;

myData[“age”] = “28”;

myData[“friend”] = new JsonData();

myData[“friend”][“name”] = “小珏妹妹”;

myData[“friend”][“age”] = “18”;

myData[“friend”][“friends”] = new JsonData{“Jue01”, “Jue02”, “Jue03”};

print(myData.ToJson());

}

++输出：{“name”:”立钻哥哥”, “age”:”28”, “friend”:{“name”:”小珏妹妹”, “age”:”18”, “friends”:[“Jue01”, “Jue02”, “Jue03”]}}

#第二篇：中级进阶篇