IO流总结

最新推荐文章于 2024-09-14 18:46:05 发布

weixin_53213088

最新推荐文章于 2024-09-14 18:46:05 发布

阅读量27

点赞数

文章标签： java servlet 前端

本文链接：https://blog.csdn.net/weixin_53213088/article/details/134496516

版权

字节流：任何文件的额底层都是由字节组成能够复制全部字节流非常适合复制。

// E:\resource\meinv.png  ===> D:\new.png
        try (
                // 注意：这里只能放置资源对象，用完后会自动调用这些资源对象的close方法释放资源。
                // 1、创建一个文件字节输入流管道先与源文件接通
                InputStream is = new FileInputStream("day05-file-io\\src\\dlei06.txt");
                // 2、创建一个文件字节输出流管道与目标文件接通
                OutputStream os = new FileOutputStream("day05-file-io\\src\\dlei06-new.txt");
                MyConnection conn = new MyConnection();
                ){
            // 3、准备一个字节数组，准备转移数据
            // 1024 + 1024 + 3
            byte[] buffer = new byte[1024];
            int len; // 记录每次读取的字节数。
            while ((len = is.read(buffer)) != -1) {
                os.write(buffer, 0, len);
            }
            System.out.println("复制完成了！");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class MyConnection implements AutoCloseable{
    @Override
    public void close() throws Exception {
        System.out.println("当前资源对象被释放~~~~");
    }

释放资源的方式：try - catch -finally

try - with - resource

第二种方式：

try(这里只能放资源对象用完后自动调用其close（）方法)

字符输出流使用时的注意事项：

文件字符输入流：

字节一个字节和一个字节数组低级高级的总结

package d2_buffer_stream;

import java.io.*;

public class TimeTest5 {
    public static final String SRC_VIDEO = "E:\\磊哥面授\\磊哥面授-昌平校区\\基础进阶课程\\day03-常用API-Collection集合、源码\\视频\\09、ArrayList底层原理.avi";
    public static final String DEST_FILE = "E:\\磊哥面授\\";

    public static void main(String[] args) {
        // 1、低级的字节输入流一个一个字节的复制，慢的简直让人无法忍受，直接淘汰，禁止使用。
        // copy01();
        // 2、低级的字节输入流一个一个字节数组的复制，速度相对较快，但是还是比较慢。(注意：只要使用的字节数组够大，性能还是一样高的)
        copy02();
        // 3、高级的缓冲字节输入流一个一个字节的复制：很慢！也不应该这样写。
        // copy03();
        // 4、高级的缓冲字节输入流一个一个字节数组的复制：极快！！推荐使用！！
        copy04();
    }

    // 1、使用低级的字节输入流一个一个字节的复制一把。
    public static void copy01(){
        long startTime = System.currentTimeMillis();
        try (
                // a、创建低级的字节输入流管道与源文件接通
                InputStream is = new FileInputStream(SRC_VIDEO);
                // b、创建低级的字节输出流管道与目标文件接通
                OutputStream os = new FileOutputStream(DEST_FILE + "1.avi");
                ){
            // c、一个一个字节的转移。
            int b;
            while ((b = is.read()) != -1) {
                os.write(b);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("低级字节流一个一个字节复制耗时：" + (endTime - startTime) / 1000.0 + "s");
    }

    // 2、使用低级的字节输入流一个一个字节数组的复制一把。
    public static void copy02(){
        long startTime = System.currentTimeMillis();
        try (
                // a、创建低级的字节输入流管道与源文件接通
                InputStream is = new FileInputStream(SRC_VIDEO);
                // b、创建低级的字节输出流管道与目标文件接通
                OutputStream os = new FileOutputStream(DEST_FILE + "2.avi");
        ){
            // c、一个一个字节数组的转移。
            byte[] buffer = new byte[1024 * 64];
            int len;
            while ((len = is.read(buffer)) != -1) {
                os.write(buffer, 0, len);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("低级字节流一个一个的字节数组复制耗时：" + (endTime - startTime) / 1000.0 + "s");
    }

    // 3、使用高级的缓冲字节输入流一个一个字节的复制一把。
    public static void copy03(){
        long startTime = System.currentTimeMillis();
        try (
                // a、创建低级的字节输入流管道与源文件接通
                InputStream is = new FileInputStream(SRC_VIDEO);
                InputStream bis = new BufferedInputStream(is);

                // b、创建低级的字节输出流管道与目标文件接通
                OutputStream os = new FileOutputStream(DEST_FILE + "3.avi");
                OutputStream bos = new BufferedOutputStream(os);
        ){
            // c、一个一个字节的转移。
            int b;
            while ((b = bis.read()) != -1) {
                bos.write(b);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("高级的缓冲字节流一个一个字节复制耗时：" + (endTime - startTime) / 1000.0 + "s");
    }

    // 4、使用高级的缓冲字节输入流一个一个字节数组的复制一把。
    public static void copy04(){
        long startTime = System.currentTimeMillis();
        try (
                // a、创建低级的字节输入流管道与源文件接通
                InputStream is = new FileInputStream(SRC_VIDEO);
                InputStream bis = new BufferedInputStream(is);

                // b、创建低级的字节输出流管道与目标文件接通
                OutputStream os = new FileOutputStream(DEST_FILE + "4.avi");
                OutputStream bos = new BufferedOutputStream(os);
        ){
            // c、一个一个字节数组的转移。
            byte[] buffer = new byte[1024 * 32];
            int len;
            while ((len = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, len);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("高级的缓冲字节输流一个一个的字节数组复制耗时：" + (endTime - startTime) / 1000.0 + "s");
    }
}

高级流：

字节缓冲流：Buffered(缓冲)InputStream

字符缓冲流：BufferedReader

原始流、缓冲流的性能分析：

// 目标：字符缓冲输入流的使用：提升原始字符输入流的读字符性能，多了按照行读取的能力。
        try (
                // 1、创建一个文件字符输入流与源文件接通
                Reader fr = new FileReader("day06-io-thread\\src\\dlei03.txt");
                // 把低级的字符输入流包装成高级的缓冲字符输入流。
                BufferedReader bw = new BufferedReader(fr);
        ) {

            // 2、public int read(char[] buffer):
            //  每次读取字符数组这么多字符，返回每次读取了多少个字符。如果没有字符可读返回-1.
//            char[] buffer = new char[1024];
//            int len; // 记录每次读取的字符个数。
//            while ((len = bw.read(buffer)) != -1){
//                String rs = new String(buffer, 0, len);
//                System.out.print(rs);
//            }

//            System.out.println(bw.readLine());
//            System.out.println(bw.readLine());
//            System.out.println(bw.readLine());
//            System.out.println(bw.readLine());
//            System.out.println(bw.readLine());
//            System.out.println(bw.readLine());
//            System.out.println(bw.readLine());

            // 3、使用循环改进
            String line; // 记住读取的一行数据
            while ((line = bw.readLine()) != null) {
                System.out.println(line);
            }
        }catch (Exception e){
            e.printStackTrace();
        }

字符输入转换流：

InputStreamReader

打印流：

public static void main(String[] args) {
        try (
                // 1、创建打印流管道
//                PrintStream ps = new PrintStream("day06-io-thread/src/ps.txt"); // 覆盖管道
                PrintStream ps = new PrintStream(new FileOutputStream("day06-io-thread/src/ps.txt", true)); // 追加管道
//                PrintWriter ps = new PrintWriter("day06-io-thread/src/ps.txt"); // 覆盖管道
                ){
            // 2、打印数据出去
            ps.println(97); // 自带换行
            ps.println(98.5);
            ps.println("我爱你中国");
            ps.println('a');
            ps.println(true);

        }catch (Exception e){
            e.printStackTrace();
        }
    }

打印流的重定向：