java高级_04

一 XML文件
   XML ---可扩展标记语言
   XML文件
   1 存储数据:简单灵活
   2 数据传输:平台无关
   3 配置文件:可读性强
    
   标签:<product>开始标签 </product>结束标签 标签都是成对出现
   属性:包含在开始标签中的属性名=“属性值”
   文本:包含在开始标签和结束标签之间的文本内容
二 解析XML文件
   1 DOM
     DOM:Document Object Model,即文档对象模型
     DOM把XML文映射成一个倒挂的树
     使用DOM解析XML文档的步骤:
     1.1 创建解析器工厂对象
         DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
     1.2 由解析器工厂对象创建解析器对象
         DocumentBuilder db = dbf.newDocumentBuilder();
     1.3 由解析器对象对指定XML文件进行解析,构建相应DOM树,创建Document对象
         Document document = db.parse("E:\\products.xml");
     1.4 以Document对象为起点对DOM树的节点进行增删改查操作。
         节点Node:在树中标签,属性,文本都是节点
         元素Element:元素就是标签节点
         属性Attr:属性就是属性节点
         文本Text:文本节点

//1 获取树中的根元素(products)
        Element root = document.getDocumentElement();
        //2 根元素的子元素
        NodeList ps = root.getElementsByTagName("product");//获取当前元素的叫做product的所有子元素
        //3 循环处理所有product子元素
        for(int i=0;i<ps.getLength();i++)
        {
            //获取集合中的一个元素
            Element p = (Element)ps.item(i);
            //获取当前节点的所欲子节点
            NodeList list = p.getChildNodes();
            //循环处理product中的所有子节点
            for(int j=0;j<list.getLength();j++)
            {
                //获取一个子节点
                Node node = list.item(j);
                //获取节点名和节点文本内容
                if(!node.getNodeName().startsWith("#"))
                    System.out.println("节点名:" + node.getNodeName() + ",节点文本内容:" + node.getTextContent());
            }
        }
         
   2 SAX
     
     事件驱动机制:当某一个事件发生时,会自动调用事件处理器中处理这种事件的方法

SAX解析器不像DOM那样建立一个完整的文档树,而是在读取文档时激活一系列事件,事件处理器提供对这些事件进行处理的方法

1.1 创建解析器工厂对象
       SAXParserFactory sFactory = SAXParserFactory.newInstance();
     1.2 由解析器工厂对象创建解析器对象
       SAXParser sp =  sFactory.newSAXParser();
     1.3 由解析器对象对指定XML文件进行解析
           //3 解析(提供事件处理器)
       MyHandler myHandler = new MyHandler();
       sp.parse("E:\\products.xml",myHandler);
     1.4 重写事件处理器中的方法对数据进行处理
         事件处理类继承自DefaultHandler
         然后重写事件处理中关注的事件对应的方法

//如果是一个标签的开始,就自动调用这个方法,qName是标签名
    @Override
    public void startElement(String uri, String localName, String qName,
            Attributes attributes) throws SAXException {
    }
    
    //如果是文本内容,就自动调用这个方法,而且字符数组ch中存储的就是这个文本内容
    @Override
    public void characters(char[] ch, int start, int length)
            throws SAXException {
    }
    
    //如果是一个标签的结束,就自动调用这个方法,qName是标签名
    @Override
    public void endElement(String uri, String localName, String qName)
            throws SAXException {
    }

下边两种方式需要导入jar包
   3 JDOM
     1 解析器
     SAXBuilder sBuilder = new SAXBuilder();
     2 解析
    Document document = sBuilder.build("E:\\products.xml");
        
     3 从document中获取需要的数据
    Element root = document.getRootElement();//获取根元素
        getChild(String name)//获取叫做name的那一个子元素
        getChildren()//获取所有的子元素
        getChildren(String name)//获取所有叫做name的子元素

getChildText(String name)//直接获取叫做name的那一个子元素的文本内容

