JavaSE中级之IO流操作二

最新推荐文章于 2024-06-16 01:20:25 发布

不想写代码的懒大王

最新推荐文章于 2024-06-16 01:20:25 发布

阅读量369

点赞数 1

分类专栏：计算机二级—Java JavaSE Java 文章标签： jvm java 开发语言

本文链接：https://blog.csdn.net/weixin_54212148/article/details/128948298

版权

Java 同时被 3 个专栏收录

20 篇文章 0 订阅

订阅专栏

计算机二级—Java

19 篇文章 0 订阅

订阅专栏

JavaSE

19 篇文章 0 订阅

订阅专栏

IO流操作文本文件和非文本文件

对于文本文件的操作建议使用字符流来进行操作
对于非文本文件建议使用字节流来进行操作
utf-8文件编码格式下，中文字符在底层实际占用3个字节

IO流操作文本文件--------字符流

`FileReader`-------->文件读操作(字符流)

IO流，数据库，网络资源操作完成后需要手动关闭，jvm没有办法自己关闭
文件读操作对于程序来说是输入操作，是把外部文件内容输入到程序里面

单个字符循环读操作

循环读取文件里面的内容

File file = new File("E:\\Java\\test.txt");
        FileReader fileReader = new FileReader(file);
        int read = fileReader.read();
        //方式1
        //System.out.println(read);
        while (read != -1) {
            System.out.println((char) read);
            read = fileReader.read();
        }
        //方式2
        /*int read1;
        while ((read1 = fileReader.read()) != -1) {
            System.out.println(read1);
        }*/
        //IO流，数据库，网络资源操作完成后需要手动关闭，jvm没有办法自己关闭
        fileReader.close();

字符串循环读操作

利用String进行字符串循环读操作

File file = new File("E:\\Java\\test1.txt");
        FileReader fileReader = new FileReader(file);
        char[] chars = new char[5];
        int read = fileReader.read(chars);
        while (read != -1) {
            //System.out.println(read);
            //方式1
            /*for (int i = 0; i < read; i++) {
                System.out.println(chars[i]);
            }*/
            //方式2
            String s = new String(chars,0,read);
            System.out.println(s);
            read = fileReader.read(chars);
        }
        fileReader.close();

`FileWriter`-------->文件写操作(字符流)

文件写操作对于程序来说是输出操作，是把程序里面的内容输出到外部文件里面
FileWriter(file)，默认对文件进行追加写操作
FileWriter(file,false),对目标文件进行覆盖写操作
FileWriter(file,true)，对文件进行追加写操作

单个字符循环写操作

File file = new File("E:\\Java\\fwtest.txt");
        FileWriter fileWriter = new FileWriter(file);
        //FileWriter fileWriter = new FileWriter(file,false);//对目标文件进行覆盖操作
        //FileWriter fileWriter = new FileWriter(file,true);//对文件进行追加操作
        //输出动作
        //一个一个字符输出
        String s = "hello word! 你好 世界,世界 你好 好好";
        for (int i = 0; i < s.length(); i++) {
            fileWriter.write(s.charAt(i));
        }
        fileWriter.close();

利用缓冲数组写操作

File file = new File("E:\\Java\\fwtest.txt");
        FileWriter fileWriter = new FileWriter(file);
        //FileWriter fileWriter = new FileWriter(file,false);//对目标文件进行覆盖操作
        //FileWriter fileWriter = new FileWriter(file,true);//对文件进行追加操作
        //输出动作
        //一个一个字符输出
        String s = "hello word! 你好 世界,世界 你好 好好";
        /*for (int i = 0; i < s.length(); i++) {
            fileWriter.write(s.charAt(i));
        }*/
        //利用缓冲数组
        char[] chars = s.toCharArray();
        fileWriter.write(chars);
        fileWriter.close();

文件与程序输入输出的区别

对文件来说

从程序里面存内容到文件是输入操作
从文件里面拿内容到程序里面是输出操作

对程序来说

从程序里面存内容到文件是输出操作
从文件里面拿内容到程序里面是是输入操作

`FileReader`和`FileWriter`结合的`Copy`操作

对文件进行copy操作后要先关闭fileWriter流操作，然后再关闭FileReader流操作，所以 fileWriter.close();方法要写在 fileReader.close();前面
- 简单来说就是先用先关，后用后关

方式一

普通copy操作

File file = new File("E:\\Java\\test1.txt");
        File file1 = new File("E:\\Java\\testCopy.txt");
        FileReader fileReader = new FileReader(file);
        FileWriter fileWriter = new FileWriter(file1);
        //Copy操作
        //方式1
        int read = fileReader.read();
        while (read != -1) {
            fileWriter.write(read);
            read = fileReader.read();
        }
        fileWriter.close();
        fileReader.close();

