03-Java核心类库_XML与JSON

程序员文章站 2022-04-15 18:53:23

七，xml与json1，XML介绍1.1 简介可扩展标记语言（eXtensible Markup Language）。特性:1. xml具有平台无关性（系统无关性，语言无关性）, 是一门独立的标记语言（不依赖任何东西，也可以描述事物）.2. xml具有自我描述性1.2 为什么学习XML？1）网络数据传输.客户端服务器传输数据时，是传输一段数据，但是如何区分数据主体内容？若采用特殊符号分割，那数据内容本身含有该特殊符号怎么办？若采用对象来保存数据，那么......

七，xml与json

1，XML介绍

3）一个XML文档中, 必须有且且仅允许有一个根标记.

4）标记可以嵌套, 但是不允许交叉

5）标记的层级称呼 (子标记, 父标记 , 兄弟标记, 后代标记 ,祖先标记)

七，xml与json

配套工具下载03-Java核心类库_XML与JSON（配套工具）

1，XML介绍

1.1 简介

可扩展标记语言（eXtensible Markup Language）。特性:

1. xml具有平台无关性（系统无关性，语言无关性）, 是一门独立的标记语言（不依赖任何东西，也可以描述事物）.

2. xml具有自我描述性

1.2 为什么学习XML？

1）网络数据传输.

客户端服务器传输数据时，是传输一段数据，但是如何区分数据主体内容？

若采用特殊符号分割，那数据内容本身含有该特殊符号怎么办？

若采用对象来保存数据，那么不同语言之间改如何交流？

2）数据存储

3）配置文件

1.3 XML文件

.XML文件是保存XML数据的一种方式

XML数据也可以以其他的方式存在（如在内存中构建XML数据）。

不要将XML语言狭隘的理解成XML文件。（也可以是Java对象中一个属性）

2，XML语法

注：在记事本中编写XML文档，若里面含有中文字符，直接双击浏览器打开，可能会产生乱码。可以选择将其粘贴到IDEA中，IDEA会对其进行编码检验。

这样做的原因可能是：记事本和IDEA中编码格式不同。

1）XML文档声明

<?xml version="1.0" encoding="UTF-8"?>

2）标记 ( 元素 / 标签 / 节点)

XML文档,由一个个的标记组成.

语法:

   开始标记(开放标记): <标记名称>

   结束标记(闭合标记): </标记名称>

   标记名称: 自定义名称，必须遵循以下命名规则：

       1.名称可以含字母、数字以及其他的字符

       2.名称不能以数字或者标点符号开始

       3.名称不能以字符 “xml”（或者 XML、Xml）开始

       4.名称不能包含空格，不能包含冒号（:）

       5.名称区分大小写标记内容: 开始标记与结束标记之间 ,是标记的内容.

例如 ,我们通过标记, 描述一个人名: <name>李伟杰</name>

3）一个XML文档中, 必须有且且仅允许有一个根标记.

根标记：最外层只能有一个标签

正例:
<names> 
    <name>张三</name> 
    <name>李四</name> 
</names> 
反例
<name>李四</name> 
<name>麻子</name>

4）标记可以嵌套, 但是不允许交叉

正例

<person> 
    <name>李四</name> 
    <age>18</age> 
</person>

反例

<person> 
    <name>李四<age>
    </name> 18</age> 
</person>

5）标记的层级称呼 (子标记, 父标记 , 兄弟标记, 后代标记 ,祖先标记)

<persons> 
    <person> 
        <name>李四</name> 
        <length>180cm</length> 
    </person> 
    <person> 
        <name>李四</name> 
        <length>200cm</length> 
    </person> 
</persons>
name是person的子标记.也是person的后代标记

name是persons的后代标记

name是length的兄弟标记.

person是name的父标记.

persons是name的祖先标记.

6）标记名称允许重复

7）标记除了开始和结束 , 还有属性.

标记中的属性, 在标记开始时描述, 由属性名和属性值组成.

格式:

在开始标记中, 描述属性.

可以包含0-n个属性, 每一个属性是一个键值对!

属性名不允许重复 , 键与值之间使用等号连接, 多个属性之间使用空格分割.

属性值必须被引号引住.

案例：
<persons> 
    <person id="10001" groupid="1"> 
        <name>李四</name> 
        <age>18</age> 
    </person> 
    <person id="10002" groupid="1"> 
        <name>李四</name> 
        <age>20</age> 
    </person> 
</persons>

8）注释

