JSON（初识一）

最新推荐文章于 2024-07-30 20:09:50 发布

㏒灵韵№

最新推荐文章于 2024-07-30 20:09:50 发布

阅读量3.3k

点赞数 10

CC 4.0 BY-SA版权

分类专栏： JavaEE

本文链接：https://blog.youkuaiyun.com/daai5201314/article/details/114480104

JavaEE 专栏收录该内容

6 篇文章

订阅专栏

本文详细介绍了JSON的基本概念、语法以及在数据交换中的应用，包括对象和数组的表示方式。同时，文章深入讲解了如何使用Gson、FastJson和Jackson这三种流行的Java库进行JSON数据与Java对象之间的转换，包括对象转JSON字符串和JSON字符串转对象的实例代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.简介

JSON: JavaScript Object Notation JS对象简谱 , 是一种轻量级的数据交换格式.

1.1概念

概念： JavaScript Object Notation JavaScript对象表示法

      Person p = new Person();
		p.setName("张三");
		p.setAge(23);
		p.setGender("男");
		var p = {"name":"张三","age":23,"gender":"男"};

	* json现在多用于存储和交换文本信息的语法
	* 进行数据的传输
	* JSON 比 XML 更小、更快，更易解析。

1.2对象格式

一本书
书名
简介

Java形式

class Book{
private String name;
private String info;
get/set...
}

Book b = new Book();
b.setName(“金苹果”);
b.setInfo(“种苹果”);

2.js形式

var b = new Object();
b.name = "金苹果";
b.info = "种苹果";

3.XML形式

<book>
<name>金苹果</name>
<info>种苹果</info>
</book>

4.JSON形式

{
"name":"金苹果",
"info":"种苹果"
}

1.3语法

一个对象, 由一个大括号表示. 括号中描述对象的属性 . 通过键值对来描述对象的属性 (可以理解为, 大括号中,包含的是一个个的键值对.) 格式: 键与值之间使用冒号连接, 多个键值对之间使用逗号分隔. 键值对的键应使用引号引住(通常Java解析时, 键不使用引号会报错. 而JS能正确解析.) 键值对的值, 可以是JS中的任意类型的数据

1.3.1基本规则

数据在名称/值对中：json数据是由键值对构成的
* 键用引号(单双都行)引起来，也可以不使用引号

值得取值类型:

数字（整数或浮点数）
字符串（在双引号中）
逻辑值（true 或 false）
数组（在方括号中） {“persons”:[{},{}]}
对象（在花括号中） {“address”:{“province”：“陕西”…}}
null

		* 数据由逗号分隔：多个键值对由逗号分隔
		* 花括号保存对象：使用{}定义json 格式
		* 方括号保存数组：[]

1.3.2获取数据

json对象.键名
json对象[“键名”]
数组对象[索引]
遍历

//1.定义基本格式

              //1.定义基本格式
var person = {"name": "张三", age: 23, 'gender': true};
var ps = [{"name": "张三", "age": 23, "gender": true},
		  {"name": "李四", "age": 24, "gender": true},
		  {"name": "王五", "age": 25, "gender": false}];

//获取person对象中所有的键和值

  //for in 循环
       /* for(var key in person){
     //这样的方式获取不行。因为相当于  person."name"
        //alert(key + ":" + person.key);
          alert(key+":"+person[key]);
		        }*/
		
		    //获取ps中的所有值
		     for (var i = 0; i < ps.length; i++) {
		         var p = ps[i];
		         for(var key in p){
		             alert(key+":"+p[key]);
		            }
		        }

