流的概念

流：在 Java中所有数据都是使用流读写的。流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。
即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。
流的作用：为数据源和目的地建立一个输送通道

流的分类：

• 按流向分：输入流 、输出流
• 按处理数据的单位分：字节流（8位的字节）、字符流（16位的字节）

什么是输入，输出

输入就是将数据从各种输入设备（包括文件、键盘等）中读取到内存中。
输出则正好相反，是将数据写入到各种输出设备（比如文件、显示器、磁盘等）。
从文件角度简单总结就是，输入流就是读数据，输出流就是写数据。在这个过程中，始终把内存作为参考点。

什么是字节流，字符流

如果要处理文件内容，必须要通过流的操作模式来完成。
在java.io包中，流分为两种：字节流与字符流
字节流：数据流中最小的数据单元是字节 。InputStream、OutputStream。
字符流：数据流中最小的数据单元是字符， Java中的字符是Unicode编码，一个字符占用两个字节。Reader、Writer。

字节流

1、 FileInputStream 和 FileOutputStream

• FileInputStream从文件系统中的某个文件中获得输入字节,用于读取诸如图像数据之类的原始字节流
• FileOutputStream文件输出流是用于将数据写入到输出流 File 或一个 FileDescriptor 。

举个例子:现在先找到我"D:\bit"此路径下得到"hello.txt"文件,然后再次路径下再复制一份一样的文件.

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Solution {
    public static void main(String[] args) throws IOException {
        FileInputStream fin = new FileInputStream("D:\\bit\\hello.txt");
        FileOutputStream fout = new FileOutputStream("D:\\bit\\hell0Copy.txt");
        int len = 0;
        byte[] buff = new byte[1024];
        while ((len = fin.read(buff)) != -1) {
            fout.write(buff, 0, len);
        }
        fin.close();
        fout.close();
    }
}

2. BufferedInputStream 和 BufferedOutputStream

为什么需要缓存流?
答：当我们用read()读取文件时，每读一个字节，访问一次硬盘，效率很低 。文件过大时，操作起来也不是很方便。因此我们需要用到buffer缓存流，当创建buffer对象时，会创建一个缓冲区数组。当我们读一个文件时，先从硬盘中读到缓冲区，然后直接从缓冲区输出即可，效率会更高.

• BufferedInputStream 为另一个输入流添加了功能创建 BufferedInputStream 时，将创建一个内部缓冲区数组
• BufferedOutputStream实现缓冲输出流.应用程序可以向底层输出流写入字节

举例:使用 BufferedInputStream 和 BufferedOutputStream 实现文件拷贝

import java.io.*;
public class Solution {
    public static void main(String[] args) throws IOException {
        File file = new File("bit.txt");
        if (!file.isFile()) {
            return;
        }
        BufferedInputStream bfis = new BufferedInputStream(new FileInputStream(file));
        BufferedOutputStream bfos = new BufferedOutputStream(new
                FileOutputStream("D:\\bit" + file.getName()));//copy到src目录下
        byte bytes[] = new byte[1024];
        int temp = 0; //边读边写
        while ((temp = bfis.read(bytes)) != -1) {//读
            bfos.write(bytes, 0, temp); //写
        }
        bfos.flush();
        bfos.close();
        bfis.close();
        System.out.println("copy成功！");
    }
}

字符流

1、字符流 FileReader 和 FileWriter

• 如果要从文件中读取内容，可以直接使用 FileReader 子类
• 如果是向文件中写入内容，应该使用 FileWriter 子类

复制文件

import java.io.*;
public class Solution {
    public static void main(String[] args) throws IOException {
        //创建输入流对象
        FileReader fr = new FileReader("D:\\bit\\bitSrc.java");
        //创建输出流对象
        FileWriter fw = new FileWriter("D:\\bit\\bitCopy.java");
        //读写数据
        int ch;
        while((ch=fr.read())!=-1) {
            fw.write(ch);
        }
        //释放资源
        fw.close();
        fr.close();
    }
}

2、字符缓冲流 BufferedReader 和 BufferedWriter

为了提高字符流读写的效率，引入了缓冲机制，进行字符批量的读写，提高了单个字符读写的效率。

• BufferedReader 用于加快读取字符的速度
• BufferedWriter 用于加快写入的速度

import java.io.*;
public class Solution {
    public static void main(String[] args) throws IOException {
        FileReader reader=new FileReader("D:\\Ideaproject\\bit.txt");
        BufferedReader bReader=new BufferedReader(reader);
        FileWriter writer=new FileWriter("D:\\Ideaproject\\bit2.txt");
        BufferedWriter bWriter=new BufferedWriter(writer);
        String content="";
        //readLine一行一行的读取
        while((content=bReader.readLine())!=null){
        //\r\n换行
            bWriter.write(content+"\r\n");
        }
        /**
         * 关闭流的顺序：
         * 当A依赖B的时候先关闭A，再关闭B
         * 带缓冲的流最后关闭的时候会执行一次flush
         */
        reader.close();
        bReader.close();
        bWriter.close();
        writer.close();
    }
}

字节流对比字符流

字符字节转换流

OutputStreamWriter 和 InputStreamReader

• InputStreamReader 是Reader的子类，将输入的字节流转换成字符流
• OutputStreamWriter 是Writer的子类，将输出的字符流转换成字节流

import java.io.*;
public class Solution {
    public static void main(String[] args) {
        // 创建字节流对象 System.in 代表从控制台输入
        InputStream in = System.in;
        // 创建字符流对象
        BufferedWriter bw = null;
        BufferedReader br = null;
        try {
            // 实例化字符流对象 通过 InputStreamReader 将字节输入流转化成字符输入流
            br = new BufferedReader(new InputStreamReader(in));
            //br = new BufferedReader(new InputStreamReader(in,"GBK"));
            bw = new BufferedWriter(new FileWriter("a.txt"));
            // 定义读取数据的行
            String line = null;
            // 读取数据
            while ((line = br.readLine()) != null) {
                // 如果输入的是"exit"就退出
                if ("exit".equals(line)) {
                    break;
                }
                // 将数据写入文件
                bw.write(line);
                // 写入新的一行
                bw.newLine();
                // 刷新数据缓冲
                bw.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 释放资源
            try {
                if (bw != null)
                    bw.close();
                if (br != null)
                    br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

import java.io.*;
public class Solution {
    public static void main(String[] args) {
        // 定义字节输出流的对象System.out
        OutputStream out = System.out;
        // 定义字符流的对象
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            //通过OutputStreamWriter将字符转流换为字节流对象
            bw = new BufferedWriter(new OutputStreamWriter(out));
            //bw = new BufferedWriter(new OutputStreamWriter(out,"GBK"));
            br = new BufferedReader(new FileReader("a.txt"));
            // 定义读取行的字符串
            String line = null;
            // 读取数据
            while ((line = br.readLine()) != null) {
                // 输出到控制台
                bw.write(line);
                // 新的一行
                bw.newLine();
                // 刷新缓冲
                bw.flush();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (bw != null)
                    bw.close();
                if (br != null)
                    br.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}