注释不能写在文档文档声明前

注释不能嵌套注释

格式:

注释开始:

语法进阶CDATA （了解）

CDATA

CDATA 是不应该由 XML 解析器解析的文本数据。

像 "<" 和 "&" 字符在 XML 元素中都是非法的。

"<" 会产生错误，因为解析器会把该字符解释为新元素的开始。

"&" 会产生错误，因为解析器会把该字符解释为字符实体的开始

某些文本，比如 JavaScript 代码，包含大量 "<" 或 "&" 字符。为了避免错误，可以将脚本代码定义为 CDATA。

CDATA 部分中的所有内容都会被解析器忽略。

CDATA 部分由 "<![CDATA[" 开始，由 "]]>" 结束：

比如：
<![CDATA[<<<>>>]]>

3，解析XML的方式

3.1 Java解析XML（掌握）

面试题：Java中有几种XML解析方式 ? 分别是什么 ? 有什么样的优缺点 ?

四种.

1. SAX解析

介绍

解析方式是事件驱动机制 !

SAX解析器, 逐行读取XML文件解析 , 每当解析到一个标签的开始/结束/内容/属性时,触发事件.

我们可以编写程序在这些事件发生时, 进行相应的处理.

优点:

分析能够立即开始，而不是等待所有的数据被处理；

逐行加载,节省内存.有助于解析大于系统内存的文档；

有时不必解析整个文档,它可以在某个条件得到满足时停止解析；

缺点:

单向解析，无法定位文档层次，无法同时访问同一文档的不同部分数据(因为逐行解析, 当解析第n行是, 第n-1行已经被释放了, 无法在进行操作了).

无法得知事件发生时元素的层次，只能自己维护节点的父/子关系.

只读解析方式, 无法修改XML文档的内容.

2. DOM解析

介绍

是用与平台和语言无关的方式表示XML文档的官方W3C标准，分析该结构通常需要加载整个文档和内存中建立文档树模型.程序员可以通过操作文档树, 来完成数据的获取修改删除等.

优点:

文档在内存中加载, 允许对数据和结构做出更改.

访问是双向的，可以在任何时候在树中双向解析数据。

缺点:

文档全部加载在内存中 , 消耗资源大. （文档普遍较小，可以忽略不记，所以大部分用DOM解析）

3. JDOM解析

介绍

目的是成为Java特定文档模型，它简化与XML的交互并且比使用DOM实现更快。由于是第一个Java特定模型，JDOM一直得到大力推广和促进。

JDOM文档声明其目的是“使用20%（或更少）的精力解决80%（或更多）Java/XML问题” （根据学习曲线假定为20%）

优点:

使用具体类而不是接口，简化了DOM的API。

大量使用了Java集合类，方便了Java开发人员。

缺点:

没有较好的灵活性。

性能不是那么优异。

4. DOM4J解析（重点掌握）

介绍

它是JDOM的一种智能分支。

它合并了许多超出基本XML文档表示的功能，包括集成的XPath （DOM树类似于文件目录的包含关系）支持、XML Schema支持以及用于大文档或流化文档的基于事件的处理。它还提供了构建文档表示的选项；

DOM4J是一个非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件。如今你可以看到越来越多的Java软件都在使用DOM4J来读写XML。

目前许多开源项目中大量采用DOM4J , 例如:Hibernate

4，XML解析

4.1 DOM4J解析XML（掌握）

步骤:

1. 引入jar文件 dom4j.jar

2. 创建一个指向XML文件的输入流；
 FileInputStream fis = new FileInputStream("xml文件的地址"); 
3. 创建一个XML读取工具对象；
SAXReader sr = new SAXReader(); 
4. 使用读取工具对象, 读取XML文档的输入流 , 并得到文档对象；
Document doc = sr.read(fis); 
5. 通过文档对象, 获取XML文档中的根元素对象；
 Element root = doc.getRootElement();

4.2 文档对象 Document

指的是加载到内存的整个XML文档.

常用方法:

1. 通过文档对象, 获取XML文档中的根元素对象；
Element root = doc.getRootElement(); 
2. 添加根节点；（由于一个文档只能有一个根节点，故此方法只用于操作空文档）
Element root = doc.addElement("根节点名称");

4.3 元素对象 Element

指的是XML文档中的单个节点.

常用方法:

