解析JSON
铭记：访问外界和向外界写入数据都是通过流的的方式
解析XML：
- SAXReader类
生成XML：
- XMLWriter类 DocumentHelper类
- XStream类
解析和生成JSON：
- GSon类
- JSON类
了解XML
- 语法：
文档声明：<?xml version = "1.0" encoding = "UTF-8" ?>
由“<标明名>“开始，以</标明名>结束,标明名可以自定义，可以嵌套，但不能嵌套标明的一半。一个.XML只允许有一个根标明。
如：
<person></person> 正确
<person> <age> </person> </age> 错误
- 命名规范：
1.标明名可以包含英文和数字，其他字符
2.标明名不能由XML，Xml，xml，标点符号，数字开头
3.标明名中不能由空格和冒号
4.标明名要区分大小写
- 解析XML常用方法：
```
- SAXReader类：
read() 读取为文档
-操作文档的节点：
getRootElement() 获取文档的根节点
elements() 获取节点的子节点集合，数据类型为List<Element>
element(String Nodename) 获取指定节点
getName() 获取节点名
getText() 获取节点内容
elementText(String node) 获取指定节点的内容
setText() 设置节点内容
attributeValue(String attributeName) 获取节点属性值
addAttribute(String attributeName ,String attributeValue) 给节点设置属性
addElement(String Node) 添加节点
- XPATH操作节点：
例如：“//hobby0[@id="hobby]”
语法：
/ ： 从根节点开始
// ： 从当前节点开始找查后代节点
. ： 找查当前节点
.. ： 找查该节点的父节点
@ ：选择属性
使用方式：[@属性名=“值”]
方法：注意必须操作的是根节点
selectSingleNode("路径表达式") 找查匹配的单个节点
selectNodes("路径表达式") 找查节点的子节点
```
- 解析XLM的步骤：
```
一想到解析XML就要用到：SAXReder类
1.获取.xml文件输入流FileInputStream类
FileInputStream flie = new FileStream("xml文件路径")
2.实例化解析xml的类：SAXReader 类
SAXReader reader = new SAXReader();
3.解析xml
Document document = reader.read(file);
4.获取根节点：
Element element = document.getRootElement();
5.根据节点等方法得到数据；
```
案例：
```
- 案例一：
public class Task1 {
/**
* 解析XML文件
*
* one.xml文件:
*
* <?xml version="1.0" encoding="UTF-8" ?>
* <preson>
* <name>墨染</name>
* <age>18岁</age>
* <hobby0>
* <hobby1>羽毛球</hobby1>
* <hobby2>乒乓球</hobby2>
* <hobby3>排球</hobby3>
* <hobby4>篮球</hobby4>
* </hobby0>
* </preson>
*
* */
public static void main(String[] args) throws FileNotFoundException, DocumentException {
FileInputStream p = new FileInputStream("out\\one.xml"); //获取XML输入流
SAXReader s = new SAXReader(); //实例XML解析工具
Document d = s.read(p); //读取为文档
Element e = d.getRootElement(); //获得根节点
List<Element> l = e.elements(); //获取根节点下的子节点
ListIterator<Element> i = l.listIterator(); //获取List集合迭代器
String g = null; //记录hobby0
String o = null; //记录子节点名
p: while(i.hasNext()) {
o=i.next().getName();
if(o.equals("hobby0")) {
g = o;
break p;
}
System.out.println(e.elementText(o));
}
Element kk= e.element(g); //获取hobby0节点
List<Element> jj= kk.elements(); //获取hobby0节点的子节点
for(Element as : jj) {
System.out.println(as.getText());
}
p.close(); //关闭流
}
}
- 案例二 XPATH
```
生成XML的步骤
```
**一想到要生成XML文件想到的类：XMLWriter类 ，DocumentHelper类，XStream类**
- XMLWriter类 ，DocumentHelper类
1.获取文件输出：
FileOutputStream file = new FileOutputStream("文件路径");
2.文档帮助器类
Element element = DocumentHelper.createElement(String node); //生成根节点
3。添加节点：
Element elementone = document.addElement( String node);
4.实例化文档转换器类，并将文件转化为XML文件：
XMLWriter writer = new XMLWriter(file);
5.将生成的XML写入XML文件
wrter.writer(file);.
6.关闭流：
write.close();
- XStream类：
1.实例化类：
类名 对象 = new 类名();
2.实例化XStream类：
Xstream xstream = new Xstream();
3.规定根节点
xstream.alias("根节点",类名.class);
4.把对象转换为XML字符串格式
类名 对象 = xstream.toXML(对象)
```
案例：
```
案例一：
Element e=DocumentHelper.createElement("person");
e.addElement("name","幸运佳");
e.addElement("age", "18");
Element wx=e.addElement("hobby");
String[] array = {"启发","自律","墨染","星辰"};
for(int i = 0;i<array.length;i++) {
wx.addElement("hobby"+i,(String)Array.get(array, i));
}
FileOutputStream f = new FileOutputStream("two.txt");
XMLWriter w = new XMLWriter(f);
w.write(e);
w.close();
案例二：
public class Task3 {
/**
* 生成XML字符串，并写入文件
* @param args
* @throws IOException
* @throws DocumentException
*/
public static void main(String[] args) throws IOException, DocumentException {
Person p = new Person("流星","18","墨染");
XStream x = new XStream(); //借助XStream类
x.alias("person",Person.class); //规定根节点
System.out.println(x.toXML(p));
FileOutputStream f = new FileOutputStream("there.txt",false);
// 必须false，不写时默认false，填true时会发生错误，原因就是 XML文件有且仅有一个根节点。
PrintStream p2 = new PrintStream(f); //转化为字符流
String b =x.toXML(p); //把对象转换为XML字符串
p2.print(b);
p2.close(); //关闭流
XMLWriter w = new XMLWriter(f); //把文件转换为.xml类型的
w.close(); //关闭流
FileInputStream fs = new FileInputStream("there.txt"); //文件输入流
InputStreamReader in = new InputStreamReader(fs); //转换为字符流
SAXReader s = new SAXReader(); //XML解析工具类
Document d = s.read(in); //获取文档
Element e = d.getRootElement(); //获取根节点
System.out.println(e.getName());
in.close(); //关闭流
}
}
class Person{
private String name;
private String age;
private String hobby;
public Person(String name, String age, String hobby) {
this.name = name;
this.age = age;
this.hobby = hobby;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
public String getHobby() {
return hobby;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", hobby=" + hobby + "]";
}
}
```
掌握JSON
解析JSON有两个类：GSon类 ， JSON类
JSON语法：
- {}包住的相当于一个对象
- {}包住的内容由键值对（键 ：值）的形式组成，并且同一级键不能有重复（唯一性），且键所对应的值也可是是一个{}（对象）。
- 每个键值对有英文逗号隔开
- 为了安全，在Java中我们要把键用引号引起来。
```
如：
{
"age":"18",
"name"："墨染"，
“hobby”:{
"age":"18",
"name":"星辰"
}
}
```
GSon类
```
**方法**
- toJson(对象名) 把对象转换为JSON格式字符串
- fromJson(String jsonsring, 类名.class) 把JSON格式的字符串转换为对象
案例：
public class Task4 {
/**
* Gson
* */
public static void main(String[] args) {
Person p = new Person("墨染","19","星辰");
Gson g = new Gson(); //Gson类
String s = g.toJson(p); //把对象转换为json格式
System.out.println(s);
Person pl = g.fromJson(s, Person.class); // json格式转换为Person类
System.out.println(pl.getName());
}
}
```
JSON类
```
**方法**
- toJSONString（对象名） 把对象转换为JSON格式的字符串
- preseObject(String jsonstring,类名.class) 把JSON格式的字符串转换为对象
- preseArray(String jsonstring , 类名.class) 把JSON格式的字符串转换为List集合类型
案例：
public class Task5 {
/**
* FastJson
* */
public static void main(String[] args) {
Person p = new Person("墨染","18","龙的传人");
String s = JSON.toJSONString(p); //类JSON 把对象转换为JSON字符串
System.out.println(s);
Person k = JSON.parseObject(s,Person.class); //静态类JSON 把为JSON字符串转换为对象Person
System.out.println(k.getAge());
}
}
```
940
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