方式二

利用缓冲数组进行copy操作

File file = new File("E:\\Java\\test1.txt");
        File file1 = new File("E:\\Java\\testCopy.txt");
        FileReader fileReader = new FileReader(file);
        FileWriter fileWriter = new FileWriter(file1);
        //Copy操作
        //方式2    利用缓冲数组
        char[] chars = new char[5];
        int read = fileReader.read(chars);
        while (read != -1) {
            fileWriter.write(chars,0,read);
            read = fileReader.read(chars);
        }
        fileWriter.close();
        fileReader.close();

方式三

把缓冲数组转为String进行copy操作

File file = new File("E:\\Java\\test1.txt");
        File file1 = new File("E:\\Java\\testCopy.txt");
        FileReader fileReader = new FileReader(file);
        FileWriter fileWriter = new FileWriter(file1);
        //Copy操作
        //方式3 把缓冲数组转为String
        char[] chars = new char[5];
        int read = fileReader.read(chars);
        while (read != -1) {
            String s = new String(chars,0,read);
            fileWriter.write(s);
            read = fileReader.read(chars);
        }
        fileWriter.close();
        fileReader.close();

IO流操作非文本文件--------字节流

字节流操作文本文件会把文本文件里面的内容拆成字节然后输出，所以不建议使用字节流操作文本文件

`FileInputStream`-------->文件读操作(字节流)

read()读取一个字节，返回的值是int类型，而不是byte类型
read()底层做了处理，让所有的返回值都的“正数”，避免了返回值为-1的情况，因为返回值为-1就难以区分是这个值是字节还是文件结尾

字节流操作文本文件

字节流操作文本文件会把中文切割成字节，在utf-8文件编码格式下一个中文汉字占3个字节
操作完后需要关闭流操作

File file = new File("E:\\Java\\test2.txt");
        FileInputStream fileInputStream = new FileInputStream(file);
        int sum = 0;
        int read = fileInputStream.read();
        //read()读取一个字节，返回的值是int，而不是byte
        //read底层做了处理，让所有的返回值都的“正数”，避免了返回值为-1的情况，避免了难以区分读入的到底是字节还是文件结尾
        //utf-8文件编码格式下，中文在底层实际占用3个字节
        while (read != -1) {
            sum ++;
            System.out.println(read);
            read = fileInputStream.read();
        }
        System.out.println(sum);
        fileInputStream.close();

字节流操作非文本文件

把非文本文件的二进制信息以字节流形式输出
操作完后需要关闭流操作

File file1 = new File("E:\\Java\\picTest.jpg");
        FileInputStream fileInputStream1 = new FileInputStream(file1);
        int count = 0;
        int read1 = fileInputStream1.read();
        while (read1 != -1) {
            count++;
            System.out.println(read1);
            read1 = fileInputStream1.read();
        }
        System.out.println(count);
        fileInputStream.close();

利用缓冲数组操作字节流

File file = new File("E:\\Java\\picTest.jpg");
        FileInputStream fileInputStream = new FileInputStream(file);
        //利用字节类型缓冲数组
        byte[] bytes = new byte[1024];
        int read = fileInputStream.read(bytes);
        while (read != -1) {
            //System.out.println(read);
            for (int i = 0; i < read; i++) {
                System.out.println(bytes[i]);
            }
            read = fileInputStream.read(bytes);
        }
        fileInputStream.close();

字节流对非文本文件的`copy`操作

方法1和方法2的时间差对比，明显方法2用时更短

方法1

File file = new File("E:\\Java\\pic.jpg");
        File file1 = new File("E:\\Java\\picTest.jpg");

        FileInputStream fileInputStream = new FileInputStream(file);
        FileOutputStream fileOutputStream = new FileOutputStream(file1);

        long start = System.currentTimeMillis();//开始时间
        int read = fileInputStream.read();
        while (read != -1) {
            fileOutputStream.write(read);
            read = fileInputStream.read();
        }
        long end = System.currentTimeMillis();//结束时间
        System.out.println((end - start));

        fileOutputStream.close();
        fileInputStream.close();

方法2
- 利用缓冲数组

File file = new File("E:\\Java\\pic.jpg");
        File file1 = new File("E:\\Java\\picTest.jpg");

        FileInputStream fileInputStream = new FileInputStream(file);
        FileOutputStream fileOutputStream = new FileOutputStream(file1);

        long start = System.currentTimeMillis();
        byte[] bytes = new byte[1024*1024];
        int read = fileInputStream.read(bytes);
        while (read != -1) {
            fileOutputStream.write(bytes,0,read);
            read = fileInputStream.read();
        }
        long end = System.currentTimeMillis();
        System.out.println((end - start));

        fileOutputStream.close();
        fileInputStream.close();