15/7/23/文件输入输出/DOM/SAX

最新推荐文章于 2015-08-12 20:17:05 发布

ForrestL

最新推荐文章于 2015-08-12 20:17:05 发布

阅读量455

点赞数

分类专栏： JAVA 文章标签： java

本文链接：https://blog.csdn.net/ForrestL/article/details/47027815

版权

JAVA 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

文件的输出与输入

XML的两种解析方法DOM和SAX

File类

1.File类用来进行文件的相关操作，它描述的是文件本身的属性
2.File类创建File的对象是可以用来获取磁盘文件的相关信息。
3.File类被封装爱Java.io包中
4.构造方法File（String pathname）

寻找文件

public static void main(String[] args) {
    ergoicFile("e://");
}
    public static void ergoicFile(String filePath){
        File file=new File(filePath);//定义一个File类的对象，File指向文件路径
//  File类中listFiles功能：返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件    
        File[] abstract01=file.listFiles();//遍历file指向的路劲的地方，将文件名放入files文件数组内
        for (int i = 0; i < abstract01.length; i++) {
//          System.out.println(files[i].getAbsolutePath());//打印文件路劲名称
            if (abstract01[i].isDirectory()) {//判断文件是否是文件夹
                ergoicFile(abstract01[i].getAbsolutePath());//递归，如果是文件夹就继续往下面找
            }else{
                if (abstract01[i].getName().endsWith(".txt")) {//如果有以.txt结尾的文件
                    System.out.println(abstract01[i].getAbsolutePath());//打印以.txt结尾的文件路径
                }
            }

        }
    }

文件的输出