案例：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        //1.定义基本格式
       /* var person={"name":"张三",age:23,'gender':true};
        for(var i in person){
            alert(person[i])
        }*/
        //获取name值
        //var name=person.name;
       /* var name=person["name"];
        alert(name);*/
        //嵌套格式{}-->[]
        var persons1={"persons":[{"name":"张三",age:23,gender:"true"},
                              {"name":"李四",age:23,gender:"true"},
                              {"name":"王五",age:23,gender:"false"}
                              ],
            "personsq":[{"name":"张三",age:23,gender:"true"},
        {"name":"李四",age:23,gender:"true"},
        {"name":"王五",age:23,gender:"false"}
        ]

        };
        for(var i in persons1){//获取键
            var p=persons1[i];//获取值数组
            alert("gg"+p);
            for(var j=0;j<p.length;j++){//遍历数组
                var o=p[j];//获取数组中的对象
                for(var s in o) {//获取数组中的对象的键
                    alert(o[s]);
                }
            }
        }

      /*  //拿李四值
        var name1=persons.persons[1].name;
        alert(name1);*/
        //嵌套格式[]-->{}
        /*var ps=[{"name":"张三",age:23,gender:"true"},
                {"name":"李四",age:23,gender:"true"},
                {"name":"王五",age:23,gender:"false"}];
        //遍历
        for(var i=0;i<ps.length;i++){
            var p=ps[i];
          for(var s in p){
              alert(p[s])
          }
        }*/
        /*//拿王五值
        var name3=ps[2].name;
        alert(name3);*/
    </script>
</head>
<body>

</body>
</html>

2.JSON数据和Java对象的相互转换

可以做什么?

将Java中的对象快速的转换为 JSON格式的字符串.
将JSON格式的字符串, 转换为Java的对象.

JSON解析器： * 常见的解析器：Jsonlib，Gson，fastjson，jackson

下面简单介绍三种实现解析方式

2.1Gson

2.1.1将对象转换为JSON字符串

转换JSON字符串的步骤:

引入Gson相关JAR包
创建 Gson 的核心对象 Gson gson=new Gson();
调用Gson的相关方法进行转换
String json = new Gson().toJSON(要转换的对象);

案例：
(1.创建实体类)

import java.util.Objects;

public class Book {
    private String id;
    private String name;
    private String info;
public Book(){}
    public Book(String id, String name, String info) {
        this.id = id;
        this.name = name;
        this.info = info;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return "Book{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", info='" + info + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Book)) return false;
        Book book = (Book) o;
        return Objects.equals(id, book.id) &&
                Objects.equals(name, book.name) &&
                Objects.equals(info, book.info);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name, info);
    }
}

（2.实现）

import com.alibaba.fastjson.JSON;
import com.google.gson.Gson;
import java.util.List;

public class Demo {
    public static void main(String[] args) {
        //Gson 将对象转换为字符窜 new Gson().toJson(要转换的对象)
        Book book=new Book("1008","金苹果","一个女孩种植了一棵金苹果树");
        Gson gson=new Gson();
        String s = gson.toJson(book);
        System.out.println(s);
        System.out.println("======================");
    }
}

结果如下：

{"id":"1008","name":"金苹果","info":"一个女孩种植了一棵金苹果树"}
======================

2.1.2将JSON字符串转换为对象

将JSON字符串转换为对象:

引入Gson相关JAR包
创建 Gson 的核心对象 Gson gson=new Gson();
调用Gson的相关方法进行转换
对象 = new Gson().fromJson(JSON字符串,对象类型.class);

案例：

import com.alibaba.fastjson.JSON;
import com.google.gson.Gson;
import java.util.List;

public class Demo {
    public static void main(String[] args) {
        // Gson 将Json字符窜 转换为 对象
        Book book1 = gson.fromJson("{\"id\":\"1008\",\"name\":\"金苹果\",\"info\":\"一个女孩种植了一个金苹果树\"}", Book.class);
        System.out.println(book1);
    }
}

测试结果如下：

Book{id='1008', name='金苹果', info='一个女孩种植了一个金苹果树'}

2.2FastJson

2.2.1将对象转换为JSON字符串

转换JSON字符串的步骤:

引入FastJson相关JAR包
在需要转换JSON字符串的位置编写如下代码即可:
String json=JSON.toJSONString(要转换的对象);

案例：
(1.创建实体类)

import java.util.Objects;

public class Book {
    private String id;
    private String name;
    private String info;
public Book(){}
    public Book(String id, String name, String info) {
        this.id = id;
        this.name = name;
        this.info = info;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return "Book{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", info='" + info + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Book)) return false;
        Book book = (Book) o;
        return Objects.equals(id, book.id) &&
                Objects.equals(name, book.name) &&
                Objects.equals(info, book.info);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name, info);
    }
}

