IO流基础

IO

Input/Output，用于设备之间的数据传输。Java中以流的方式进行数据输入输出。

流的分类：

• 字节流（8bit）非文本
• 字符流（16bit）文本类
• 输入流（数据流向程序）
• 输出流（程序流出数据）
• 节点流
• 处理流（对节点流进行包装优化）

抽象基类	字节流	字符流
输入流	InputStream	Reader
输出流	OutputStream	Writer

常用流

• 访问文件（节点流）：FileInputStream 。。。
• 缓冲流（处理流）：BufferedInputStream 。。。
• 对象流：ObjectInputStream 。。。

文件流（节点流）

读取文件(字符流）

一个一个字节读

FileReader fileReader = null;
        try {
            //1.实例化File对象，指定操作的文件
            File file = new File("hello.txt");
            //2.提供具体的流
            fileReader = new FileReader(file);
            //3.数据的读入
            //read()返回值为-1表示读到文件末尾
            int read;
            while ((read = fileReader.read()) != -1){
                System.out.println((char)read);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            //4.流必须手动关闭,垃圾回收处理不了
            try {
                if(fileReader != null) {
                    fileReader.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }

多个字节读

        FileReader fileReader = null;
       try {
           File file = new File("hello.txt");
           fileReader = new FileReader(file);
           char[] cbuf = new char[5];
           int len;
           while ((len = fileReader.read(cbuf)) != -1){
               /*for (int i = 0; i < len; i++) {
                   System.out.println(cbuf[i]);
               }*/
               String str = new String(cbuf,0,len);
               System.out.println(str);
           }
       }catch (IOException e){
           e.printStackTrace();
       }finally {
           try {
               if(fileReader != null) {
                   fileReader.close();
               }
           }catch (IOException e){
               e.printStackTrace();
           }
       }

写出数据

FileWriter fileWriter = null;
        try {
            //1.指定写出文件,不存在则会创建
            File file = new File("hello1.txt");
            //2.提供写出流对象,true表示不覆盖原文件，而是追加内容
            fileWriter = new FileWriter(file,true);
            //3.写出操作
            fileWriter.write("Hello FileWriter\n");

        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try {
                if(fileWriter != null) {
                    fileWriter.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }

读加写

FileReader fileReader = null;
        FileWriter fileWriter = null;
        try {
            File srcFile = new File("hello.txt");
            File destFile = new File("hello2.txt");

            fileReader = new FileReader(srcFile);
            fileWriter = new FileWriter(destFile,true);

            char[] cbuf = new char[5];
            int len;
            while ((len=fileReader.read(cbuf))!=-1){
                fileWriter.write(cbuf,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try {
                if (fileReader!=null){
                    fileReader.close();
                }
                if (fileWriter!=null){
                    fileWriter.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }

读取和输出图片 (字节流)

FileInputStream fi = null;
        FileOutputStream fo = null;
        try {
            File srcFile = new File("1.jpg");
            File destFile = new File("2.png");

            fi = new FileInputStream(srcFile);
            fo = new FileOutputStream(destFile,true);

            byte[] b = new byte[5];
            int len;
            while ((len=fi.read(b))!=-1){
                fo.write(b,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try {
                if (fi!=null){
                    fi.close();
                }
                if (fo!=null){
                    fo.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }

缓冲流（处理流）

处理流对节点流进行包装，提高流的读取、写入速度，利于处理大文件，小文件没必要

所以写的时候也要先写节点流

BufferedInputStream bis = null;
        BufferedOutputStream bos = null;

        FileInputStream fis;
        FileOutputStream fos;
        try {
            File srcFile = new File("hello.txt");
            File destFile = new File("hello2.txt");

            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile,true);

            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);

            byte[] b = new byte[5];
            int len;
            while ((len=bis.read(b))!=-1){
                bos.write(b,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try {
                //外层关闭后内层自动关闭
                if (bis!=null){
                    bis.close();
                }
                if (bos!=null){
                    bos.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }

高速度的原因：提供了一个内部缓存区，flush()刷新缓冲区

转换流

提供字节流与字符流之间的转换

• InputStreamReader（解码）
• OutputStreamWriter（编码）

FileInputStream fis = new FileInputStream("hello.txt");
        FileOutputStream fos = new FileOutputStream("hello6.txt",true);
        
        InputStreamReader isr = new InputStreamReader(fis,"UTF-8");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");
        
        char[] cbuf = new char[5];
        int len;
        while ((len = isr.read(cbuf)) != -1){
            osw.write(cbuf,0,len);
        }
        isr.close();
        osw.close();

标准的输入输出流

输入

InputStreamReader isr = new InputStreamReader(System.in);
        
        BufferedReader br = new BufferedReader(isr);
        System.out.println("程序开始");
        while (true){
            String data = br.readLine();
            if ("e".equalsIgnoreCase(data)||"exit".equalsIgnoreCase(data)){
                System.out.println("程序结束");
                break;
            }

            System.out.println(data);
        }

        br.close();

输出

FileOutputStream fos = new FileOutputStream("D:\\t1.txt");
        //创建打印输出流，设置自动刷新模式(写入换行会刷新出缓冲区)
        PrintStream ps = new PrintStream(fos,true);
        //将标准输出流改成文件
        System.setOut(ps);
        //现在sout将会输出至文件
        for (int i = 0; i < 256; i++) {
            System.out.print((char)i);
            if (i%50==0){
                System.out.println();
            }
        }