1. 获取节点名称
String getName(); 
2. 获取节点内容
String getText(); 
3. 设置节点内容
String setText(); 
4. 根据子节点的名称 , 获取匹配名称的第一个子节点对象.
Element element(String 子节点名称); 
5. 获取所有的子节点对象
 List<Element> elements(); 
6. 获取节点的属性值
String attributeValue(String 属性名称); 
7. 获取子节点的内容
String elementText(String 子节点名称); 
8. 添加子节点
Element addElement(String 子节点名称);

4.4 实例操作——解析本地文件

1）导入jar文件

03-Java核心类库_XML与JSON

2）配置

03-Java核心类库_XML与JSON

这样就可以在项目中使用类库（进入lib文件夹，发现原先添加的jar文件现在可以展开了）

03-Java核心类库_XML与JSON

3）编码——获取单个元素及内容

Demo1.xml

<?xml version="1.0" encoding="UTF-8"?>
<books>
	<book id="1001">
		<name>金苹果</name>
		<info>锄禾日当午，苹果很辛苦</info>
	</book>
	<book id="1002">
		<name>银苹果</name>
		<info>锄禾日当午，苹果很辛苦</info>
	</book>
</books>

Demo.java

package com.kaikeba;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Demo {
    public static void main(String[] args) throws IOException, DocumentException {
        // 1，获取输入流
        FileInputStream fis = new FileInputStream("D://Demo1.xml");
        // 2，创建XML读取对象
        SAXReader sr = new SAXReader();
        // 3，读取并得到文档对象
        Document doc = sr.read(fis);
        // 4，通过文档获得根元素
        Element root = doc.getRootElement();
        // 5，开始解析元素
        System.out.println(root.getName());
        Element book = root.element("book");
        System.out.println(book.getText());
        Element name = book.element("name");
        System.out.println(name.getText());



        fis.close();
    }
}

03-Java核心类库_XML与JSON

注：若文件出现“Error on line 4 of document : 1 字节的 UTF-8 序列的字节 1 无效。”的报错信息，可以参考这里的解决方法@l执着l【1字节的UTF-8序列的字节1无效】。这里我采用记事本另存为的方法，解决了上述问题。

4）编码——获取多个元素及内容

package com.kaikeba;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class Demo {
    public static void main(String[] args) throws IOException, DocumentException {
        // 1，获取输入流
        FileInputStream fis = new FileInputStream("D://Demo1.xml");
        // 2，创建XML读取对象
        SAXReader sr = new SAXReader();
        // 3，读取并得到文档对象
        Document doc = sr.read(fis);
        // 4，通过文档获得根元素
        Element root = doc.getRootElement();
        // 5，开始解析元素
        List<Element> list = root.elements();                  // 获取全部节点
        for(int i = 0; i < list.size(); i++) {
            Element book = list.get(i);
            System.out.println(book.attributeValue("id"));  // 获取属性的值
            System.out.println(book.elementText("name"));   // 获取节点文本内容
            System.out.println(book.elementText("info"));   // 获取节点文本内容
            System.out.println("-------------------------");   // 分割线
        }
        fis.close();
    }
}

03-Java核心类库_XML与JSON

4.5 实例操作——解析网络文件

网络文件来自于网址：

http://apis.juhe.cn/mobile/get?%20phone=手机号&dtype=xml&key=9f3923e8f87f1ea50ed4ec8c39cc9253

运行效果如下：

03-Java核心类库_XML与JSON

package com.kaikeba;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;

public class Demo {
    public static void main(String[] args) throws IOException, DocumentException {
        String phone = "18856306666";               // 非本人号码
        // 1，获取到XML资源的输入流
        URL url = new URL("http://apis.juhe.cn/mobile/get?%20phone=" + phone + "&dtype=xml&key=9f3923e8f87f1ea50ed4ec8c39cc9253");
        URLConnection conn = url.openConnection();  // 打开链接
        InputStream is = conn.getInputStream();     // 获得输入流
        // 2，创建XML读取对象
        SAXReader sr = new SAXReader();
        // 3，通过读取对象，读取XML数据，并返回文档对象
        Document doc = sr.read(is);
        // 4，获取根节点
        Element root = doc.getRootElement();
        // 5，解析内容
        String code = root.elementText("resultcode");
        if("200".equals(code)) {
            Element result = root.element("result");
            String province = result.elementText("province");
            String city = result.elementText("city");
            if(province.equals(city)) {
                System.out.println("号码归属地：" + province);
            } else {
                System.out.println("号码归属地：" + province + " " + city);
            }
        } else {
            System.out.println("请输入正确的手机号码");
        }
        is.close();
    }
}

