IO流与xml解析

于 2022-04-13 09:40:08 发布
阅读量293 收藏 1
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45168276/article/details/124140754
版权 
    @Transactional(rollbackFor = RestClientException.class)
    @ApiOperation("字节流写入")
    @RequestMapping(value = "/writFileTest", method = RequestMethod.POST, produces = "application/json")
    public AjaxResult writFileTest() throws DocumentException, IOException {
        // 创建文件对象
        File file = new File("D:\\20220411File\\a.txt");
        //如果不存在
        if (!file.exists()) {
            //创建目录
            boolean mkdirs = file.getParentFile().mkdirs();
            //创建文件
            boolean newFile = file.createNewFile();
        }
        FileOutputStream fos = new FileOutputStream(file, true);
        String str = "SpoCsInPut";
        //写入文件
        fos.write(str.getBytes());
        //从0开始只写入三个字节
        //fos.write(str.getBytes(),0,3);
        fos.close();
        return AjaxResult.success();
    }

    @Transactional(rollbackFor = RestClientException.class)
    @ApiOperation("字节流读取")
    @RequestMapping(value = "/readFileTest", method = RequestMethod.POST, produces = "application/json")
    public AjaxResult readFileTest() throws DocumentException, IOException {
        // 创建文件对象
        File file = new File("D:\\20220411File\\a.txt");
        // 创建文件输入流
        FileInputStream fis = new FileInputStream(file);
        // 有对多长，就读多少字节。(int) file.length()
        byte bt1[] = new byte[1024];
        int len = fis.read(bt1);
        String str = new String(bt1, 0, len);
        fis.close();
        return AjaxResult.success(str);
    }

    @Transactional(rollbackFor = RestClientException.class)
    @ApiOperation("字节拷贝二进制图片")
    @RequestMapping(value = "/FileCopy", method = RequestMethod.POST, produces = "application/json")
    public AjaxResult FileCopy() {
        //原本文件
        String imgPath = "D:\\20220411File\\D.jpg";
        //需要拷贝的文件
        String imgPathCopy = "D:\\20220411File\\A.jpg";
        //字节流读取
        FileInputStream fileInputStream = null;
        //字节流写入
        FileOutputStream fileOutputStream = null;
        try {
            fileInputStream = new FileInputStream(imgPath);
            fileOutputStream = new FileOutputStream(imgPathCopy);
            byte[] bytes = new byte[1024];
            int readLen = 0;
            //每次读取1024个字节 -1表示文件末尾
            while ((readLen = fileInputStream.read(bytes)) != -1) {
                //写入文件
                fileOutputStream.write(bytes, 0, readLen);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileInputStream != null) {
                    //关闭流
                    fileInputStream.close();
                }
                if (fileOutputStream != null) {
                    //关闭流
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return AjaxResult.success("完成");
    }

    @Transactional(rollbackFor = RestClientException.class)
    @ApiOperation("字符流写入磁盘")
    @RequestMapping(value = "/FileWriterOut", method = RequestMethod.POST, produces = "application/json")
    public AjaxResult FileWriterOut() throws DocumentException, IOException {
        // 创建文件对象
        File file = new File("D:\\20220411File\\字符.txt");
        //如果不存在
        if (!file.exists()) {
            //创建目录
            boolean mkdirs = file.getParentFile().mkdirs();
            //创建文件
            boolean newFile = file.createNewFile();
        }
        //字符流
        FileWriter fos = new FileWriter(file, true);
        //中文
        String str = "明天你好";
        //写入文件
        fos.write(str);
        //从0开始 写入3个字符
        //fos.write(str.toCharArray(),0,3);
        //关闭流
        fos.close();
        return AjaxResult.success("写入完成");
    }

    @Transactional(rollbackFor = RestClientException.class)
    @ApiOperation("字符流读取文件")
    @RequestMapping(value = "/FileReaderIn", method = RequestMethod.POST, produces = "application/json")
    public AjaxResult FileReaderIn() throws DocumentException, IOException {
        File file = new File("D:\\20220411File\\字符.txt");
        // 创建文件输入流
        FileReader fis = new FileReader(file);
        // char类型数组 一次读1024
        char[] bt1 = new char[1024];
        //默认为0 结束为-1
        int readLen = 0;
        //声明字符串
        String str = "";
        //开始循环  一次读取1024
        while ((readLen = fis.read(bt1)) != -1) {
            //字符串赋值 从0开始 到-1
            str = new String(bt1, 0, readLen);
        }
        //关闭流
        fis.close();
        return AjaxResult.success(str);
    }


    @Transactional(rollbackFor = RestClientException.class)
    @ApiOperation("Buffered缓冲流读取文件")
    @RequestMapping(value = "/BufferedReaderCs", method = RequestMethod.POST, produces = "application/json")
    public AjaxResult BufferedReaderCs() throws DocumentException, IOException {
        File file = new File("D:\\20220411File\\字符.txt");
        BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
        String str;
        String reStr = "";
        //末尾是返回null
        while ((str = bufferedReader.readLine()) != null) {
            reStr = str;
        }
        bufferedReader.close();
        return AjaxResult.success(reStr);
    }

    @Transactional(rollbackFor = RestClientException.class)
    @ApiOperation("Buffered缓冲流写入文件")
    @RequestMapping(value = "/BufferedWriterCs", method = RequestMethod.POST, produces = "application/json")
    public AjaxResult BufferedWriterCs() throws DocumentException, IOException {
        File file = new File("D:\\20220411File\\buffer.txt");
        if (!file.exists()) {
            //创建目录
            boolean mkdirs = file.getParentFile().mkdirs();
            //创建文件
            boolean newFile = file.createNewFile();
        }
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file, true));
        bufferedWriter.write("测试缓冲流写入数据！");
        bufferedWriter.newLine();
        bufferedWriter.write("HelloDis！");
        bufferedWriter.flush();
        bufferedWriter.close();
        return AjaxResult.success("写入成功");
    }

    @Transactional(rollbackFor = RestClientException.class)
    @ApiOperation("BufferedCopy文本文件")
    @RequestMapping(value = "/BufferedCopy", method = RequestMethod.POST, produces = "application/json")
    public AjaxResult BufferedCopy() throws DocumentException, IOException {
        //原本文件
        String imgPath = "D:\\20220411File\\buffer.TXT";
        //需要拷贝的文件
        String imgPathCopy = "D:\\20220411File\\bufferA.TXT";
        //字节流读取
        BufferedReader bufferedReader = null;
        //字节流写入
        BufferedWriter bufferedWriter = null;
        try {
            bufferedReader = new BufferedReader(new FileReader(imgPath));
            bufferedWriter = new BufferedWriter(new FileWriter(imgPathCopy));

            String read;
            while ((read = bufferedReader.readLine()) != null) {
                //写入文件
                bufferedWriter.write(read);
                //换行
                bufferedWriter.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (bufferedReader != null) {
                    //关闭流
                    bufferedReader.close();
                }
                if (bufferedWriter != null) {
                    //关闭流
                    bufferedWriter.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return AjaxResult.success("拷贝成功");
    }

    @Transactional(rollbackFor = RestClientException.class)
    @ApiOperation("BufferedCopy二进制文件")
    @RequestMapping(value = "/BufferedStreamCopy", method = RequestMethod.POST, produces = "application/json")
    public AjaxResult BufferedStreamCopy() throws DocumentException, IOException {
        //原本文件
        String imgPath = "D:\\20220411File\\D.jpg";
        //需要拷贝的文件
        String imgPathCopy = "D:\\20220411File\\C.jpg";
        //字节流读取
        BufferedInputStream fileInputStream = null;
        //字节流写入
        BufferedOutputStream fileOutputStream = null;
        try {
            fileInputStream = new BufferedInputStream(new FileInputStream(imgPath));
            fileOutputStream = new BufferedOutputStream(new FileOutputStream(imgPathCopy));
            byte[] bytes = new byte[1024];
            int readLen = 0;
            //每次读取1024个字节 -1表示文件末尾
            while ((readLen = fileInputStream.read(bytes)) != -1) {
                //写入文件
                fileOutputStream.write(bytes, 0, readLen);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileInputStream != null) {
                    //关闭流
                    fileInputStream.close();
                }
                if (fileOutputStream != null) {
                    //关闭流
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return AjaxResult.success("拷贝成功");
    }


    @Transactional(rollbackFor = RestClientException.class)
    @ApiOperation("Object保存文件为data,序列化")
    @RequestMapping(value = "/ObjectOutputStreamCs", method = RequestMethod.POST, produces = "application/json")
    public AjaxResult ObjectOutputStreamCs() throws DocumentException, IOException {
        File file = new File("D:\\20220411File\\data.data");
        if (!file.exists()) {
            //创建目录
            boolean mkdirs = file.getParentFile().mkdirs();
            //创建文件
            boolean newFile = file.createNewFile();
        }
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(file));
        objectOutputStream.writeInt(100); //实现序列化 Serializable
        objectOutputStream.writeBoolean(true);//实现序列化 Serializable
        objectOutputStream.writeChar('a');
        objectOutputStream.writeDouble(93.5);
        objectOutputStream.writeUTF("明天");
        objectOutputStream.writeObject(new Dog("name", 10));
        objectOutputStream.close();
        return AjaxResult.success("写入成功");
    }

    @Transactional(rollbackFor = RestClientException.class)
    @ApiOperation("Object读取文件为data,反序列化")
    @RequestMapping(value = "/ObjectInputStreamCs", method = RequestMethod.POST, produces = "application/json")
    public AjaxResult ObjectInputStreamCs() throws DocumentException, IOException, ClassNotFoundException {
        File file = new File("D:\\20220411File\\data.data");
        ObjectInputStream stream = new ObjectInputStream(new FileInputStream(file));
        //写入的顺序和读取的顺序要一直
        System.out.println(stream.readInt());
        System.out.println(stream.readBoolean());
        System.out.println(stream.readChar());
        System.out.println(stream.readDouble());
        System.out.println(stream.readUTF());
        Object dog1 = stream.readObject();
        System.out.println(dog1);
        Dog dog2 = (Dog) dog1;
        System.out.println(dog2.getName());
        stream.close();
        return AjaxResult.success("控制台输出成功！");
    }

    @Transactional(rollbackFor = RestClientException.class)
    @ApiOperation("Xml解析One")
    @RequestMapping(value = "/CsXml", method = RequestMethod.POST, produces = "application/json")
    @SuppressWarnings("unchecked")
    public AjaxResult CsXml() throws DocumentException, IOException {
        SAXReader reader = new SAXReader();
        //读取文件路径
        Document read = reader.read(new File("D:\\20220411File\\CsXml.xml"));
        //获取所有的xml信息
        String asXML = read.asXML();
        //获取根属性
        Element rootElement = read.getRootElement();
        //迭代
        List<String> list  = new ArrayList<>();
        for (Iterator<Element> it = rootElement.elementIterator("user"); it.hasNext();) {
            Element user = it.next();
            String id = user.attributeValue("id");
            String name = user.elementText("name");
            String age = user.elementText("age");
            String address = user.elementText("address");
            list.add(id+name+age+address);
        }
        return AjaxResult.success(list);
    }

    @Transactional(rollbackFor = RestClientException.class)
    @ApiOperation("Xml解析Two")
    @RequestMapping(value = "/SAXReader", method = RequestMethod.POST, produces = "application/json")
    @SuppressWarnings("unchecked")
    public AjaxResult SAXReader() throws DocumentException, IOException {
        SAXReader reader = new SAXReader();
        //读取文件路径
        Document read = reader.read(new File("D:\\20220411File\\CsXml.xml"));
        //获取所有的xml信息
        String asXML = read.asXML();
        //获取根属性
        Element rootElement = read.getRootElement();
        List<Element> user = rootElement.elements();
        //迭代
        List<String> list  = new ArrayList<>();
        for (Element elemen:user) {
            String id = elemen.attributeValue("id");
            String name = elemen.elementText("name");
            String age = elemen.elementText("age");
            String address = elemen.elementText("address");
            list.add(id+name+age+address);
        }
        return AjaxResult.success(list);
    }

    @Transactional(rollbackFor = RestClientException.class)
    @ApiOperation("Xml添加属性与值")
    @RequestMapping(value = "/SaveSAXReader", method = RequestMethod.POST, produces = "application/json")
    public AjaxResult SaveSAXReader() throws DocumentException, IOException {
        SAXReader reader = new SAXReader();
        //读取文件路径
        Document read = reader.read(new File("D:\\20220411File\\CsXml.xml"));
        //获得根元素
        Element rootElement = read.getRootElement();
        rootElement.addElement("user").addAttribute("id","p4");
        rootElement.addElement("name").addText("小一");
        rootElement.addElement("age").addText("20");
        rootElement.addElement("address").addText("蜀国");
        rootElement.addElement("user").addAttribute("id","p5");
        rootElement.addElement("name").addText("小二");
        rootElement.addElement("age").addText("21");
        rootElement.addElement("address").addText("蜀国");
        OutputFormat format = OutputFormat.createPrettyPrint();
        format.setEncoding("UTF-8");
        XMLWriter writer = new XMLWriter(new FileWriter(new File("D:\\20220411File\\CsXml.xml")), format);
        writer.write( read );
        writer.close();
        return AjaxResult.success("写入成功！");
    }

    @Transactional(rollbackFor = RestClientException.class)
    @ApiOperation("Xml删除节点")
    @RequestMapping(value = "/DelSAXReader", method = RequestMethod.POST, produces = "application/json")
    public AjaxResult DelSAXReader() throws DocumentException, IOException {
        SAXReader reader = new SAXReader();
        //读取文件路径
        Document document = reader.read(new File("D:\\20220411File\\CsXml.xml"));
        Element root = document.getRootElement();
        Element node = (Element) document.selectSingleNode("//user[@id = 'p4']");
        boolean remove = node.getParent().remove(node);
        OutputFormat format = OutputFormat.createPrettyPrint();
        format.setEncoding("UTF-8");
        XMLWriter writer = new XMLWriter(new FileWriter(new File("D:\\20220411File\\CsXml.xml")), format);
        writer.write( document );
        writer.close();
        return AjaxResult.success("删除成功！");
    }

    @Transactional(rollbackFor = RestClientException.class)
    @ApiOperation("Xml修改节点")
    @RequestMapping(value = "/UpDateSAXReader", method = RequestMethod.POST, produces = "application/json")
    public AjaxResult UpDateSAXReader() throws DocumentException, IOException {
        SAXReader reader = new SAXReader();
        //读取文件路径
        Document document = reader.read(new File("D:\\20220411File\\CsXml.xml"));
        //查找父元素
        Element user = (Element) document.selectSingleNode("//user[@id = 'p3']");
        user.element("name").addAttribute("type","dd");
        user.element("name").setText("周瑜");
        OutputFormat format = OutputFormat.createPrettyPrint();
        format.setEncoding("UTF-8");
        XMLWriter writer = new XMLWriter(new FileWriter(new File("D:\\20220411File\\CsXml.xml")), format);
        writer.write( document );
        writer.close();
        return AjaxResult.success("修改成功！");
    }

    @Transactional(rollbackFor = RestClientException.class)
    @ApiOperation("Properties文件读取")
    @RequestMapping(value = "/PropertiesGet", method = RequestMethod.POST, produces = "application/json")
    public AjaxResult PropertiesGet() throws DocumentException, IOException {
        File file = new File("D:\\20220411File\\mysql.properties");
        Properties properties = new Properties();
        properties.load(new FileReader(file));
        properties.list(System.out);
        String id = properties.getProperty("id");
        return AjaxResult.success(id);
    }

    @Transactional(rollbackFor = RestClientException.class)
    @ApiOperation("Properties文件写入修改")
    @RequestMapping(value = "/SaveProperties", method = RequestMethod.POST, produces = "application/json")
    public AjaxResult SaveProperties() throws DocumentException, IOException {
        File file = new File("D:\\20220411File\\mysql.properties");
        Properties properties = new Properties();
        properties.setProperty("name","123");
        properties.setProperty("age","1111");
        properties.setProperty("address","中国");
        properties.store(new FileWriter(file),"这是注释");
        return AjaxResult.success("写入成功");
    }





    static class Dog implements Serializable {
        private String name;
        private int age;

        public Dog(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        @Override
        public String toString() {
            return "Dog{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
SporadicLife
关注
XML解析
weixin_43863384的博客
06-20 521
XML解析一、XML介绍二、XML解析介绍1.DOM解析三、XML解析实例1.DOM解析 一、XML介绍 XML：Extensible Markup Language，即可扩展标记语言. 用于标记电子文件使其具有结构性的标记语言，可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言。非常适合 Web 传输。XML 提供统一的方法来描述和交换独立于应用程序或供应商的结构化...
IO和XML讲解
04-24
IO和XML讲解 AndroidXML讲解，适合新手学习
IO流、Xml解析
08-26
它们的一些用法，作用
Java IO——xml文件解析一（DOM方式解析xml文件）
PettyKoKo
08-10 344
DOM方式解析xml文件 在Java程序中如何获取xml文件的内容 在Java程序中读取xml文件的过程也称为解析xml文件 解析的目的：获取节点名、节点值、属性名、属性值 四种解析方式：DOM、SAX、DOM4J、JDOM (前两种是Java官方提供的) 本次学习了DOM方式解析xml文件 代码如下 package d...
读取xml文件
mibing1912的博客
01-04 233
JAVA读取xml文件-----DOM方式 文件结构： 第一种 import java.io.File; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import org.junit.Test;
[知了堂学习笔记]IO扩展_解析xml文件
mili_dou的博客
01-28 310
文章来自： https://www.cnblogs.com/jasonHome/p/5647108.html java解析XML文件的四种方法 假设有xml文件内容和结构如下： employees> employee> name>feifeiname> sex>womansex> age>21age> employee> employees> 建立XML文件建立与解析接口：
文件io之（用jdom解析xml）
weixin_42328543的博客
03-21 111
文件io之（用jdom解析xml） 下面是将xml解析到txt xml中内容如下： <?xml version="1.0" encoding="utf-8"?> <students> <student> <学号>201833</学号> <学生姓名>王二</学生姓名&gt...
readXML.rar_happenupn_matlab_xml-io_xml_io_tools_解析xml
07-15
用xml_io_tools解析XML文件（包含xml_io_tools 工具包）
Java IO流操作：解析XML文件创建对象的实践指南
资源摘要信息:"在Java程序设计中，处理XML文件并从中读取数据以创建对象是常见的任务，这可以通过Java的IO流和XML解析技术来实现。本知识摘要将详细介绍如何使用Java的IO流功能从XML文件中读取数据，并且利用这些...
多层镶嵌xml解析.zip
11-19
总结一下，DOM4J提供了一种灵活、高效的XML解析方式，尤其适用于处理具有复杂结构的XML文档。通过创建和操作DOM4J的`Element`对象，我们可以方便地解析XML，提取所需数据，并将其存储到自定义的实体类中。对于大型...
Java XML和IO流
三三大家长
06-11 691
第七章  XML和Io处理 一.File类 File类位于java.io包下，代表与平台无关的文件和目录。 作用：可以只用File来对文件或目录进行：创建，删除，重命名。 1.访问文件和目录 a.创建file实例 (1)File(String pathname) :通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。 (2)File(File parent, Stri
用java读取xml文件的四种方法
06-28
用java读取xml文件的四种方法
java--IO读取写入xml文件
qq_43804919的博客
10-28 542
IO读取写入xml文件 以学生对象为例 员工类 package com.situ.chapterwork; public class Student { private int id; private String name; private String sex; private int age; public int getId() { return id; } public void setId(int id) {
I/O和XML
qq_31424991的博客
10-18 823
1 I/O 1.1 File类： File类定义了一系列与操作系统无关的方法来操作文件和目录。一个File对象可以代表一个文件，也可以代表一个目录。创建一个File类对象后，如果是目录可以显示目录清单、新建或删除目录；如果是文件，可以查阅文件的属性和路径信息，也可以输出和改名。可以通过查阅API帮助文档了解更多的相关内容。 1.2 I/O系统 在Java编程中，I/O系统主要负责文件的读写
Java基础---（io和xml）
hjh202537的专栏
09-12 598
一个很简单的复制文件的操作：  package test.io;import java.io.BufferedReader;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;imp
python中，IO和xml
weixin_42077001的博客
05-28 158
 Python中的io模块是用来处理各种类型的I/O操作流。主要有三种类型的I/O类型：文本I/O(Text I/O)，二进制I/O(Binary I/O)和原始I/O。它们都是通用类别，每一种都有不同的后备存储。属于这些类别中的任何一个的具体对象称为文件对象，其他常用的术语为流或者类文件对象。  除了它的类别，每一种具体的流对象也具有各种功能：它仅仅允许读，或者仅仅允许写，或者既能读又能写。它也...
堆，栈，Object，Exception，IO流，XML三种解析方式
小纯洁党
07-25 373
1.栈：先进后出，后进先出 堆：先进先出，后进后出（给一个字符串，进行四则运算，用栈实现） 2.Object类（祖类）java所有引用数据类型全部都继承于Object，所有类默认继承Object（extends Object） 主要方法equals hashcode toString…… 学习在类中重写equals和toString 3.Exception异常 类的关系如下 其中Er
34.XML使用IO流来解析时需要的一些类
01-31 141
1.DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); 2.DocumentBuilder documentBuilder = factory.newDocumentBuilder(); 3.Document document = documentBuilder.parse(file); 4.Node...
IO&XML
qq_29747683的博客
09-08 183
持续更新中…
Java XML与IO流解析：使用Reader读取文件
"使用Reader读取文件内容--XML与IO流" 在Java中，文件的读取和写入操作是通过流(Stream)的概念来实现的。流可以被看作是一组有序的数据集合，它有起点（数据源）和终点（数据目的地）。流主要分为两大类：字节流和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值