public static void main(String[] args) {
     File file=new File("e:\\11.txt");
//   FileInputStream 从文件系统中的某个文件中获得输入字节，
//   通过打开一个到实际文件的连接来创建一个 FileInputStream
     FileInputStream in=null;
    try {
        in= new FileInputStream(file);
//  构建一个缓冲区域
        byte[]arry=new byte[1024];
//read方法是从此输入流中将1024个字节的数据读入arry数组中，返回读入数组中字节的总数
//  如果因为已经到达文件末尾而没有更多的数据，则返回 -1
        int i=in.read(arry);
        while(i!=-1){
//  将读入arry数组的中字节造型成为String输出0到i的字节
//  这样做的目的是为了防止到文件末尾以后因为不够1024个字节而导致第i个字节之后的字节同样被输出
            System.out.println(new String(arry, 0, i));
//继续读下一1024个字节知道i！=-1为止         
            i=in.read(arry);
        }
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }finally{//关闭数据流
        if (in!=null) {
            try {
                in.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

将指定字符写入文件中

public class Test04 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        String s=scanner.next();
        File file=new File("e:\\22.txt");
//  如果文件不存在就在该路径下创建一个新的名为22.txt的文件
        if(!file.exists()){
        try {
            file.createNewFile();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        }
        FileOutputStream out=null;
        try {
//      创建一个向指定对象表示的文件中写入数据的文件输出流
            out=new FileOutputStream(file);
//  String类中getBytes的功能是使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中
//  FileOutputStream.write是将指定字节数组的内写入文件输出流上
            out.write(s.getBytes());
//  FileOutputStream.flush刷新此输出流并强制写出所有缓冲的输出字节
            out.flush();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {//关闭输出流
            if(out!=null){
                try {
                    out.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }

    }

文件之间的复制

public static void main(String[] args) {
        fileCopy("e:\\111.txt", "e:\\12.txt");
    }
    public static void fileCopy(String path,String copy){
        File source=new File(path);
        if (!source.exists()) {
            System.out.println("指定路径不存在");
            return;
        }
        File file=new File(copy);
        if (!file.exists()) {
            try {
                file.createNewFile();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        try {
//  创建以指定路径为输入流的对象sourceIn  
//  创建以指定路径为输出流的对象fileOut       
            FileInputStream sourceIn=new FileInputStream(source);
            FileOutputStream fileOut=new FileOutputStream(file);
            byte []arry=new byte [1024];//设置缓冲区域
            int i=0;
            while(i!=-1){
                i=sourceIn.read(arry);
                if(i!=-1){
                fileOut.write(arry, 0, i);
                }
            }
//  按照顺序关闭文件
            sourceIn.close();
            fileOut.flush();
            fileOut.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

以默认字符集合默认缓冲的方式读取文件中内容

public static void main(String[] args) {
    File file=new File("e:\\12.txt");
    try {
//  创建一个以指定路径的文件作为输入流的对象in
        FileInputStream in=new FileInputStream(file);
//创建一个使用默认字符集的 reader
        InputStreamReader reader=new InputStreamReader(in);
//  创建一个使用默认大小输入缓冲区的缓冲字符输入流br
        BufferedReader br=new BufferedReader(reader);
//  BufferedReader.readLine读取一个文本行
        String s=br.readLine();
        while(s!=null){
            System.out.println(s);
            s=br.readLine();
        }
//  依次关闭文件
        br.close();
        reader.close();
        in.close();
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

}

以默认字符集合默认缓冲方式写入指定文件

    File file=new File("e:\\12.txt");//通过将给定路径名字符串转换为"抽象路径名"来创建一个新 File 实例
        try {
            FileOutputStream out=new FileOutputStream(file);//通过打开一个到实际文件的连接来创建一个 FileInputStream
            OutputStreamWriter writer=new OutputStreamWriter(out);//创建使用默认字符编码的 OutputStreamWriter。
            BufferedWriter bw=new BufferedWriter(writer);//创建一个使用默认大小输出缓冲区的缓冲字符输出流
            bw.write("你好");
            bw.newLine();
            bw.write("nihao");
            out.flush();//刷新该流的缓冲。
            writer.flush();//刷新该流的缓冲。
            bw.flush();//刷新该流的缓冲。
            out.close();
            writer.close();
            bw.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

打印文字到指定文件中

public static void main(String[] args) {
        File file=new File("e:\\12.txt");
        try {
            PrintStream ps=new PrintStream(file);//  创建具有指定文件且不带自动行刷新的新打印流。
            System.setOut(ps);//将打印出来的东西放到ps里面
            System.out.println("dasfjasf");
            System.out.println("quickly");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

创建XML文件

1.XML文档总是以XML声明开始
2.XML文档的主要部分是元素
3.元素由开始标签、元素内容和结束标签组成
4.元素内容可以包含子元素、字符数据等

DOM解析SML文档

public static void main(String[] args) {
    File file=new File("e:\\weather.txt");
//  DocumentBuilderFactory定义工厂 API，使应用程序能够从 XML 文档获取生成 DOM 对象树的解析器。
    DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();//使用当前配置的参数创建一个新的 DocumentBuilder 实例,返回新的 DocumentBuilder 实例
    try {
//  DocumentBuilder定义 API， 使其从 XML 文档获取 DOM 文档实例
        DocumentBuilder db=dbf.newDocumentBuilder();//newDocumentBuilder：使用当前配置的参数创建一个新的 DocumentBuilder 实例
//  Document 接口表示整个 HTML 或 XML 文档。从概念上讲，它是文档树的根，并提供对文档数据的基本访问。
        Document doc=db.parse(file);//parse方法：将给定文件的内容解析为一个 XML 文档，并且返回一个新的 DOM Document 对象
        NodeList weathers=doc.getElementsByTagName("Weather");//按文档顺序返回包含在文档中且具有给定标记名称的所有 Element 的 NodeList
        for (int i = 0; i < weathers.getLength(); i++) {
            Node weather=weathers.item(i);//得到第一个节点
//  包含此节点的属性的 NamedNodeMap（如果它是 Element）；否则为 null。 
            NamedNodeMap map=weather.getAttributes();
            System.out.println("111"+map.getNamedItem("name").getNodeValue());
//          getFirstChild作用是此节点的第一个子节点  ，getNextSibling直接在此节点之后的节点
            for (Node  node=weather.getFirstChild(); node!=null; node=node.getNextSibling()) {
//  ELEMENT_NODE该节点为 Element    ；getNodeType得到该节点的类型    getNodeValue此节点的值
                if (node.getNodeType()==Node.ELEMENT_NODE) {
                    System.out.println(node.getNodeName());//如果该节点的类型为Element，打印该节点的名称
                    if (node.getFirstChild()!=null) {
                        System.out.println(node.getFirstChild().getNodeValue());
                    }
                }
            }
        }
    } 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();
    }
}

SAX解析XML

1.SAX解析器不像DOM那样建立一个完整的文档树，而是在读取文档时激活一系列事件
2.这些事件被退给事件处理器，然后由事件处理器提供给对文档内容的访问
3.与DOM相比，SAX的优点是内存消耗小，无需为所有节点创建对象

public class Test01 {
    public static void main(String[] args) {
        //SAXParserFactory 定义工厂 API，使应用程序能够配置和获取基于 SAX 的解析器以解析 XML 文档
        SAXParserFactory factory=SAXParserFactory.newInstance();//SAX解析器工厂利用newInstance（新实例）构造了一个实例对象
        File f=new File("e:\\weather.txt");
        try {
            SAXParser parser=factory.newSAXParser();//该实例对象利用newSAXParser方法构造了一个名为parser的解析器
            MySAXHandler handler=new MySAXHandler();//创建了一个名为handler的新的解析规则（自己定义的）
//  parse作用是使用指定的 DefaultHandler 将指定文件的内容解析为 XML。       
            parser.parse(f, handler);//f为指定的文件，handler为指定的默认方法
        } 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();
        }
    }
/DefaultHandler SAX2 事件处理程序的默认基类
//定义一个类，这个类继承了DefaultHandler ,其作用是SAX的解析方法采用默认方式
//重写了默认方法，构成了新的处理方法
public class MySAXHandler extends DefaultHandler{

    @Override
    public void characters(char[] ch, int start, int length) throws SAXException {
        // TODO Auto-generated method stub
        super.characters(ch, start, length);
        System.out.println("标签内容"+new String(ch,start,length));
    }


    @Override
    public void endDocument() throws SAXException {
        // TODO Auto-generated method stub
        super.endDocument();
        System.out.println("结束检测文档");
    }

    @Override
    public void endElement(String uri, String localName, String qName) throws SAXException {
        // TODO Auto-generated method stub
        super.endElement(uri, localName, qName);
        System.out.println("结束标签"+qName);
//      System.out.println(uri+localName+qName);

    }

    @Override
    public void startDocument() throws SAXException {
        // TODO Auto-generated method stub
        super.startDocument();
        System.out.println("开始检测文档");
    }

    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
        // TODO Auto-generated method stub
        super.startElement(uri, localName, qName, attributes);
        System.out.println("开始标签"+qName);
//      System.out.println(uri+localName+qName);
    }