4 DOM4J
            1 解析器
        SAXReader sr = new SAXReader();
        2 解析
        Document document = sr.read("E:\\products.xml");
        
        3 从document中获取需要的数据
        Element root = document.getRootElement();//products
        
        获取root下的product子元素构成的集合的迭代器
        Iterator<Element> it = root.elementIterator("product");
    
            Element element = it.next();
            //获取element下的所有子元素组成的集合的迭代器
            Iterator<Element> iterator = element.elementIterator();

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;

public class TestDOM {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            (new DomXML()).parse();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

class DomXML
{
    //用DOM方式解析XML文件
    public void parse() throws Exception
    {
        //1 解析器工厂
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        //2 解析器
        DocumentBuilder db = dbf.newDocumentBuilder();
        //3 解析
        Document document = db.parse("E:\\products.xml");
        //4 把倒挂的树中的有效数据拿出来
        
        //1 获取树中的根元素(products)
        Element root = document.getDocumentElement();
        //2 根元素的子元素
        NodeList ps = root.getElementsByTagName("product");//获取当前元素的叫做product的所有子元素
        //3 循环处理所有product子元素
        for(int i=0;i<ps.getLength();i++)
        {
            //获取集合中的一个元素
            Element p = (Element)ps.item(i);
            //获取当前节点的所欲子节点
            NodeList list = p.getChildNodes();
            //循环处理product中的所有子节点
            for(int j=0;j<list.getLength();j++)
            {
                //获取一个子节点
                Node node = list.item(j);
                //获取节点名和节点文本内容
                if(!node.getNodeName().startsWith("#"))
                    System.out.println("节点名:" + node.getNodeName() + ",节点文本内容:" + node.getTextContent());
            }
        }
    }
}
import java.util.Iterator;
import java.util.List;

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

public class TestDOM4J {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            DOM4JXML.parse();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

class DOM4JXML
{
    public static void parse() throws Exception
    {
        //1 解析器
        SAXReader sr = new SAXReader();
        //2 解析
        Document document = sr.read("E:\\products.xml");
        
        //3 从document中获取需要的数据
        Element root = document.getRootElement();//products
        
        //获取root下的子元素构成的集合的迭代器
        Iterator<Element> it = root.elementIterator("product");
        
        while(it.hasNext())
        {
            Element element = it.next();//product
            Iterator<Element> iterator = element.elementIterator();
            
            while(iterator.hasNext())
            {
                Element element2 = iterator.next();
                System.out.println(element2.getName() + "," + element2.getText());
            }
        }
    }
}
import java.util.Iterator;
import java.util.List;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;

public class TestJDOM {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            JDOMXML.parse();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

class JDOMXML
{
    public static void parse() throws Exception
    {
        //1 解析器
        SAXBuilder sBuilder = new SAXBuilder();
        //2 解析
        Document document = sBuilder.build("E:\\products.xml");
        
        //3 从document中获取需要的数据
        Element root = document.getRootElement();//products
        
        //root下的子元素
        List list = root.getChildren("product");
        Iterator<Element> it = list.iterator();
        while(it.hasNext())
        {
            Element element = it.next();//product
            /*
            //product才的所有子元素
            List lt = element.getChildren();
            Iterator<Element> iterator = lt.iterator();
            while(iterator.hasNext())
            {
                Element element2 = iterator.next();
                System.out.println(element2.getName() + "," + element2.getText());
            }*/
            
            System.out.println("id = " + element.getChildText("productid"));
            System.out.println("name = " + element.getChildText("product_name"));
            System.out.println("price = " + element.getChildText("price"));
            System.out.println("num = " + element.getChildText("num"));
            System.out.println("time = " + element.getChildText("publish_time"));
        }
    }
}
import java.util.ArrayList;
import java.util.Iterator;

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

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class TestSAX {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            SAXXML.parse();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

class SAXXML
{
    public static void parse() throws Exception, SAXException
    {
        //1 解析器工厂
        SAXParserFactory sFactory = SAXParserFactory.newInstance();
        //2 解析器
        SAXParser sp =  sFactory.newSAXParser();
        //3 解析(提供事件处理器)
        MyHandler myHandler = new MyHandler(); 
        sp.parse("E:\\products.xml",myHandler);
        //获取解析出的所有产品并打印
        ArrayList<Product> list = myHandler.getList();
        Iterator<Product> iterator = list.iterator();
        while(iterator.hasNext())
        {
            System.out.println(iterator.next());
        }
    }
}

//事件处理器类
class MyHandler extends DefaultHandler
{
    private ArrayList<Product> list = new ArrayList<Product>();//存储解析出来的所有产品数据
    private Product product;//存一个产品信息
    private String tag;//存储标签名
    
    public ArrayList<Product> getList() {
        return list;
    }
    
    //如果是一个标签的开始,就自动调用这个方法,qName是标签名
    @Override
    public void startElement(String uri, String localName, String qName,
            Attributes attributes) throws SAXException {
        // TODO Auto-generated method stub
        //System.out.println(qName + "开始");
        tag = qName;//保存标签名
        if(tag.equals("product"))
            product = new Product();//存储接下来要解析出的产品信息
    }
    
    //如果是文本内容,就自动调用这个方法,而且字符数组ch中存储的就是这个文本内容
    @Override
    public void characters(char[] ch, int start, int length)
            throws SAXException {
        // TODO Auto-generated method stub
        //System.out.println("内容:" + new String(ch,start,length));
        String data = new String(ch,start,length).trim();
        if(!data.equals(""))
        {
            if(tag.equals("productid"))
                product.setId(Integer.parseInt(data));
            if(tag.equals("product_name"))
                product.setName(data);
            if(tag.equals("price"))
                product.setPrice(Integer.parseInt(data));
            if(tag.equals("num"))
                product.setNum(Integer.parseInt(data));
            if(tag.equals("publish_time"))
                product.setTime(data);
        }    
    }
    
    //如果是一个标签的结束,就自动调用这个方法,qName是标签名
    @Override
    public void endElement(String uri, String localName, String qName)
            throws SAXException {
        // TODO Auto-generated method stub
        //System.out.println(qName + "结束");
        tag = qName;
        if(tag.equals("product"))
            list.add(product);    //把解析出来的这个产品信息添加到集合
    }
}

class Product
{
    private int id;
    private String name;
    private int price;
    private int num;
    private String time;
    
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }
    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }
    public String getTime() {
        return time;
    }
    public void setTime(String time) {
        this.time = time;
    }
    
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return id + name + price + num + time;
    }

}
<?xml version="1.0" encoding="UTF-8"?>
<products>
   <product>
      <productid>1</productid>
      <product_name>电脑500</product_name>
      <price>5000</price>
      <num>1000</num>
      <publish_time>2012-01-01</publish_time>
   </product>
   <product>
      <productid>2</productid>
      <product_name>TCL智能家电</product_name>
      <price>5000</price>
      <num>1000</num>
      <publish_time>2012-01-01</publish_time>
   </product>
</products>
时间: 2024-11-10 08:09:04

java高级_04的相关文章

java高级编程的教程

java高级编程说的就是编程思想,在学习完Java基础以后就是编程的,推荐可以去看看<Java编程思想>这本书籍,还不错. Java已经成为了编程语言的骄子.我们可以看到,越来越多的大学在教授数据结构.程序设计和算法分析等课程时,选择以Java语言为载体.这本赢得了全球程序员的广泛赞誉,即使是最晦涩的概念,在Bruce Eckel的文字亲和力和小而直接的编程示例面前也会化解于无形. 这本书赢得了全球程序员的广泛赞誉,即使是最晦涩的概念,在Bruce Eckel的文字亲和力和小而直接的编程示例面

Java高级复习㈠ 多线程

1.线程 也称为轻量级进程,每个线程有自己的堆栈.程序计数器.局部变量.与进程相比,进程中的线程之间隔离程度要小 2.Java实现 ①implements Runnable ②extends Thread 一般推荐① 3.sleep().yield() sleep()方法对当前线程操作,指定以毫秒为单位的线程最小休眠时间,除非线程因中断提早恢复执行,否则不会在这段时间前恢复执行.线程可调用另一线程的interrupt()方法,向暂停的线程发出InterruptedException,变相唤醒暂停

Java高级程序设计第三版:基本概念

严格模式 ? 1 2 3 4 5 6 function fun(){   "use strict";  //启用严格模式,作用域函数  }   "use strict";  //全局 变量 变量定义需要用var,如果没有通过var定义的变量会由于相应变量不会马上有定义而导致不必要的混乱. 数据类型 5种基本数据类型:Undefined.Null.Boolean.NUmber.String 1种复杂数据类型:Object typeof 对未初始化的和未声明的变量执行t

Java高级规范之四

四十一.控制层不能调用model层除了最顶级的接口外的任何内容.要通过new顶级接口才能调用. 不规范示例: public class UserServiceImpl{ private UserDAOImpl userDAOImpl; private UserServiceImpl(){ userDAOImpl = new UserDAOImpl(); } public void deleteById(Long id){ userDAOImpl.deleteById(id); } } 规范示例:

Java高级规范之三

三十一.如果变量名要加注释,说明命名不是很准确. 不规范示例:暂无 规范实例:暂无 解析:暂无 三十二.任何类字段除非必要,否则都要私有化 不规范示例: public class Person{ String name; String sex; int age; } 规范示例: public class ClassName{ private String name; private String sex; private int age; } 解析:没有为程序的安全考虑,可以被其他的类访问 三十

2017最新技术java高级架构、千万高并发、分布式集群、架构师入门到精通视频教程

* { font-family: "Microsoft YaHei" !important } h1 { color: #FF0 } 15套java架构师.集群.高可用.高可扩 展.高性能.高并发.性能优化.Spring boot.Redis.ActiveMQ.Nginx.Mycat.Netty.Jvm大型分布 式项目实战视频教程 视频课程包含: 高级Java架构师包含:Spring boot.Spring  cloud.Dubbo.Redis.ActiveMQ.Nginx.Mycat

java高级之反射

--- android培训.java培训.期待与您交流! ---- java高级之反射 一 反射(类的加载概述和加载时机) A:类的加载概述 当程序要使用某个类时,如果该类还未被加载到内存中,则系统会通过加载,连接,初始化三步来实现对这个类进行初始化. 加载 就是指将class文件读入内存,并为之创建一个Class对象.任何类被使用时系统都会建立一个Class对象. 连接 验证 是否有正确的内部结构,并和其他类协调一致 准备 负责为类的静态成员分配内存,并设置默认初始化值 解析 将类的二进制数据

java高级值类反射

 类反射 类反射,这是属于java高级的技术了,如果把这个学好了,那么你的java学习之路就上了一个台阶了. 一.什么是类反射? 1.JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调           用它的任意一个方法和属性:这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制. 2.反射(Reflection)是Java程序开发语言的特征之一,它允许运行中的Java程序对自身进行检查, 也称自审,并能直接操作

Java高级应用(一)-文件目录监控服务

最近,在研究一些比较成熟的框架,这其中也发现了一些比较不错的文章,现给大家简单翻译其中的一部分(强烈建议大家看一些原版的英文文章,很有帮助). 译:原文链接 你有没有发现,当你编辑一个文件,同时使用另一个IDE或编辑器进行编辑的时候,会出现一个对话框通知"一个打开的文件的已经改变,是否需要重新加载?".但像NetBeans IDE等一些应用程序只是静静地更新文件而没有通知你. 要实现这种"文件监控"功能,程序必须能够检测到在文件系统相关的目录中发生了什么.一种方法是