java学习----数据解析

　　1、何为数据解析

　　2、xml解析

　　3、Excel解析

　　4、json解析

一、何为数据解析

　　举个栗子----如果不同的程序之间需要通信，假如说A程序需要B程序做一件事，B程序说

我可以做这件事，但是需要给我必须的数据。我才能做这件事。

我们可以用下面一副图表示：

java学习----数据解析

在上面这幅图中，两个数据的传输都是有数据格式的。我们要做的就是解析这种数据格式或者生成这种数据格式的数据

二、XML解析

　　首先我们先认识一下xml数据：

可扩展标记语言（英语：Extensible Markup Language，简称：XML），是一种标记语言。标记指计算机所能理解的信息符号，通过此种标记，计算机之间可以处理包含各种信息的文章等。　　　　　　　　-----by wiki

　　接下来我们看一个XML数据吧

<?xml version="1.0" encoding="UTF-8"?>
<Students>
    <Student>
        <name java="初级">张三</name>
        <age>14</age>
        <fav>烫头</fav>
    </Student>
    <Student>
        <name java="高级">李四</name>
        <age>16</age>
        <fav>玩游戏</fav>
    </Student>
</Students>

　　我们可以看到xml数据的格式，xml数据的第一行写的是xml版本号和字符编码集

　　它下面的字标签都是成对出现的，这个xml可以表示两个对象。

　　在Java中xml解析的常见方式大致可以分为以下几个

　　1、DOM解析----文本对象模型（Document Object Model） w3c标准

　　2、SAX解析---- 基于事务驱动的解析

　　3、JAXP SAX和DOM结合

　　4、JDOM 第三方开源项目 jdom-*.jar

　　5、DOM4J 第三方开源项目 dom4j-*.jar

在此，我们主要讲解一下java内置的SAX解析和DOM解析

　　1.DOM解析

　　原理：将整个xml文档看成一颗树，会将整个文档一次性读入内存中（适合于小型xml文件解析）

　　首先我们先要了解以下DOM解析里的一些名词

　　Document对象：文档对象 extends Node
　　Node对象：节点对象，所有节点类型的父接口包含元素/标签、属性、文本、注释
　　Element：元素/标签(extends Node)
　　Attr：属性节点(extends Node)
　　Text：文本节点(extends Node)

ps：除文档对象之外，其他的都是节点对象

　　为了更形象的解释一下，请看如下图：

　　 java学习----数据解析

XML解析的步骤大致可分为：

　　1、构建器工厂
　　2、构建器
　　3、xml文件-》document对象
　　4、节点内容解析

package com.demo.udp;

