17、XML与Json

1、什么是XML
2、 XML的用途
3、 SAX解析XML
- XMLDemo for SAX
- PersonHandler
4、 DOM解析XML
5、 JDOM解析XML
6、 DOM4J解析XML
7、通过对象生成XML文件
8、各种解析方法比较
9、Json
10、 GSON组件的使用
11、 XML与JSON的比较

1、什么是XML

XML（Extensible Markup Language 可扩展标记语言）， XML是一个以文本来描述数据的
文档

<?xml version="1.0" encoding="UTF-8"?>
<people>
    <person personid="E01">
        <name>Tony</name>
        <address>10 Downing Street, London, UK</address>
        <tel>(061) 98765</tel>
        <fax>(061) 98765</fax>
        <email>tony@everywhere.com</email>
    </person>
    <person personid="E02">
        <name>Bill</name>
        <address>White House, USA</address>
        <tel>(001) 6400 98765</tel>
        <fax>(001) 6400 98765</fax>
        <email>bill@everywhere.com</email>
    </person>
</people>

package com.vince.xml;
/**
 */
public class Person {
    private String personid;
    private String name;
    private String address;
    private String tel;
    private String fax;
    private String email;
    @Override
    public String toString() {
        return "Person{" +
                "personid='" + personid + '\'' +
                ", name='" + name + '\'' +
                ", address='" + address + '\'' +
                ", tel='" + tel + '\'' +
                ", fax='" + fax + '\'' +
                ", email='" + email + '\'' +
                '}';
    }
    public String getPersonid() {
        return personid;
    }
    public void setPersonid(String personid) {
        this.personid = personid;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public String getTel() {
        return tel;
    }
    public void setTel(String tel) {
        this.tel = tel;
    }
    public String getFax() {
        return fax;
    }
    public void setFax(String fax) {
        this.fax = fax;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
}

2、 XML的用途

XML技术的用途：

（1）充当显示数据（以XML充当显示层）
（2）存储数据（存储层）的功能
（3）以XML描述数据，并在联系服务器与系统的其余部分之间传递。 (传输数据的一样格式)

从某种角度讲， XML是数据封装和消息传递技术

3、 SAX解析XML

SAX是Simple API for XML的缩写

SAX 是读取和操作 XML 数据更快速、更轻量的方法。 SAX 允许您在读取文档时处理它，从而不必等待整个文档被存储之后才采取操作。它不涉及 DOM 所必需的开销和概念跳跃。 SAX API是一个基于事件的API ，适用于处理数据流，即随着数据的流动而依次处理数据。 SAX API 在其解析您的文档时发生一定事件的时候会通知您。在您对其响应时，您不作保存的数据将会被抛弃

SAX API中主要有四种处理事件的接口，它们分别是ContentHandler， DTDHandler，EntityResolver 和 ErrorHandler 。

实际上只要继承DefaultHandler 类就可以，
DefaultHandler实现了这四个事件处理器接口，然后提供了每个抽象方法的默认实现。

// 创建SAX解析器工厂对象
SAXParserFactory spf = SAXParserFactory.newInstance();
// 使用解析器工厂创建解析器实例
SAXParser saxParser = spf.newSAXParser();
// 创建SAX解析器要使用的事件侦听器对象
PersonHandler handler =new PersonHandler();
// 开始解析文件
saxParser.parse(new File(fileName), handler);

XMLDemo for SAX

package com.vince.xml;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
import org.junit.Test;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
import javax.xml.parsers.*;
import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
 */
public class XMLDemo {
    /**
     * SAX解析的特点：
     * 1、基于事件驱动
     * 2、顺序读取，速度快
     * 3、不能任意读取节点（灵活性差）
     * 4、解析时占用的内存小
     * 5、SAX更适用于在性能要求更高的设备上使用（Android开发中）
     * @throws ParserConfigurationException
     * @throws SAXException
     * @throws IOException
     */
    @Test
    public void saxParseXML() throws ParserConfigurationException, SAXException, IOException {
        //1、创建一个SAX解析器工厂对象
        SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
        //2、通过工厂对象创建SAX解析器
        SAXParser saxParser = saxParserFactory.newSAXParser();
        //3、创建一个数据处理器（需要我们自己来编写）
        PersonHandler personHandler = new PersonHandler();
        //4、开始解析
        InputStream is = Thread.currentThread().getContextClassLoader()
                .getResourceAsStream("com/vince/xml/person.xml");
        saxParser.parse(is,personHandler);
        List<Person> persons = personHandler.getPersons();
        for (Person p:persons){
            System.out.println(p);
        }
    }
}

PersonHandler

package com.vince.xml;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
import java.util.ArrayList;
import java.util.List;
/**
 * Created by vince on 2017/7/1.
 * SAX解析的特点：
 * 1、基于事件驱动
 * 2、顺序读取，速度快
 * 3、不能任意读取节点（灵活性差）
 * 4、解析时占用的内存小
 * 5、SAX更适用于在性能要求更高的设备上使用（Android开发中）
 *
 */
public class PersonHandler extends DefaultHandler{
    private List<Person> persons = null;
    private Person p;//当前正在解析的person
    private String tag;//用于记录当前正在解析的标签名
    public List<Person> getPersons() {
        return persons;
    }
    //开始解析文档时调用
    @Override
    public void startDocument() throws SAXException {
        super.startDocument();
        persons = new ArrayList<>();
        System.out.println("开始解析文档...");
    }
    //在XML文档解析结束时调用
    @Override
    public void endDocument() throws SAXException {
        super.endDocument();
        System.out.println("解析文档结束.");
    }
    /**
     * 解析开始元素时调用
     * @param uri 命名空间
     * @param localName 不带前缀的标签名
     * @param qName 带前缀的标签名
     * @param attributes 当前标签的属性集合
     * @throws SAXException
     */
    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
        super.startElement(uri, localName, qName, attributes);
        if ("person".equals(qName)){
            p = new Person();
            String personid = attributes.getValue("personid");
            p.setPersonid(personid);
        }
        tag = qName;
        System.out.println("startElement--"+qName);
    }
    //解析结束元素时调用
    @Override
    public void endElement(String uri, String localName, String qName) throws SAXException {
        super.endElement(uri, localName, qName);
        if ("person".equals(qName)) {
            persons.add(p);
        }
        tag = null;
        System.out.println("endElement--"+qName);
    }
    //解析文本内容时调用
    @Override
    public void characters(char[] ch, int start, int length) throws SAXException {
        super.characters(ch, start, length);
        if (tag != null) {
            if ("name".equals(tag)) {
                p.setName(new String(ch,start,length));
            }else if("address".equals(tag)){
                p.setAddress(new String(ch,start,length));
            }else if("tel".equals(tag)){
                p.setTel(new String(ch,start,length));
            }else if("fax".equals(tag)){
                p.setFax(new String(ch,start,length));
            }else if("email".equals(tag)){
                p.setEmail(new String(ch,start,length));
            }
            System.out.println(ch);
        }
    }
}

4、 DOM解析XML

JAVA 解析 XML 通常有两种方式， DOM 和 SAX

DOM： Document Object Model（文档对象模型）

DOM的特性：

定义一组 Java 接口，基于对象，与语言和平台无关将 XML 文档表示为树，在内存中解析和存储 XML 文档，允许随机访问文档的不同部分。

DOM解析XML：

DOM的优点，由于树在内存中是持久的，因此可以修改后更新。它还可以在任何时候在树中上下导航， API使用起来也较简单。

解析步骤：

DocumentBuilderFactory builder = DocumentBuilderFactory.newInstance();
DocumentBuilder db = builder.newDocumentBuilder();
db.parse("person.xml");
NodeList node_person = doc.getElementsByTagName("person");

/**
     * DOM解析XML
     * 1、基于树型结构，通过解析器一次性把文档加载到内存中，所以会比较占用内存，可以随机访问
     * 更加灵活，更适合在WEB开发中使用
     */
    @Test
    public void domParseXML() throws ParserConfigurationException, IOException, SAXException {
        //1、创建一个DOM解析器工厂对象
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        //2、通过工厂对象创建解析器对象
        DocumentBuilder documentBuilder = factory.newDocumentBuilder();
        //3、解析文档
        InputStream is = Thread.currentThread().getContextClassLoader()
                .getResourceAsStream("com/vince/xml/person.xml");
        //此代码完成后，整个XML文档已经被加载到内存中，以树状形式存储
        Document doc = documentBuilder.parse(is);
        //4、从内存中读取数据
        //获取节点名称为person的所有节点，返回节点集合
        NodeList personNodeList = doc.getElementsByTagName("person");
        ArrayList<Person> persons = new ArrayList<>();
        Person p = null;
        //此循环会迭代两次
        for (int i=0;i<personNodeList.getLength();i++){
            Node personNode = personNodeList.item(i);
            p = new Person();
            //获取节点的属性值
            String personid = personNode.getAttributes().getNamedItem("personid").getNodeValue();
            p.setPersonid(personid);
            //获取当前节点的所有子节点
            NodeList childNodes = personNode.getChildNodes();
            for (int j = 0;j<childNodes.getLength();j++){
                Node item = childNodes.item(j);
                String nodeName = item.getNodeName();
                if ("name".equals(nodeName)) {
                    p.setName(item.getFirstChild().getNodeValue());
                }else if("address".equals(nodeName)){
                    p.setAddress(item.getFirstChild().getNodeValue());
                }else if("tel".equals(nodeName)){
                    p.setTel(item.getFirstChild().getNodeValue());
                }else if("fax".equals(nodeName)){
                    p.setFax(item.getFirstChild().getNodeValue());
                }else if("email".equals(nodeName)){
                    p.setEmail(item.getFirstChild().getNodeValue());
                }
            }
            persons.add(p);
        }
        System.out.println("结果:");
        System.out.println(Arrays.toString(persons.toArray()));
    }

5、 JDOM解析XML

JDOM是两位著名的 Java 开发人员兼作者， Brett Mclaughlin 和 Jason Hunter 的创作成果，2000 年初在类似于Apache协议的许可下， JDOM作为一个开放源代码项目正式开始研发了。

JDOM 简化了与 XML 的交互并且比使用 DOM 实现更快， JDOM 与 DOM 主要有两方面不同。首先， JDOM 仅使用具体类而不使用接口。这在某些方面简化了 API，但是也限制了灵活性。第二， API 大量使用了 Collections 类，简化了那些已经熟悉这些类的 Java开发者的使用。

下载地址：
http://www.jdom.org/downloads/index.html

解析步骤：
（1） SAXBuilder sax = new SAXBuilder();
（2） Document doc = sax.build(….);
（3） Element el = doc.getRootElement();
（4） List list = el.getChildren();
（5）遍历内容

/**
     * JDOM解析 XML
     * 1、与DOM类似基于树型结构，
     * 2、与DOM的区别：
     * （1）第三方开源的组件
     * （2）实现使用JAVA的Collection接口
     * （3）效率比DOM更快
     */
    @Test
    public void jdomParseXML() throws JDOMException, IOException {
        //创建JDOM解析器
        SAXBuilder builder = new SAXBuilder();
        InputStream is = Thread.currentThread().getContextClassLoader()
                .getResourceAsStream("com/vince/xml/person.xml");
        org.jdom2.Document build = builder.build(is);
        Element rootElement = build.getRootElement();
        List<Person> list = new ArrayList<>();
        Person person = null;
        List<Element> children = rootElement.getChildren();
        for(Element element: children){
            person = new Person();
            String personid = element.getAttributeValue("personid");
            person.setPersonid(personid);
            List<Element> children1 = element.getChildren();
            for (Element e: children1){
                String tag = e.getName();
                if("name".equals(tag)){
                    person.setName(e.getText());
                }else if("address".equals(tag)){
                    person.setAddress(e.getText());
                }else if("tel".equals(tag)){
                    person.setTel(e.getText());
                }else if("fax".equals(tag)){
                    person.setFax(e.getText());
                }else if("email".equals(tag)){
                    person.setEmail(e.getText());
                }
            }
            list.add(person);
        }
        System.out.println("结果：");
        System.out.println(Arrays.toString(list.toArray()));
    }

6、 DOM4J解析XML

dom4j是一个非常非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件，可以在SourceForge上找到它。在对主流的Java XML API进行的性能、功能和易用性的评测， dom4j无论在那个方面都是非常出色的。如今你可以看到越来越多的Java软件都在使用dom4j来读写XML，特别值得一提的是连Sun的JAXM也在用dom4j。这是必须使用的jar包， Hibernate用它来读写配置文件。

下载地址：
https://dom4j.github.io/

解析步骤：
（1） SAXReader sax = new SAXReader();
（2） Document doc = sax.read(Thread.currentThread().getContextClassLoader().getResourceAsStream(“person.xml”));
（3） Element root = doc.getRootElement();
（4） Iterator iterator = root.elementIterator();
（5）遍历迭代器

/**
     * DOM4J解析XML
     * 基于树型结构，第三方组件
     * 解析速度快，效率更高，使用的JAVA中的迭代器实现数据读取，在WEB框架中使用较多（Hibernate)
     *
     */
    @Test
    public void dom4jParseXML() throws DocumentException {
        //1 创建DOM4J的解析器对象
        SAXReader reader = new SAXReader();
        InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("com/vince/xml/person.xml");
        org.dom4j.Document doc = reader.read(is);
        org.dom4j.Element rootElement = doc.getRootElement();
        Iterator<org.dom4j.Element> iterator = rootElement.elementIterator();
        ArrayList<Person> persons = new ArrayList<>();
        Person p = null;
        while(iterator.hasNext()){
            p = new Person();
            org.dom4j.Element e = iterator.next();
            p.setPersonid(e.attributeValue("personid"));
            Iterator<org.dom4j.Element> iterator1 = e.elementIterator();
            while(iterator1.hasNext()){
                org.dom4j.Element next = iterator1.next();
                String tag = next.getName();
                if("name".equals(tag)){
                    p.setName(next.getText());
                }else if("address".equals(tag)){
                    p.setAddress(next.getText());
                }else if("tel".equals(tag)){
                    p.setTel(next.getText());
                }else if("fax".equals(tag)){
                    p.setFax(next.getText());
                }else if("email".equals(tag)){
                    p.setEmail(next.getText());
                }
            }
            persons.add(p);
        }
        System.out.println("结果：");
        System.out.println(Arrays.toString(persons.toArray()));
    }

7、通过对象生成XML文件

.
使用Java提供的java.beans.XMLEncoder和java.beans.XMLDecoder类。
这是JDK 1.4以后才出现的类
步骤：
（1）实例化XML编码器
XMLEncoder xmlEncoder = new XMLEncoder(new BufferedOutputStream(newFileOutputStream(new File(“a.xml”))));
（2）输出对象
（3）关闭

/**
     * 从XML文件中读取对象
     */
    @Test
    public void xmlDecoder() throws FileNotFoundException {
        BufferedInputStream in = new BufferedInputStream(new FileInputStream("test.xml"));
        XMLDecoder decoder = new XMLDecoder(in);
        Person p = (Person)decoder.readObject();
        System.out.println(p);
    }
    /**
     * 把对象转成XML文件写入
     */
    @Test
    public void xmlEncoder() throws FileNotFoundException {
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("test.xml"));
        XMLEncoder xmlEncoder = new XMLEncoder(bos);
        Person p = new Person();
        p.setPersonid("1212");
        p.setAddress("北京");
        p.setEmail("vince@163.com");
        p.setFax("6768789798");
        p.setTel("13838389438");
        p.setName("38");
        xmlEncoder.writeObject(p);
        xmlEncoder.close();
    }