运行效果

03-Java核心类库_XML与JSON

5，xPATH解析

5.1 路径表达式

通过路径快速的查找一个或一组元素

路径表达式:

/ : 从根节点开始查找

// : 从发起查找的节点位置查找后代节点（常用）

. : 查找当前节点

.. : 查找父节点

@ : 选择属性. *

属性使用方式:

[@属性名='值']

[@属性名>'值']

[@属性名<'值']

[@属性名!='值']

举例

books: 路径： //book[@id='1']//name

books
    book id=1 
        name 
        info 
    book id=2 
        name 
        info

5.2 使用步骤

通过Node类的两个方法, 来完成查找:

(Node是 Document 与 Element 的父接口)

方法1.

//根据路径表达式, 查找匹配的单个节点
Element e = selectSingleNode("路径表达式"); 
方法2.
List<Element> es = selectNodes("路径表达式");

5.3 举例

1）代码

package com.kaikeba;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class Demo {
    public static void main(String[] args) throws IOException, DocumentException {
        // 1，获取输入流
        FileInputStream fis = new FileInputStream("D://Demo1.xml");
        // 2，创建XML读取对象
        SAXReader sr = new SAXReader();
        // 3，读取并得到文档对象
        Document doc = sr.read(fis);
        // 4，通过文档对象+XPATH查找所有name节点
        List<Node> data = doc.selectNodes("//name");
        for(Node e : data) {
            System.out.println(e.getName());
            System.out.println(e.getText());
        }
        fis.close();
    }
}

2）D://Demo1.xml

<?xml version="1.0" encoding="UTF8"?>
<books>
	<book id="1001">
		<name>金苹果</name>
		<info>锄禾日当午，苹果很辛苦</info>
	</book>
	<book id="1002">
		<name>银苹果</name>
		<info>锄禾日当午，苹果很辛苦</info>
	</book>
</books>

3）运行结果

03-Java核心类库_XML与JSON

4）网络文档解析

package com.kaikeba;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;

import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;

public class Demo {
    public static void main(String[] args) throws IOException, DocumentException {
        String phone = "18856306666";               // 非本人号码
        // 1，获取到XML资源的输入流
        URL url = new URL("http://apis.juhe.cn/mobile/get?%20phone=" + phone + "&dtype=xml&key=9f3923e8f87f1ea50ed4ec8c39cc9253");
        URLConnection conn = url.openConnection();  // 打开链接
        InputStream is = conn.getInputStream();     // 获得输入流
        // 2，创建XML读取对象
        SAXReader sr = new SAXReader();
        // 3，通过读取对象，读取XML数据，并返回文档对象
        Document doc = sr.read(is);
        // 4，运营商
        Node node = doc.selectSingleNode("//company");
        System.out.println("运营商：" + node.getText());

        is.close();
    }
}

可以方便的解析想要获取的内容，但是效率本省并没有提高；

03-Java核心类库_XML与JSON

6，XML生成（熟悉）

6.1 步骤

步骤:

1. 通过文档帮助器 (DocumentHelper) , 创建空的文档对象；
Document doc = DocumentHelper.createDocument(); 
2. 通过文档对象, 向其中添加根节点；
 Element root = doc.addElement("根节点名称"); 
3. 通过根节点对象root , 丰富我们的子节点；
Element e = root.addElement("元素名称"); 
4. 创建一个文件输出流 ,用于存储XML文件；
FileOutputStream fos = new FileOutputStream("要存储的位置"); 
5. 将文件输出流, 转换为XML文档输出流；
XMLWriter xw = new XMLWriter(fos); 
6. 写出文档；
xw.write(doc); 
7. 释放资源；
xw.close();

6.2 案例

1）代码

package com.kaikeba;

import org.dom4j.*;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;

public class Demo {
    public static void main(String[] args) throws IOException, DocumentException {
        // 1，通过文档帮助器，创建一个文档对象
        Document doc = DocumentHelper.createDocument();
        // 2，给文档添加一个节点
        Element books = doc.addElement("books");
        // 3，通过根节点丰富子节点
        for(int i = 0; i < 100; i++) {
            Element book = books.addElement("book");
            Element name = book.addElement("name");
            name.setText("第" + i + "个种苹果的小姑娘");
            Element info = book.addElement("info");
            info.setText("第" + i + "个种苹果的故事");
            book.addAttribute("id", 100 + i + "");
        }
        // 4，创建一个文档输出流
        FileOutputStream fos = new FileOutputStream("books.xml");// 工程所在目录创建文件
        // 5，将输出流转换为XML输出流
        XMLWriter xw = new XMLWriter(fos);
        // 6，写出文档
        xw.write(doc);
        // 7，释放资源
        fos.close();
        System.out.println("执行完毕");
    }
}