（2.实现）

import com.alibaba.fastjson.JSON;
import com.google.gson.Gson;
import java.util.List;

public class Demo {
    public static void main(String[] args) {
      //JSon.toJsonString(要转换的对象)
      Book book=new Book("1008","金苹果","一个女孩种植了一棵金苹果树");
        String s1 = JSON.toJSONString(book);
        System.out.println(s1);
    }
}

结果如下：

{"id":"1008","name":"金苹果","info":"一个女孩种植了一棵金苹果树"}
======================

2.2.2将JSON字符串转换为对象

将JSON字符串转换为对象:

引入FastJson相关JAR包
在需要转换JSON字符串的位置编写如下代码即可:
类型对象名=JSON.parseObject(JSON字符串, 类型.class);
或
List<类型> list=JSON.parseArray(JSON字符串,类型.class);

案例：

import com.alibaba.fastjson.JSON;
import com.google.gson.Gson;
import java.util.List;

public class Demo {
    public static void main(String[] args) {
        //FastJson 将Json字符转换为对象 parseObject()
        Book book2 = JSON.parseObject("{\"id\":\"1008\",\"info\":\"一个女孩种植了一棵金苹果树\",\"name\":\"金苹果\"}", Book.class);
        System.out.println(book2);
        List<String> strings = JSON.parseArray("[\"123\",\"456\",\"789\"]", String.class);
        System.out.println(strings);
    }
}

测试结果如下：

Book{id='1008', name='金苹果', info='一个女孩种植了一棵金苹果树'}
[123, 456, 789]

2.3JackSon

2.3.1 JSON转为Java对象

		1. 导入jackson的相关jar包
		2. 创建Jackson核心对象 ObjectMapper
		3. 调用ObjectMapper的相关方法进行转换
            readValue(json字符串数据,Class)

案例：
(1.实体类)

注解：
1. @JsonIgnore：排除属性。
2. @JsonFormat：属性值得格式化
* @JsonFormat(pattern = “yyyy-MM-dd”)

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonIgnore;

import java.util.Date;
import java.util.Objects;

public class Person {
    private String name;
    private int age;
    private String gender;
    //@JsonIgnore//忽略该属性
    @JsonFormat(pattern="yyyy-MM-dd")
    private Date birthday;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                ", birthday=" + birthday +
                '}';
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person)) return false;
        Person person = (Person) o;
        return getAge() == person.getAge() &&
                Objects.equals(getName(), person.getName()) &&
                Objects.equals(getGender(), person.getGender()) &&
                Objects.equals(getBirthday(), person.getBirthday());
    }

    @Override
    public int hashCode() {
        return Objects.hash(getName(), getAge(), getGender(), getBirthday());
    }
}

 @Test
    public void Test5() throws IOException {
        //1.初始化JSON字符串
        String json="{\"name\":\"张三\",\"age\":23,\"gender\":\"男\"}";
        String s=   "{\"gender\":\"男\",\"name\":\"张三\",\"age\":23}";
        //2.创建ObjectMapper对象
        ObjectMapper mapper=new ObjectMapper();
        //转换为java对象 Person对象
        Person person = mapper.readValue(json,Person.class);
        System.out.println(person);
    }

测试结果如下：

Person{name='张三', age=23, gender='男', birthday=null}

2.3.2Java对象转换JSON

导入jackson的相关jar包
创建Jackson核心对象 ObjectMapper
调用ObjectMapper的相关方法进行转换

转换方法：

writeValue(参数1，obj):
参数1：
File：将obj对象转换为JSON字符串，并保存到指定的文件中
Writer：将obj对象转换为JSON字符串，并将json数据填充到字符输出流中
OutputStream：将obj对象转换为JSON字符串，并将json数据填充到字节输出流中
writeValueAsString(obj):将对象转为json字符串

