目录
XML
1.什么是XML，有什么特性
- 可扩展标记语言（eXtensible Markup Language）。
- 可扩展:指标签都是自定义的(不是系统规定的)，如<user><student>。
特性:
1. xml具有平台无关性, 是一门独立的标记语言.
- 平台(系统)无关:xml文件在win或者苹果电脑上打开效果是一样的。
- 语言无关:xml文件由java、c、JS解析后的数据是一样的
2. xml具有自我描述性
- xml可以自己描述自己
2.为什么学习XML,有什么功能
1.进行网络数据传输-通常使用JSON
- 在网络编程中，客户端与服务器端传输一段数据，服务器没有标准如何拆分这段数据，通常是客户端和服务端约定好标记进行拆分，而xml在存储的时候就对数据拆分。
- 客户端与服务器端传递对象，使用对象序列化，如果客户端和服务端都是java编写没问题，如果客户端是C,Py等编写，服务器给客户端发送java的对象，对方是识别不了的，不同编程语言的对象的组织格式都是不一样的。
2.数据存储-基本不用
3.配置文件
- 只需要学习语法，如何解析配置文件只做了解，后期框架来解析
3.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>4.java解析XML方式及优缺点
1.DOM解析:
- 将标记语言文档一次性加载进内存，在内存中形成一棵DOM树。
2.DOM优缺点:
- 优点:方便操作，可以对xml文档进行CRUD(增删改查)操作。
- 缺点:占内存。
- 将标记语言文档(html,xml等)一次性加载进内存，在内存形成DOM树，可以通过getElementsBy..来选中标签获取标签的值，也可以调用方法对标签的增删改查操作。
- 但是，由于标记语言文档是一次性加载到内存的，若标记语言只有1MB,但要是解析的代码写的不是很好，那么1MB的标记语言加载到内存形成的DOM树一般会扩大到1000倍。这个树形结构就比较消耗内存，不适用内存比较小的设备比如手机等。
3.SAX解析
- 逐行读取，基于事件驱动的。
-
优点:不占内存。
-
缺点:只能读取，不能增删改。
- 1.对于上面的标记语言，用SAX思想进行逐行读取，首先读第一行到内存，然后读第二行前，将上一行从内存中删除，即读一行释放一行，内存中永远只有一行。
- 2.title标签是按照三行来读取的，这存在一个严重问题就是读取文本"文档标题"时怎么知道这个文本是titile内容，title的开始标签已经删掉了，因此这个地方就需要基于事件的驱动来完成数据的获取，它会判断如果是开始标签就会触发监听器(代码),在监听器中判断是title还是h1还是其它开始标签，因此编写难度比较大。
- 3.由于它逐行读取，读取一行释放一行，因此是不占内存，可以适用于内存较小的设备比如主流手机都使用的是SAX思想解析。
- 4.缺点:由于它是逐行读取，读一行释放一行，因此是无法进行增删改的。
4.总结
- 一般在服务端使用DOM解析思想(占内存)，在移动端使用SAX思想
- 比如安卓中使用的就是SAX思想，而javaeweb做网站使用的就是DOM思想。
5.使用DOM4J解析XML
步骤:
- 1. 引入jar文件 dom4j.jar
- 2. 创建一个指向XML文件的输入流(不一定是文件流)
- 3. 创建一个XML读取工具对象
- 4. 使用读取工具对象, 读取XML文档的输入流 , 并得到文档对象
- 5. 通过文档对象, 获取XML文档中的根元素对象
- 6.获取到元素对象Element(单个节点)，可进行以下操作
常用方法:
String getName();1. 获取节点名称
String getText();2. 获取节点内容
String setText();3. 设置节点内容
Element element(String 子节点名称);4. 根据子节点的名称 , 获取匹配名称的第一个子节点对象.
List<Element> elements();5. 获取所有的子节点对象
String attributeValue(String 属性名称);6. 获取节点的属性值
String elementText(String 子节点名称);7. 获取子节点的内容
Element addElement(String 子节点名称);8. 添加子节点
6.添加jar包
6.DOM4J解析本地XML
使用DOM4J解析器解析本地xml
1.导入dom4j-1.6.1.jar
2.写一个xml
- 就是xml读取对象以流的方式读取到xml文档并将其转成dom文档对象(dom树)，然后获取各个子节点及其内容就达到解析获取到xml中数据。
<!--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>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.util.List;
/**
* 解析本地xml文件--使用DOM4J解析器
* 需要导入dom4j-1.6.1.jar
*/
public class MainXML {
public static void main(String[] args) throws FileNotFoundException, DocumentException {
//1.创建指向xml文件的输入流
FileInputStream fis = new FileInputStream("src/Demo1.xml");
//2.创建xml读取对象
SAXReader sr = new SAXReader();
//3.读取并得到文档对象(即读取xml文件转化为dom树)
Document doc = sr.read(fis);
//4.通过文档获取dom树的根元素
Element root = doc.getRootElement();
//5.开始解析元素
System.out.println(root.getName());//获取根元素名称books
List<Element> es = root.elements();//获取根下所有子节点(两个book节点)
//每次循环获取一本书，并打印书的id,name,info信息
for (int i = 0; i < es.size(); i++) {
Element book = es.get(i);//获取book节点元素
//获取节点id属性值
System.out.println(book.attributeValue("id"));
//获取book节点中子节点name内容
System.out.println(book.elementText("name"));
//获取book节点中子节点info内容
System.out.println(book.elementText("info"));
System.out.println("=============");
}
}
}
7.DOM4J解析网络xml文件
- 导入dom4j-1.6.1.jar
- 下面给出一个接口，通过传递手机号参数，传回一个xml文档描述这个手机号所属地
- http://apis.juhe.cn/mobile/get?phone=18751902567&dtype=xml&key=9f3923e8f87f1ea50ed4ec8c39cc9253
- 下面开始解析网络发来的xml文件，将其转为dom文档对象，并获取各个节点和内容。
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.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
/**
* 解析网络xml文件-DOM4J解析器
* 1.下面给出一个接口，通过传递手机号参数，传回一个xml文档描述这个手机号所属地
* 2.下面开始解析网络发来的xml文件，将其转为dom文档对象，并获取各个节点和内容。
*/
public class MainXML2 {
public static void main(String[] args) throws IOException, DocumentException {
String phone="18751902567";
//1.获取到xml资源的输入流
URL url=new URL("http://apis.juhe.cn/mobile/get?phone="+phone+"&dtype=xml&key=9f3923e8f87f1ea50ed4ec8c39cc9253");
URLConnection conn = url.openConnection();//打开连接
InputStream is = conn.getInputStream();//获取输入流
//2.创建xml读取对象
SAXReader sr = new SAXReader();
//3.通过读取对象sr，读取xml数据，并返回文档对象(dom树)
Document doc = sr.read(is);
//4.获取根节点
Element root = doc.getRootElement();
//5.解析内容(解析xml即获取dom树各个节点内容)，参照该网站传回的xml格式进行解析
String code = root.elementText("resultcode");//获取resultcode子节点内容
if ("200".equals(code)){
//若码为200，表示手机号没问题,获取result子节点
Element result = root.element("result");
//获取result节点下的省份内容
String province = result.elementText("province");
String city = result.elementText("city");
if (province.equals(city)){
//若省份和城市同名
System.out.println("手机号码归属地为:"+city);
}else {
//省份和城市不同名
System.out.println("手机号码归属地:"+province+city);
}
}else{
System.out.println("请输入正确的手机号");
}
}
}
拿到了xml中province和city节点的内容。
8.XPATH解析
- xpath解析xml:通过路径快速查找到一个或一组元素节点
路径表达式
路径写法:
/:表示从根节点开始查找
- 比如获取所有name节点写法：/books//book//name或者/books//name
- 从根节点查找很少用，通常用//
//:直接查找后代节点(发起查找的节点就是根节点books)
- 比如获取所有name节点写法: //name即可
- 获取id为1节点book中的name节点写法://book[@id=‘1’]//name
xpath使用
9.DOM4J-XPATH解析本地xml文档
- 导入jar包，准备好xml文档
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.List;
/**
* 使用DOM4J-xpath解析器解析本地xml文件
* 需要导入dom4j-1.6.1.jar
*/
public class MainXML3 {
public static void main(String[] args) throws IOException, DocumentException {
//1.创建指向xml文件的输入流
FileInputStream fis = new FileInputStream("src/Demo1.xml");
//2.创建xml读取对象
SAXReader sr = new SAXReader();
//3.读取并得到文档对象(即读取xml文件转化为dom树)
Document doc = sr.read(fis);
//4.通过文档对象+xpath查询所有name节点
List <Node>names = doc.selectNodes("//name");//查询的结果是多个使用这个方法
for (int i = 0; i < names.size(); i++) {
//获取所有name节点名称和内容
System.out.println(names.get(i).getName());
System.out.println(names.get(i).getText());
}
//5.获取指定id的book节点中name节点
//查询结果只有一个节点使用这个方法
Node node = doc.selectSingleNode("//book[@id='1001']//name");
System.out.println(node.getName()+node.getText());
fis.close();
}
}
10.DOM4J-XPATH解析网络xml文档
- 导入DOM4J的jar包
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;
/**
* -DOM4J-xpath解析网络xml文件
* 1.下面给出一个接口，通过传递手机号参数，传回一个xml文档描述这个手机号所属地
* 2.下面开始解析网络发来的xml文件，将其转为dom文档对象，并获取各个节点和内容。
*/
public class MainXML4 {
public static void main(String[] args) throws IOException, DocumentException {
String phone="18751902567";
//1.获取到xml资源的输入流
URL url=new URL("http://apis.juhe.cn/mobile/get?phone="+phone+"&dtype=xml&key=9f3923e8f87f1ea50ed4ec8c39cc9253");
URLConnection conn = url.openConnection();//打开连接
InputStream is = conn.getInputStream();//获取输入流
//2.创建xml读取对象
SAXReader sr = new SAXReader();
//3.通过读取对象sr，读取xml数据，并返回文档对象(dom树)
Document doc = sr.read(is);
//4.通过dom+xpath指定节点路径，获取指定节点
Node node = doc.selectSingleNode("//company");//获取xml文档中运营商节点
System.out.println("运营商:"+node.getText());
}
}
11.java生成XML文档
步骤:
- 导入dom4j-1.6.1.jar
- 1. 通过文档帮助器 (DocumentHelper) , 创建空的文档对象
- 2. 通过文档对象, 向其中添加根节点
- 3. 通过根节点对象root , 丰富我们的子节点
- 4. 创建一个文件输出流 ,用于存储XML文件
- 5. 将文件输出流, 转换为XML文档输出流
- 6. 写出文档 xw.write(doc);
- 7. 释放资源 xw.close();
Document doc = DocumentHelper.createDocument();
Element root = doc.addElement("根节点名称");
Element e = root.addElement("元素名称");
FileOutputStream fos = new FileOutputStream("要存储的位置");
XMLWriter xw = new XMLWriter(fos);
xw.write(doc);
xw.close();java生成xml文档
- 需要自己将对象搭建成dom树(搭建各个节点和赋值)再传出，比较麻烦
- 下一节使用xstream-1.3.1.jar自动生成dom树
import org.dom4j.Comment;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.XMLWriter;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* java生成xml文档
* 需要自己将对象搭建成dom树(搭建各个节点和赋值)
* 下一节使用xstream-1.3.1.jar自动生成dom树
*/
public class MainXML5 {
public static void main(String[] args) throws IOException {
//1.通过文档帮助器，创建一个文档对象
Document doc = DocumentHelper.createDocument();
//2.给文档对象(dom树)添加第一个节点(根节点)
Element books = doc.addElement("books");
//3.通过根节点，丰富子节点
// 创建100个book子节点，每个子节点又包含name和info两个子节点
for (int i = 0; i < 100; i++) {
Element book = books.addElement("book");//添加books子节点
book.addAttribute("id",100+i+"");//设置属性
Element name = book.addElement("name");//添加book子节点
name.setText(i+"斗罗大陆");
Element info = book.addElement("info");
info.setText("每周更新第"+i+"集");
}
//4.将写好的xml文档写入到本地文件
//4.1.创建一个指向xml的文件输出流(即封装路径并创建文件)
FileOutputStream fos = new FileOutputStream("src/Book.xml");
//4.2.将文件输出流转成(装饰)xml输出流
XMLWriter xw = new XMLWriter(fos);
//4.3.写出文档
xw.write(doc);
//5.释放资源
xw.close();
System.out.println("执行完毕");
}
}
12.XStream生成XML文档
- 导入xstream-1.3.1.jar
- 将java对象转换成XML字符串
import com.thoughtworks.xstream.XStream;
import java.util.Objects;
public class MainXML6 {
public static void main(String[] args) {
Person p = new Person();
p.setName("张三");
p.setAge(19);
//若从数据库拿到p对象，现在要发给用户，需要将对象转成json/xml
//下面是将对象转成xml(java生成xml)格式
//使用XStream将对象转成xml文档，自动生成dom树(直接传进对象即可)
//XStream使用
//1.创建XStream对象
XStream xStream = new XStream();
//2.修改某个类型生成的节点(默认生成的是全名:包名+类名)
// 把类型Person.class修改成person节点
// 这样对象的的外层节点就是person
xStream.alias("person",Person.class);
//3.传入对象，开始生成dom树(xml文档)
String xml = xStream.toXML(p);
System.out.println(xml);
}
static class Person{
private String name;
private int age;
public Person(String name, int age) { this.name = name; this.age = age; }
public Person() { }
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; }
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person pereson = (Person) o;
return age == pereson.age &&
Objects.equals(name, pereson.name);
}
@Override
public int hashCode() { return Objects.hash(name, age);}
}
}
XML与JSON比较
- 使用JSON解析一段字符串(数据)速度要比XML快很多倍。
- JSON格式阅读没有XML清晰明了
- 当数据量比较小，比如配置程序产生的缓存文件夹，配置数据库的连接密码等可以使用XML格式来配置文件，也可以使用Properties配置文件
- JSON数据，程序员编写代码解析起来比XML简单，机器解析比XML效率要高，
- JSON格式描述的数据占空间小，网络传输速度快
JSON
1.简介
- JavaScript Object Notation JS对象简谱 , 是一种轻量级的数据交换格式.
2.JSON对象格式
- 一个对象, 由一个大括号表示.
- 括号中 描述对象的属性 . 通过键值对来描述对象的属性
- (可以理解为, 大括号中, 包含的是一个个的键值对.)
格式:
- 键与值之间使用冒号连接, 多个键值对之间使用逗号分隔.
- 键值对的键 应使用引号引住 (通常Java解析时, 键不使用引号会报错. 而JS能正确解析.)
- 键值对的值, 可以是JS中的任意类型的数据
一本书
书名
简介
java
class Book{
private String name;
private String info;
get/set...
}
Book b = new Book();
b.setName(“金苹果”);
b.setInfo(“种苹果”);
js:
var b = new Object();
b.name = "金苹果";
b.info = "种苹果";
XML:
<book>
<name>金苹果</name>
<info>种苹果</info>
</book>
JSON:
{
"name":"金苹果",
"info":"种苹果"
}3.JSON数组格式
- 在JSON格式中可以使对象和数组互相嵌套
- 下面朋友属性是一个数组，数组中还嵌套一个对象
{
"name":"老师",
"age":18,
"pengyou":["张三","李四","王二","麻子",{
"name":"野马老师",
"info":"像匹野马一样狂奔在技术钻研的道路上"
}],
"heihei":{
"name":"大长刀",
"length":"40m"
}
}3.JSON语法_遍历
<script>
//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){
//这样的方式获取不行。因为key是字符串类型，相当于person."name"
//要么person.name要么person["name"]
//alert(key + ":" + person.key);
alert(key+":"+person[key]);
}*/
//获取ps中的所有值，双重循环
for (var i = 0; i < ps.length; i++) {//循环获取数组中每一个json对象
var p = ps[i];
for(var key in p){ //循环获取每个json对象的键key
alert(key+":"+p[key]);
}
}
</script>4.JSON在线视图查看器
百度-搜索API平台-选一个API接口平台"京东万象"-复制天气预报的json格式数据-百度在线JSON校验格式化工具-选择JSON视图-将JSON字符串粘贴
5.Java对象与JSON字符串互转
5.1.谷歌的Gson
将对象转换为JSON字符串
- 1. 引入JAR包gson-2.8.6.jar
- 2. 在需要转换JSON字符串的位置编写如下代码即可:
String json = new Gson().toJSON(要转换的对象);- 案例:
Book b = BookDao.find();
String json = new Gson().toJson(b);
System.out.println(json);将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);import com.google.gson.Gson;
import java.util.HashMap;
import java.util.List;
/**
* 使用谷歌的Gson来实现对象与JSON字符串互转
*/
public class MainJSON {
public static void main(String[] args) {
//1.创建Gson对象
Gson gson = new Gson();
//2.将java对象转成JSON字符串
Book book = new Book("01", "斗罗大陆", "每周持续更新");
String s = gson.toJson(book);
System.out.println(s);//{"id":"01","name":"斗罗大陆","info":"每周持续更新"}
//3.将JSON字符串转成Book对象,引号需要转义需要
// ("{\"id\":\"01\",\"name\":\"斗罗大陆\",\"info\":\"每周持续更新\"}",Book.class)
Book book1 = gson.fromJson(s,Book.class);
System.out.println(book1);//Book{id='01', name='斗罗大陆', info='每周持续更新'}
//4.将JSON字符串转成HashMap类型(键值对)
HashMap map = gson.fromJson(s, HashMap.class);
System.out.println(map);//{name=斗罗大陆, id=01, info=每周持续更新}
//5.当JSON字符串中值是数组，转成对象后这个数组值变成Arraylist类型不是数组了
//{"id":"01","name":"斗罗大陆","info":"每周持续更新","count":["1集","2集"]}
HashMap map1 = gson.fromJson("{\"id\":\"01\",\"name\":\"斗罗大陆\",\"info\":\"每周持续更新\",\"count\":[\"1集\",\"2集\"]}", HashMap.class);
System.out.println( map1.get("count").getClass());//class java.util.ArrayList
List count=(List) map1.get("count");
System.out.println(count.get(1));//获取集合中索引1内容
}
static class Book{
String id;
String name;
String info;
public Book(String id, String name, String info) {
this.id = id;
this.name = name;
this.info = info;
}
@Override
public String toString() {
return "Book{" +
"id='" + id + '\'' +
", name='" + name + '\'' +
", info='" + info + '\'' +
'}';
}
}
}
5.2.阿里的FastJson
将对象转换为JSON字符串
- 1. 引入JAR包 fastjson-1.2.70.jar
- 2. 在需要转换JSON字符串的位置编写如下代码即可:
String json=JSON.toJSONString(要转换的对象);- 案例:
Book b = BookDao.find();
String json=JSON.toJSONString(b);
System.out.println(json);
将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);import book.Book;
import com.alibaba.fastjson.JSON;
import java.util.List;
public class MainJSON1 {
public static void main(String[] args) {
Book book = new Book("01", "斗罗大陆", "每周持续更新");
System.out.println(book);
//将对象转成json字符串
String json = JSON.toJSONString(book);
System.out.println(json);
//将json转成对象
Book book1 = JSON.parseObject(json,Book.class);
System.out.println(book1);
//将json转成数组["123","456","789"]
List<String> list = JSON.parseArray("[\"123\",\"456\",\"789\"]", String.class);
System.out.println(list.get(1));//456
}
}5.3.SpringMVC内置的Jackson
1.java对象怎么转成json格式
- 1.拿到对象
- 2.创建Jackson核心对象 ObjectMapper
- 3.writeValueAsString(obj):将对象转为json字符串
- 4.writeValue(参数1，obj)
- 5.两个常用注解
Demo将对象转成json并保存到指定文件
Person类
package domain;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
public class Person {
private String name;
private int age ;
private String gender;
//@JsonIgnore //排除属性，该属性birthday就不会被转化为json字符串了
//private Date birthday;
@JsonFormat(pattern = "yyyy-MM-dd")//属性值的格式化2020-04-09
private Date birthday;
public Date getBirthday() { return birthday; }
public void setBirthday(Date birthday) { this.birthday = birthday; }
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; }
public String getGender() { return gender; }
public void setGender(String gender) { this.gender = gender; }
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", gender='" + gender + '\'' +
'}';
}
}
public void test1() throws Exception {
Person p = new Person();//1.创建Person对象
p.setName("张三");
p.setAge(23);
p.setGender("男");
ObjectMapper mapper = new ObjectMapper(); //2.创建Jackson的核心对象 ObjectMapper
String json = mapper.writeValueAsString(p);//3.对象转json字符串
System.out.println(json); //{"name":"张三","age":23,"gender":"男"}
mapper.writeValue(new File("src\\a.txt"),p);//将数据写到src\\a.txt文件中,相对路径
mapper.writeValue(new FileWriter("src\\b.txt"),p);//writeValue.将数据关联到Writer
}
注解使用
public void test2() throws Exception {
Person p = new Person();
p.setName("张三");
p.setAge(23);
p.setGender("男");
p.setBirthday(new Date());
//2.转换
ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(p);
System.out.println(json);
当在Person类中没有对birthday属性使用注解@JsonFormat(pattern = "yyyy-MM-dd")
{"name":"张三","age":23,"gender":"男","birthday":1530958029263}
对birthday属性使用注解@JsonFormat(pattern = "yyyy-MM-dd")
{"name":"张三","age":23,"gender":"男","birthday":"2018-07-07"}
}Jackson解析器解析list集合为json字符串，结果为数组中包含多个json字符串
public void test3() throws Exception {
//1.创建Person对象
Person p = new Person();
p.setName("张三");
p.setAge(23);p.setGender("男");
p.setBirthday(new Date());
Person p1 = new Person();
p1.setName("张三");
p1.setAge(23);
p1.setGender("男");
p1.setBirthday(new Date());
Person p2 = new Person();
p2.setName("张三");
p2.setAge(23);
p2.setGender("男");
p2.setBirthday(new Date());
List<Person> ps = new ArrayList<Person>();
ps.add(p); ps.add(p1);ps.add(p2);
//2.转换
ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(ps);
// [{},{},{}]
//[{"name":"张三","age":23,"gender":"男","birthday":"2018-07-07"},
// {"name":"张三","age":23,"gender":"男","birthday":"2018-07-07"},
// {"name":"张三","age":23,"gender":"男","birthday":"2018-07-07"}]
System.out.println(json);
}Jackson解析器解析HashMap集合为json字符串
public void test4() throws Exception {
//1.创建map对象
Map<String,Object> map = new HashMap<String,Object>();
map.put("name","张三");
map.put("age",23);
map.put("gender","男");
//2.转换
ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(map);
//{"name":"张三","age":23,"gender":"男"}
System.out.println(json);//{"gender":"男","name":"张三","age":23}
}2.json字符串转java对象
public void test5() throws Exception {
//1.初始化JSON字符串,{"gender":"男","name":"张三","age":23}，使用了转义字符串
String json = "{\"gender\":\"男\",\"name\":\"张三\",\"age\":23}";
//2.创建ObjectMapper对象
ObjectMapper mapper = new ObjectMapper();
//3.转换为Java对象 Person对象
Person person = mapper.readValue(json, Person.class);
System.out.println(person);//Person{name='张三', age=23, gender='男'}
}5.4.通过第三方包json-lib.jar
我们要使⽤json和java中使⽤，我们需要使⽤到⼀个第三⽅的包。它就是
java对象和json之间的转换
单个对象或map集合与json互转
java->json：
Users user2=new Users();
user2.setUsername("李四");
user2.setPassword("abc");
user2.setAge(20);
JSONObject obj=JSONObject.fromObject(user);//obj就是json格式的json->java：
String str="{'username':'李四','password':'admin','age':19}";
JSONObject json=JSONObject.fromObject(str);
Users user=(Users)JSONObject.toBean(json,Users.class);对象集合和json的转换
java集合->json数组:
List list=new ArrayList();
list.add("dd");
list.add("aa");
JSONArray obj=JSONArray.fromObject(list);//set也是这么转json数组->java集合
⽅式1:
String str2="[{'age':20,'password':'abc','username':'李四'},
{'age':10,'password':'adb','username':'张三'}
]";
JSONArray json2=JSONArray.fromObject(str2);
Object[] obj=(Object[])JSONArray.toArray(json2,Users.class);⽅式2:
String str3="[{'age':20,'password':'abc','username':'李四'},
{'age':10,'password':'adb','username':'展示⼲'}
]";
JSONArray json3=JSONArray.fromObject(str3);
//默认转换成ArrayList
List<Users> list=(List<Users>) JSONArray.toCollection(json3,Users.class);
1966
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