<?xml version="1.0" encoding="UTF-8"?>
<java version="1.8.0_77" class="java.beans.XMLDecoder">
 <object class="com.vince.xml.Person">
  <void property="address">
   <string>北京</string>
  </void>
  <void property="email">
   <string>vince@163.com</string>
  </void>
  <void property="fax">
   <string>6768789798</string>
  </void>
  <void property="name">
   <string>38</string>
  </void>
  <void property="personid">
   <string>1212</string>
  </void>
  <void property="tel">
   <string>13838389438</string>
  </void>
 </object>
</java>

8、各种解析方法比较

JDOM 和 DOM 在性能测试时表现不佳，在测试 10M 文档时内存溢出。

SAX表现较好，这要依赖于它特定的解析方式。一个 SAX 检测即将到来的XML流，但并没有载入到内存（当然当XML流被读入时，会有部分文档暂时隐藏在内存中）。

DOM4J是这场测试的获胜者，目前许多开源项目中大量采用 DOM4J，例如大名鼎鼎的Hibernate 也用 DOM4J 来读取 XML 配置文件。

xstream 实现XML的转换

/**
     * 使用第三方xstream组件实现XML的解析与生成
     */
    @Test
    public void xStream(){
        Person p = new Person();
        p.setPersonid("1212");
        p.setAddress("北京");
        p.setEmail("vince@163.com");
        p.setFax("6768789798");
        p.setTel("13838389438");
        p.setName("38");
        XStream xStream = new XStream(new Xpp3Driver());
        xStream.alias("person",Person.class);
        xStream.useAttributeFor(Person.class,"personid");
        String xml = xStream.toXML(p);
        System.out.println(xml);
        //解析XML
        Person person = (Person)xStream.fromXML(xml);
        System.out.println(person);
    }