import java.io.File;
import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class DomParse {
    
    public static void parseXml(String xmlfile){
        //创建一个document工厂实例
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        Document doc = null;
        try {
            //有document工厂实例构建一个documentBuilder对象
            DocumentBuilder builder = factory.newDocumentBuilder();
            //解析整个xml文件构建成一个Document对象
             doc = builder.parse(new File(xmlfile));
        } catch (ParserConfigurationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SAXException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        //获取Document对象的根节点---->Students
        Element root = doc.getDocumentElement();
        //根节点下找到所有的Student节点--->Student    ps：这里的NodeList不是集合，不能foreach遍历
        NodeList elelist = root.getElementsByTagName("Student");
        for(int i =0 ;i<elelist.getLength();i++){            
            Node stunode = elelist.item(i);
            //由于Node里面没有getElementsByTagName方法，所以只能通过向下强转成Element才能找到子节点
            if(stunode.getNodeType()==Node.ELEMENT_NODE){
                Element stuele = (Element)stunode;
                Node name = stuele.getElementsByTagName("name").item(0);
                System.out.println("name:"+name.getTextContent());
                
                //Node name2 = root.getElementsByTagName("name").item(i);
                //System.out.println(name2.getFirstChild().getNodeValue());
                Node java = name.getAttributes().getNamedItem("java");
                System.out.println("java:"+java.getNodeValue());
            }
        }
        
    }
    
    
    public static void main(String[] args) {
        parseXml("Students.xml");
    }
}

XML的生成大致可分为：

　　1、构建器工厂
　　2、构建器
　　3、构造一个空的document树-----数据结构为树。
　　4、构造节点对象（元素、属性、文本）
　　5、设定节点之间的关系
　　6、转换（doc对象-》xml文件）

　　　　6.1 转换器工厂

　　　　6.2 转换器对象
　　　　6.3 输入源 doc对象-》Source对象　输出源 xml文件-》Result对象
　　　　6.4 transform(Source对象,Result对象)

/**
     * 创建xml文件
     */
    public static void createXml(String xmlfile){
        //要写入的数据
        Student student = new Student("张三",18,"LOL","学习");
        Student student2 = new Student("李四", 19, "cs:go", "打游戏");
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); 
        Document doc = null;
        try {
            DocumentBuilder builder = factory.newDocumentBuilder();
            //创建document对象
            doc = builder.newDocument();
        } catch (ParserConfigurationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } 
        //创建根节点
        Element students = doc.createElement("Students");
        //创建元素节点
        Element stu1 = doc.createElement("Student");
        Element stu2 = doc.createElement("Student");
        Element name1 = doc.createElement("name");
        Element name2 = doc.createElement("name");
        Element age1 = doc.createElement("age");
        Element age2 = doc.createElement("age");
        Element fav1 = doc.createElement("fav");
        Element fav2 = doc.createElement("fav");
        
        
        //设置节点的关系，构建成一颗树
        doc.appendChild(students);
        students.appendChild(stu1);
        students.appendChild(stu2);
        stu1.appendChild(name1);
        stu1.appendChild(age1);
        stu1.appendChild(fav1);
        
        stu2.appendChild(name2);
        stu2.appendChild(age2);
        stu2.appendChild(fav2);
        
        //给属性节点与文本节点赋值
        name1.setAttribute("java", student.getAlivable());
        name2.setAttribute("java", student2.getAlivable());
        
        name1.setTextContent(student.getName());
        age1.setTextContent(student.getAge()+"");
        fav1.setTextContent(student.getFav());
        name2.setTextContent(student2.getName());
        age2.setTextContent(student2.getAge()+"");
        fav2.setTextContent(student2.getFav());
        //讲构建好的dom树转换成xml文件
        transform(doc,xmlfile);
        System.out.println("XML生成完毕！");
    }
    /**
     * 树转换方法
     * @param doc
     * @param filename
     */
    private static void transform(Document doc,String filename){
        //构建转换工厂
        TransformerFactory factory = TransformerFactory.newInstance();
        try {
            //创建转换器对象
            Transformer transformer = factory.newTransformer();
            Source sourse = new DOMSource(doc);
            Result result = new StreamResult(new File(filename));
            transformer.transform(sourse, result);
        } catch (TransformerConfigurationException e) {
            e.printStackTrace();
        } catch (TransformerException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }

生成的新xml文件格式如下：

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<Students>
    <Student>
        <name java="学习">张三</name>
        <age>18</age>
        <fav>LOL</fav>
    </Student>
    <Student>
        <name java="打游戏">李四</name>
        <age>19</age>
        <fav>cs:go</fav>
    </Student>
</Students>

　　2.SAX解析

　　前面我有提到SAX解析是一种基于数据事物驱动的解析，意思就是这个解析式被动式的。

它不会自己主动去解析xml文件，而是从上往下解析，遇到的xml文件是什么类型就执行相应的方法。

SAX解析中解析的规则需要是一个DefaultHandler的子类。这个子类中重写的方法则是解析规则。

　　 java学习----数据解析

下面就写一个实例来看看SAX解析的魅力吧：

package com.demo.udp;

import java.io.IOException;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.SAXException;

public class SAXParse {
    
    public static void start(String filePath){
        SAXParserFactory factory = SAXParserFactory.newInstance();
        try {
            SAXParser sax = factory.newSAXParser();
            sax.parse(filePath, new MySax());
        } catch (ParserConfigurationException | SAXException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
        start("Students.xml");
    }
}

构建SAX解析累