Java开发——29.I/O流_字符流和字节流

定义流：

在电脑上针对数据的传输就可以视为一种数据的流动，按照流动的方向，我们以内存(程序)为基准，分为输出流(Input,流向内存)和输出流(Output,流出内存)。

IO流：

Java中I/O操作主要是指使用java.io包下的内容，进行输入和输出操作；输入叫做读取数据，输出叫做写出数据。

IO流的分类：

流向：

根据数据的流向可以分为：输入流和输出流；

输入流(InputStream/Reader)：把数据从其他设备上读取到内存中的流；

输出流(OutputStream/Writer)：把数据从内存中写出到其他设备上的流。

单位：

根据数据的单位可以分为：字节流和字符流；
字节流：以位(bit，8)为单位，主要存储非文本文件的传输，底层采用0/1存储（InputStream/OutputStream）；
字符流：字符(bit，16)，是以一个个字符存储，主要应用于文本文件的传输（Reader/Writer）。

角色：

根据数据的角色可以分为：节点流和处理流；
节点流：内存(程序)对数据的直接接收；
处理流：在节点流的基础上，进行数据的处理操作。

流的体系结构：

针对字符流和字节流的操作，都是相同的，只需要掌握一种，另一种比葫芦画瓢就可以，这一章的所有类都是相类似的操作！

流的操作：

我们以字符流为标准学习流(只有四个步骤)！
无论字节流还是字符流都只有这四个步骤

//1.创建文件对象
//2.创建流对象
//3.对数据进行操作 读取/写入
//4.关闭流

字符流(Reader/Writer)：

//常用方法
read() 读一个字符 
read(char [] cbuf) 读取一个字符数组
write(char [] cbuf) 写入一个字符数组
write(char[] cbuf, int off, int len) 写入字符数组的一部分。 
colse() 关闭对应的流

//以Reader为例详细讲解读取过程

//方式一：使用字符数组存储
//这种方式是没有做异常处理的，只是为了让大家清楚具体写法(后续使用try ...catch)
public static void readFile(String path) throws IOException {
​
        //1.创建文件对象
        File file = new File(path);
​
        //2.创建流对象
        FileReader fr = new FileReader(file);
​
        //3.对数据进行操作 读取
        //此处我是用了字符数组的读取，相对一个个读取，提高了效率，但是还是没有缓冲流提高效率明显
        char cbuf [] = new char[5];//此处的长度自定义即可(针对字节文件可使用1024)
        int len;//记录数据是够读完
        while ((len = fr.read(cbuf)) != -1){
        //此处的长度为len，目的是保证读取顺序
            for (int i = 0; i < len; i++){
                System.out.print(cbuf[i]);
            }
            /**错误：原因是当你读完前一个数组中的内容会出现覆盖不完全，
            也就是，保证了cbuf数组是存满的，不论文件内容是否够满足数组的长度
               for (int i = 0; i < cbuf.length; i++){
                    System.out.print(cbuf[i]);
                }
              */
        }
​
        //4.关闭流
        fr.close();
    }
​

//方式二：逐一读取
public static void readFile(String path) throws IOException {
​
        //1.创建文件对象
        File file = new File(path);
​
        //2.创建流对象
        FileReader fr = new FileReader(file);
​
        //3.对数据进行操作 读取/写入
       int len;
       while ((len = fr.read()) != -1){
           System.out.print((char)len);
       }
​
        //4.关闭流
        fr.close();
    }

//使用try...catch处理异常以方式一为例！
//idea自动生成try catch finally代码块的快捷方式：ctrl+alt+t/ctrl+win+alt+t
public static void readFile(String path){
​
        FileReader fr = null;//要是使用快捷键会自动生成,将FileReader提升到该位置，是为了后续关闭流能找到流对象
​
        try {
            //1.创建文件对象
            File file = new File(path);
​
            //2.创建流对象
            fr = new FileReader(file);
​
            //3.对数据进行操作 读取/写入
            char cbuf [] = new char[5];
            int len;
            while ((len = fr.read(cbuf)) != -1){
                for (int i = 0; i < len; i++){
                    System.out.print(cbuf[i]);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally { //使用finally是为了保证，有异常的情况下，也必须关闭流
            //4.关闭流
            if(fr != null) {//如果在创建流的时候报错了，则fr不会成功创建，所以可能出现空指针的异常
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

文本文件的复制：

//因为创建了两个流对象读取流和写出流，所以要关闭两个流，但是这两个流关闭的顺序可以自定以
//注意：一般我们会从后往前关闭流，保证流全部关闭
public static void copyFile(String srcPath,String destPath){
​
        FileReader fr = null;
        FileWriter fw = null;
​
        try {
            //1.创建读取、写入文件的路径
            File srcfile = new File(srcPath);
            File copyfile = new File(destPath);
​
            //2.创建文件读取、写入的对象，实例化流
            fr = new FileReader(srcfile);
            fw = new FileWriter(copyfile);
​
            //3.读取、写出数据
            char cbuf [] = new char[5];
            int len;
            while ((len = fr.read(cbuf)) != -1) {
            //为了保证写出的内容和内存中的内容是相同的，此处就是以len为读取结束位置
                fw.write(cbuf, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流
            if (fw != null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
//在此位置，两种关闭流的写法都正确，try catch如果有异常会在catch中处理，所以可以不用加finally也会执行后续的代码。
            try {
                if (fr != null)
                    fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
​
        }
}

字节流(InputStream/OutputStream)：

//常用方法
read() 读一个字符 
read(byte [] buffer) 读取一个字节数组
write(byte [] buffer) 写入一个字节数组
write(byte [] buffer, int off, int len) 写入字节数组的一部分。 
colse() 关闭对应的流

直接以非文本文件作为学习：

public static void copyFile(String srcFile, String destFile){
​
            FileInputStream input = null;
            FileOutputStream output = null;
            try {
                File srcfile = new File(srcFile);
                File destfile = new File(destFile);
​
                input = new FileInputStream(srcfile);
                output = new FileOutputStream(destfile);
​
                //在读取的过程中一般使用 1024 作为标准2的10次方，因为非文本文件过大
                //在缓冲流的内容中定义了缓冲的空间，所以在学缓冲流的过程中可以使用默认的缓存空间
                byte buffer[] = new byte[1024];
                int len;
                while ((len = input.read(buffer)) != -1){
                    output.write(buffer,0,len);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (output != null)
                        output.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
​
                try {
                    if (input != null)
                        input.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
}

字符流VS字节流总结：

字符流操作文本文件：.txt .java .c .各种语言

字节流操作非文本文件：.doc .avi .mp3 .mp4 …

注意：字节流也是可以复制文本文件的，但是注意整个过程中，不要在控制台查看文件内容，否则会出现字符乱码；如果实现文本文件的拷贝是可以使用字节流进行操作的；

反之，字符流是不可以拷贝非文本文件的，尽管拷贝成功，但是该非文本文件并不是拷贝的，无法加载。

欢迎关注微信公众号：小红的成长日记，一起学Java！