** writeValue(参数1，obj):案例一：**

    @Test
    public void Test1() throws IOException {
       //1.创建Person对象
       Person p=new Person();
       p.setAge(18);
       p.setGender("男");
       p.setName("张三");
       //2.创建Jackson核心对象 ObjectMapper
        ObjectMapper mapper=new ObjectMapper();
        //3.转换
        //转换方法
        /*mapper.writeValue(参数1,obj);
        参数1:
              File:将obj对象转换为JSON字符串，并保存到指定的文件中
              Writer:将obj对象转换为JSON字符串，并将JSON数据填充到字符输出流中
              OutputStream:将obj对象转换位JSON字符串，并将JSON数据填充到字符输出流中
              writeValueAsString():将对象转换为JSON字符串
        * */

        String json = mapper.writeValueAsString(p);
       // System.out.println(json);//{"name":"张三","age":18,"gender":"男"}
        //将数据写到e://jon.txt文件中
        mapper.writeValue(new File("e://jon.txt"),p);
        //将数据关联到e://jon1.txt文件中
        mapper.writeValue(new FileWriter("E://jons1.txt"),p);
    }

测试结果如下：
在这里插入图片描述
writeValueAsString(obj)案例二：

@Test
    public void Test2() throws JsonProcessingException {
        //1.创建Person对象
        Person p=new Person();
        p.setAge(18);
        p.setGender("男");
        p.setName("张三");
        p.setBirthday(new Date());

        //2.创建Jackson核心对象 ObjectMapper
        ObjectMapper mapper=new ObjectMapper();
        //3.转换
        //转换方法
        /*mapper.writeValue(参数1,obj);
        参数1:
              File:将obj对象转换为JSON字符串，并保存到指定的文件中
              Writer:将obj对象转换为JSON字符串，并将JSON数据填充到字符输出流中
              OutputStream:将obj对象转换位JSON字符串，并将JSON数据填充到字符输出流中
              writeValueAsString():将对象转换为JSON字符串
        * */
        String json = mapper.writeValueAsString(p);
         System.out.println(json);//{"name":"张三","age":18,"gender":"男","birthday":"2020-06-10"}
    }

测试结果如下：

{"name":"张三","age":18,"gender":"男","birthday":"2021-03-07"}

集合转换案例三(List)：

 @Test
    public void Test3() throws JsonProcessingException {
        //1.创建Person对象
        Person p=new Person();
        p.setAge(18);
        p.setGender("男");
        p.setName("张三");
        p.setBirthday(new Date());

        Person p2=new Person();
        p2.setAge(18);
        p2.setGender("男");
        p2.setName("张三");
        p2.setBirthday(new Date());

        Person p3=new Person();
        p3.setAge(18);
        p3.setGender("男");
        p3.setName("张三");
        p3.setBirthday(new Date());

        List<Person>list=new ArrayList<Person>();
        list.add(p);
        list.add(p2);
        list.add(p3);
        //2.创建Jackson核心对象 ObjectMapper
        ObjectMapper mapper=new ObjectMapper();
        //3.转换
        //转换方法
        /*mapper.writeValue(参数1,obj);
        参数1:
              File:将obj对象转换为JSON字符串，并保存到指定的文件中
              Writer:将obj对象转换为JSON字符串，并将JSON数据填充到字符输出流中
              OutputStream:将obj对象转换位JSON字符串，并将JSON数据填充到字符输出流中
              writeValueAsString():将对象转换为JSON字符串
        * */
        String json = mapper.writeValueAsString(list);
        System.out.println(json);
       // [{"name":"张三","age":18,"gender":"男","birthday":"2020-06-10"},
        // {"name":"张三","age":18,"gender":"男","birthday":"2020-06-10"},
        // {"name":"张三","age":18,"gender":"男","birthday":"2020-06-10"}]

    }

测试结果如下：

[{"name":"张三","age":18,"gender":"男","birthday":"2021-03-07"},{"name":"张三","age":18,"gender":"男","birthday":"2021-03-07"},{"name":"张三","age":18,"gender":"男","birthday":"2021-03-07"}]

集合转换案例三(Map)：

 @Test
    public void Test4() throws JsonProcessingException {
        Map<String,Object> map=new HashMap<String,Object>();
        map.put("name","张三");
        map.put("age",23);
        map.put("gender","男");
        ObjectMapper mapper=new ObjectMapper();
        String s = mapper.writeValueAsString(map);
        System.out.println(s);//{"gender":"男","name":"张三","age":23}
    }

测试结果如下：

{"gender":"男","name":"张三","age":23}