17、XML与Json - 图1

9、Json

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。 JSON 官方:http://www.json.org
JSON 数据格式的特点

JSON 建构于两种结构：
1、 “ 名称/值” 对的集合
2.、值的有序列表（数组）

JSON 表示名称 / 值对的方式：

{ "firstName": "vince", "lastName":"ma", "email":"finally_m@foxmail.com" }

表示数组

{ "user": [{ "firstName": "vince", "lastName":"ma", "email": "finally_m@foxmail.com" },{ "firstName": "lin", "lastName":"jacks", "email":“ jacks@qq.com” }]}

10、 GSON组件的使用

GSON是Google开发的Java API，用于转换Java对象和Json对象。

下载地址： http://www.mvnrepository.com/artifact/com.google.code.gson/gson

解析JSON： JsonReader reader = new JsonReader(new StringReader(jsonData));

生成JSON：

private String createJSON(ArrayList<User> users) {
    JSONObject jsonObject = new JSONObject();JSONArray array = new JSONArray();
    int size = users.size();
    try {
        for (int i = 0; i < size; i++) {
            User user = users.get(i); JSONObject object = new JSONObject();
            object.put("name", user.name);object.put("age", user.age);array.put(object);
        }
        jsonObject.put("users",array);
        return jsonObject.toString();
    } catch (JSONException e) {
        e.printStackTrace();
    }
    return null;
}
static class User {String name; int age;//…}

JsonDemo1

package com.vince.json;
import com.google.gson.stream.JsonReader;
import org.junit.Test;
import javax.print.attribute.standard.MediaSize;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
/**
 * Created by vince on 2017/7/1.
 */
public class JSONDemo {
    /**
     * 解析一个JSON数组
     */
    @Test
    public void parseJSONNames(){
        InputStream is = Thread.currentThread().getContextClassLoader()
                .getResourceAsStream("com/vince/json/names.json");
        InputStreamReader in = new InputStreamReader(is);
        //JSON的解析工具（解析器）
        JsonReader reader = new JsonReader(in);
        ArrayList<Name> list = new ArrayList<>();
        try {
            //开始解析数组
            reader.beginArray();
            while(reader.hasNext()){
                list.add(parseName(reader));
            }
            //结束解析数组
            reader.endArray();
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println(Arrays.toString(list.toArray()));
    }
    //解析对象 Name
    private Name parseName(JsonReader jsonReader){
        Name name = null;
        try {
            //开始解析对象
            jsonReader.beginObject();
            name = new Name();
            while (jsonReader.hasNext()){
                String attrName = jsonReader.nextName();
                if("firstName".equals(attrName)){
                    name.setFirstName(jsonReader.nextString());
                }else if("lastName".equals(attrName)){
                    name.setLastName(jsonReader.nextString());
                }else if("email".equals(attrName)){
                    name.setEmail(jsonReader.nextString());
                }
            }
            //结束解析对象
            jsonReader.endObject();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return name;
    }
}

Names.json

[
  {"firstName":"Vince","lastName":"Ma","email":"1791705739@qq.com"},
  {"firstName":"Jason","lastName":"Hunter","email":"jason@google.com"}
]

比较复杂的一个例子：

message.json

[
  {
    "id": 912345678901,
    "text": "How do I read a JSON stream in Java?",
    "geo": null,
    "user": {
      "name": "json_newb",
      "followers_count": 41
    }
  },
  {
    "id": 912345678902,
    "text": "@json_newb just use JsonReader!",
    "geo": [50.454722, -104.606667],
    "user": {
      "name": "jesse",
      "followers_count": 2
    }
  }
]

JsonDemo2

方法虽多，但一层套一层，结构思路清晰

package com.vince.json;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonToken;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
/**
 * Created by vince on 2017/7/1.
 */
public class JsonDemo2 {
    /**
     * 使用JsonReader解析复杂的JSON数据
     */
    @Test
    public void parseJSONMessages(){
        InputStream is = Thread.currentThread().getContextClassLoader()
                .getResourceAsStream("com/vince/json/message.json");
        InputStreamReader in = new InputStreamReader(is);
        JsonReader jsonReader = new JsonReader(in);
        ArrayList<Message> list = readMessageArray(jsonReader);
        for (Message m: list){
            System.out.println(m);
        }
    }
    //读取Message数组
    private ArrayList<Message> readMessageArray(JsonReader jsonReader) {
        ArrayList<Message> list = new ArrayList<>();
        try {
            jsonReader.beginArray();
            while(jsonReader.hasNext()){
                list.add(readMessage(jsonReader));
            }
            jsonReader.endArray();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return list;
    }
    //解析一个Message对象
    private Message readMessage(JsonReader jsonReader) {
        Message m = new Message();
        try {
            jsonReader.beginObject();
            while (jsonReader.hasNext()){
                String name = jsonReader.nextName();
                if("id".equals(name)){
                    m.setId(jsonReader.nextLong());
                }else if("text".equals(name)){
                    m.setText(jsonReader.nextString());
                }else if("geo".equals(name) && jsonReader.peek()!= JsonToken.NULL){
                    m.setGeo(readGeo(jsonReader));
                }else if("user".equals(name)){
                    m.setUser(readUser(jsonReader));
                }else{
                    jsonReader.skipValue();
                }
            }
            jsonReader.endObject();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return m;
    }
    /**
     * 解析User对象
     * @param jsonReader
     * @return
     */
    private User readUser(JsonReader jsonReader) {
        User user = new User();
        try {
            jsonReader.beginObject();
            while (jsonReader.hasNext()){
                String name = jsonReader.nextName();
                if("name".equals(name)){
                    user.setName(jsonReader.nextString());
                }else if("followers_count".equals(name)){
                    user.setFollowers_count(jsonReader.nextInt());
                }else{
                    jsonReader.skipValue();
                }
            }
            jsonReader.endObject();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return user;
    }
    /**
     * 解析GEO
     * @param jsonReader
     * @return
     */
    private ArrayList<Double> readGeo(JsonReader jsonReader) {
        ArrayList<Double> list = new ArrayList<>();
        try {
            jsonReader.beginArray();
            while (jsonReader.hasNext()){
                list.add(jsonReader.nextDouble());
            }
            jsonReader.endArray();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return list;
    }
}

使用 Gson 直接把 JSON 数据转换成 Java

public Student parserJSON2(String data){
    Gson gson = new Gson();
    Student s = gson.fromJson(data, Student.class);
    return s;
}

使用 Gson 直接把 JSON 数组转换成 Java 对象

public List<Student> parserJSON3(String data){
    Type type = new TypeToken<ArrayList<Student>>(){}.getType();
    Gson gson = new Gson();
    List<Student> list = gson.fromJson(data, type);
    return list;
}

package com.vince.json;
import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.reflect.TypeToken;
import com.google.gson.stream.JsonToken;
import org.junit.Test;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;
/**
 * Created by vince on 2017/7/1.
 */
public class JsonDemo3 {
    /**
     * 把一组JSON对象转换成一个JAVA对象集合，或者把一个JAVA对象集合转换成JSON数组
     */
    @Test
    public void gson2(){
        Gson gson = new Gson();
        InputStream is = Thread.currentThread().getContextClassLoader()
                .getResourceAsStream("com/vince/json/names.json");
        InputStreamReader in = new InputStreamReader(is);
        TypeToken<List<Name>> typeToken = new TypeToken<List<Name>>(){};
        List<Name> list = gson.fromJson(in, typeToken.getType());
        System.out.println(list);
        String json = gson.toJson(list, typeToken.getType());
        System.out.println(json);
    }
    class MyTypeToken extends TypeToken<List<Name>>{}
    /**
     * 把一个JSON对象转换成JAVA对象，或把一个JAVA对象转换成JSON对象
     */
    @Test
    public void gson1(){
        Gson gson = new Gson();
        InputStream is = Thread.currentThread().getContextClassLoader()
                .getResourceAsStream("com/vince/json/name.json");
        InputStreamReader in = new InputStreamReader(is);
        Name name = gson.fromJson(in, Name.class);
        System.out.println(name);
        String json = gson.toJson(name);
        System.out.println(json);
    }
    @Test
    public void createJSON(){
        List<Name> list = new ArrayList<>();
        list.add(new Name("vince","ma","1791705739@qq.com"));
        list.add(new Name("jack","wang","jack@qq.com"));
        JsonArray array = new JsonArray();
        for (Name n: list){
            JsonObject obj = new JsonObject();
            obj.addProperty("firstName",n.getFirstName());
            obj.addProperty("lastName",n.getLastName());
            obj.addProperty("email",n.getEmail());
            array.add(obj);
        }
        System.out.println(array.toString());
    }
}

{"firstName":"Vince","lastName":"Ma","email":"1791705739@qq.com"}

11、 XML与JSON的比较

从以下6点比较JSON与XML：
1、 JSON和XML的数据可读性基本相同
2、 JSON和XML同样拥有丰富的解析手段
3、 JSON相对于XML来讲，数据的体积小
4、 JSON与JavaScript的交互更加方便
5、 JSON对数据的描述性比XML较差
6、 JSON的速度要远远快于XML

适合的场景：
（1）数据传输： JSON要比XML更有优势
（2）存储数据： XML描述性更强
（3） XML通常用做配置文件（WEB课程中会有详细介绍）

1、 什么是XML