2）执行效果

03-Java核心类库_XML与JSON

格式化：Ctrl + Alt + L

03-Java核心类库_XML与JSON

6.3 XStream 的使用(了解)

一般情况下，不会通过上述方式，直接从空白文档生成一个XML文件。而是将一个对象转换为XML文件进行传输。这样使用上述方法显得较为复杂，故引入了XStream。

1）使用步骤

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

使用步骤:

1. 创建XStream 对象；
XStream x = new XStream(); 
2.修改类生成的节点名称 (默认节点名称为包名.类名)；
x.alias("节点名称",类名.class); 
3. 传入对象 , 生成XML字符串
String xml字符串 = x.toXML(对象);

2）举例

package com.kaikeba;

import com.thoughtworks.xstream.XStream;
import org.dom4j.*;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
import java.util.Objects;

public class Demo {
    public static void main(String[] args) throws IOException, DocumentException {
        Person person = new Person("张三", 18);

        // XStream的使用
        // 1，创建XStream对象
        XStream xs = new XStream();
        // 2，修改某个类型生成的节点（可选，默认为包名+类名）
        xs.alias("Person", Person.class);
        // 3，传入对象，开始生成
        String xml = xs.toXML(person);
        System.out.println(xml);
    }
    // 创建一个类 用于测试
    static class Person {
        private String name;
        private int age;

        /**
         * 构造方法
         */
        public Person() {
        }

        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        /**
         * getter and setter
         * @return
         */
        public String getName() {
            return name;
        }

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

        public int getAge() {
            return age;
        }

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

        /**
         * 重写equals和HashCode
         * @param o
         * @return
         */
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Person person = (Person) o;
            return age == person.age &&
                    Objects.equals(name, person.name);
        }

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

        /**
         * 重写toString
         * @return
         */
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
}

运行结果

03-Java核心类库_XML与JSON

7，JSON介绍

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

相比于XML：解析更简单，数据传输更快

7.1 对象格式

1）举例

一本书

书名

简介

Java

class Book{ 
    private String name; 
    private String info;
    get/set... 
}
Book b = new Book(); 
b.setName(“金苹果”); 
b.setInfo(“种苹果”); 
...

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

XML

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

JSON（属性的双引号可以省略，属性值不可以，但是在Java中属性最好也加上双引号）

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

2）格式

一个对象, 由一个大括号表示.

括号中描述对象的属性 . 通过键值对来描述对象的属性 (可以理解为, 大括号中, 包含的是一个个的键值对.)

格式:

键与值之间使用冒号连接, 多个键值对之间使用逗号分隔.

键值对的键应使用引号引住 (通常Java解析时, 键不使用引号会报错. 而JS能正确解析.)

键值对的值, 可以是JS中的任意类型的数据

7.2 数组格式

在JSON格式中可以与对象互相嵌套

[元素1,元素2...]

对象中可以套数组，数组中可以套对象

{ 
    "name":"伟杰老师", 
    "age":18, 
    "pengyou":["张三","李四","王二","麻子",{ 
                "name":"野马老师", 
                "info":"像匹野马一样狂奔在技术钻研的道路上" 
                }], 
    "heihei":{ 
        "name":"大长刀", 
        "length":"40m" 
    } 
}

8，JSON解析

做什么?

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

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

目前Java中没有集成的JSON解析工具，所以常用的解析工具需要自己导入，比如谷歌的Gson，阿里的FastJson。相应的jar包在置顶的链接中可以下载。也可以在GitHub中下载最新的版本。

8.1 Gson

1）将对象转换为JSON字符串

步骤:

1. 引入JAR包

2. 在需要转换JSON字符串的位置编写如下代码即可:
String json = new Gson().toJSON(要转换的对象); 
案例:
Book b = BookDao.find(); 
String json = new Gson().toJson(b); 
System.out.println(json);

2）将JSON字符串转换为对象

步骤：

1. 引入JAR包
2. 在需要转换Java对象的位置, 编写如下代码:

对象 = new Gson().fromJson(JSON字符串,对象类型.class);

