json的简单使用

1.1、什么是 JSON

JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式。 易于人阅读和编写。同时也易于机器解析和生成。 它基于 JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999 的一个子集。 JSON 采用完全独立于语言的文本格式，但是也使用了类似于 C 语言家族的习惯（包括 C, C++, C#, Java,JavaScript, Perl, Python 等）。 这些特性使 JSON 成为理想的数据交换语言。

1.2、JSON 对象定义和基本使用

在标准的 json 格式中，json 对象由在括号括起来，对象中的属性也就是 json 的 key 是一个字符串，所以一定要使用
双引号引起来。每组 key 之间使用逗号进行分隔。

1.2.1json的定义

			var json={
				"key":12,
				"key2":"abc",
				"key3":true,
				"key4":[11,"arr",false],
				"key5":{
					"key5_1":551,
					"key5_2":"key5_2_value"
				},
				"key6":[{
					"key6_1_1":6611,
					"key6_1_2":"key6_2"
				},{
					"key6_2_1":66123,
					"key6_2_1":"key6_2_1"
				},{
					"key6_3_1":661121,
					"key6_3_2":"key6_3_2"
				}]
			};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

1.2.2、JSON 对象的访问

json 对象，顾名思义，就知道它是一个对象。里面的 key 就是对象的属性。我们要访问一个对象的属性，只需要使
用【对象名.属性名】的方式访问即可。

<script type="text/javascript">
// json 的定义
var jsons = {
"key1":"abc", // 字符串类型
"key2":1234, // Number
"key3":[1234,"21341","53"], // 数组
"key4":{ // json 类型
"key4_1" : 12,
"key4_2" : "kkk"
},
"key5":[{ // json 数组
"key5_1_1" : 12,
"key5_1_2" : "abc"
},{
"key5_2_1" : 41,
"key5_2_2" : "bbj"
}]
};
// 访问 json 的属性
“玩转”Java 系列
alert(jsons.key1); // "abc"
// 访问 json 的数组属性
alert(jsons.key3[1]); // "21341"
// 访问 json 的 json 属性
alert(jsons.key4.key4_1);//12
// 访问 json 的 json 数组
alert(jsons.key5[0].key5_1_2);//"abc"
script>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

1.3、JSON 中两个常用的方法。

JSON 对象和字符串对象的互转

JSON.stringify( json ); 此方法可以把一个 json 对象转换成为 json 字符串

JSON.parse( jsonString ); 此方法可以把一个 json 字符串转换成为 json 对象

			// json对象转字符串
			var jsonString=JSON.stringify(jsonObj);
			alert(jsonString);

			// json字符串转json对象
			var jsonparse=JSON.parse(jsonString);
			alert(typeof (jsonparse.key1));
1
2
3
4
5
6
7

1.4、JSON 在 java 中的使用(重点)

我们要使用 json 和 java 中使用，我们需要使用到一个第三方的包。它就是 gson.jar。

Gson 是 Google 提供的用来在 Java 对象和 JSON 数据之间进行映射的 Java 类库。可以将一个 JSON 字符串
转成一个 Java 对象，或者反过来。
json 在 java 中的操作。常见的有三种情况。
1、java 对象和 json 的转换
2、java 对象 list 集合和 json 的转换
3、map 对象和 json 的转换

创建一个person类，供后面使用

package com.atguigu.pojo;

public class Person {
    private Integer id;
    private String name;
    public Person() {
    }
    
    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }
    
    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;
    }
    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

要把复杂的 json 字符串转换成为 java 对象。需要继承 TypeToken 类。
并把返回的类型当成 TypeToken 的泛型注入
对于LIst集合和Json对象的转换需要的操作

package com.atguigu.pojo;

import com.google.gson.reflect.TypeToken;

import java.util.ArrayList;

public class PersonLIstType extends TypeToken<ArrayList<Person>> {
}

1
2
3
4
5
6
7
8
9

对于LIst集合和Json对象的转换需要的操作

package com.atguigu.pojo;

import com.google.gson.reflect.TypeToken;

import java.util.HashMap;

public class PersonMapType extends TypeToken<HashMap<Integer,Person>> {
}

1
2
3
4
5
6
7
8
9

package com.atguigu.json;

import com.atguigu.pojo.Person;
import com.atguigu.pojo.PersonLIstType;
import com.atguigu.pojo.PersonMapType;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import org.junit.Test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class JsonTest {
//    javaBean与json的互转
    @Test
    public void test1(){
        Person person=new Person(1,"开学延期");
//        创建Gson对象实例
        Gson gson=new Gson();
//        toJson可以把Java对象转化为json字符串
        String toJson = gson.toJson(person);
        System.out.println(toJson);
//        fromJson把字符串转化为Java对象
        Person fromJson = gson.fromJson(toJson, Person.class);
        System.out.println(fromJson);
    }
//    List与json的互转
    @Test
    public void test2(){
        List<Person> list=new ArrayList<>();

        list.add(new Person(1,"开学"));
        list.add(new Person(2,"延期"));

        Gson gson=new Gson();
        String toJson = gson.toJson(list);
//        System.out.println(toJson);
        List<Person> person = gson.fromJson(toJson,new PersonLIstType().getType());
//        System.out.println(person);
        System.out.println(person.get(0));
    }
//    map与json的互转
    @Test
    public void test3(){
        Map<Integer,Person> personMap=new HashMap<>();

        personMap.put(1,new Person(1,"开学"));
        personMap.put(2,new Person(2,"延期"));
        personMap.put(3,new Person(3,"了"));

        Gson gson=new Gson();
        String s = gson.toJson(personMap);
        System.out.println(s);
//        HashMap personHashMap= gson.fromJson(s, new PersonMapType().getType());
//由于每次这样使用都需要我们创建一个类，所以我们可以使用匿名内部类的方式
        HashMap<Integer,Person> personHashMap= gson.fromJson(s,new TypeToken<HashMap<Integer,Person>>(){}.getType());
        System.out.println(personHashMap);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62