案例:

String json = "{\"id\":1,\"name\":\"金苹果\",\"author\":\"李伟杰 \",\"info\":\"嘿嘿嘿嘿嘿嘿\",\"price\":198.0}"; 
Book book = new Gson().fromJson(json, Book.class); 
System.out.println(book);

3）举例

8.2 FastJson

1）将对象转换为JSON字符串

步骤

1. 引入JAR包

2. 在需要转换JSON字符串的位置编写如下代码即可:
String json=JSON.toJSONString(要转换的对象); 
案例:
Book b = BookDao.find(); 
String json=JSON.toJSONString(b); 
System.out.println(json);

2）将JSON字符串转换为对象

步骤

1. 引入JAR包
2. 在需要转换Java对象的位置, 编写如下代码:

类型 对象名=JSON.parseObject(JSON字符串, 类型.class);

或

List<类型> list=JSON.parseArray(JSON字符串,类型.class);

案例:

String json = "{\"id\":1,\"name\":\"金苹果\",\"author\":\"李伟杰 \",\"info\":\"嘿嘿嘿嘿嘿嘿\",\"price\":198.0}"; 
Book book = JSON.parseObject(json, Book.class); 
System.out.println(book);

8.3 举例——配置环境

1）添加jar包

03-Java核心类库_XML与JSON

8.4 编写代码——Gson

Book.java

package com.kaikeba;

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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) 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);
    }

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

Demo.java（对象转JSON）

package com.kaikeba;

import com.google.gson.Gson;
import com.thoughtworks.xstream.XStream;
import org.dom4j.*;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
import java.util.Objects;

public class Demo {
    public static void main(String[] args) {
        // 1，创建Gson对象
        Gson g = new Gson();
        // 2，转换
        Book b = new Book("100", "金苹果", "种苹果");
        String s = g.toJson(b);
        System.out.println(s);
    }

}

03-Java核心类库_XML与JSON

Demo.java（JSON转对象）

package com.kaikeba;

import com.google.gson.Gson;
import com.thoughtworks.xstream.XStream;
import org.dom4j.*;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
import java.util.Objects;

public class Demo {
    public static void main(String[] args) {
        // 1，创建Gson对象
        Gson g = new Gson();
        // 2，转换{"id":"100","name":"金苹果","info":"种苹果"}为对象
        Book b = g.fromJson("{\"id\":\"100\",\"name\":\"金苹果\",\"info\":\"种苹果\"}", Book.class);
        System.out.println(b);
    }

}

03-Java核心类库_XML与JSON

注意：

03-Java核心类库_XML与JSON

8.5 FastJson举例

1）对象转JSON

03-Java核心类库_XML与JSON

2）JSON转对象

03-Java核心类库_XML与JSON

JSON转数组

03-Java核心类库_XML与JSON

本文地址：https://blog.csdn.net/qq_41528502/article/details/109128471

相关标签：《新职课-JavaEE开发工程师V2.0》学习之路 1024程序员节

上一篇： Java-数据类型（8种基本数据类型+3种引用类型）

下一篇： Java象类实现计算景区门票（包含GUI相关窗体组件、文本以及按钮）

03-Java核心类库_XML与JSON

七，xml与json

1，XML介绍

1.1 简介

1.2 为什么学习XML？

1.3 XML文件

2，XML语法

1）XML文档声明

2）标记 ( 元素 / 标签 / 节点)

3）一个XML文档中, 必须有且且仅允许有一个根标记.

4）标记可以嵌套, 但是不允许交叉

5）标记的层级称呼 (子标记, 父标记 , 兄弟标记, 后代标记 ,祖先标记)

6）标记名称 允许重复

7）标记除了开始和结束 , 还有属性.

8）注释

语法进阶CDATA （了解）

3，解析XML的方式

3.1 Java解析XML（掌握）

4，XML解析

4.1 DOM4J解析XML（掌握）

4.2 文档对象 Document

4.3 元素对象 Element

4.4 实例操作——解析本地文件

4.5 实例操作——解析网络文件

5，xPATH解析

5.1 路径表达式

5.2 使用步骤

5.3 举例

6，XML生成（熟悉）

6.1 步骤

6.2 案例

6.3 XStream 的使用(了解)

7，JSON介绍

7.1 对象格式

7.2 数组格式

8，JSON解析

8.1 Gson

8.2 FastJson

8.3 举例——配置环境

8.4 编写代码——Gson

8.5 FastJson举例