Java SE I/O流

分类

按方向 \ 按流量	字节流	字符流
输入流	InputStream	Reader
输出流	OutputStream	Writer

常用流分类

	字节输入流	字节输出流	字符输入流	字符输出流
	FileInputStream	FileOutputStream	FileReader	FileWriter
缓冲流	BufferedInputStream	BufferedOutputStream	BufferedReader	BufferedWriter
转换流			InputStreamReader	OutputStreamWriter

注意

• 文本文件 ------> 字符流
• 非文本文件 -----> 字节流

流的使用

1、节点流

案例1：文本文件复制

/**
 * 学习 FileReader  &  FileWriter
 * 案例：文件复制
 * 分解：读取文件  --->  写入文件
 */
public class FileCopy {

    public static void main(String[] args) throws Exception {
        // 有个目标文件，用来接流的数据
        File inputFile = new File("D:\\text.txt");
        File outputFile = new File("D:\\write.txt");

        // 有个输入\出流
        FileReader fileReader = new FileReader(inputFile);
        FileWriter fileWriter = new FileWriter(outputFile); //需要指定接收数据的文件

        // 开始读取输入
        char[] chars = new char[1024]; //使用缓冲数组
        int len;
        while ((len = fileReader.read(chars)) != -1){
            // 开始输出
            fileWriter.write(chars,0,len); // 使用缓冲数组的有效位
        }

        // 关流 后开启的就先关闭
        fileWriter.close();
        fileReader.close();
    }
}

案例2：图片复制

/**
 * 学习 FileInputStream  &  FileOutputStream
 * 案例：非文本文件复制
 * 分解：读取文件  --->  写入文件
 */
public class Test02 {
    public static void main(String[] args) throws Exception {
        File file1 = new File("D:\\奔驰.png");
        File file2 = new File("D:\\奔驰2.png");

        FileInputStream inputStream = new FileInputStream(file1);
        FileOutputStream outputStream = new FileOutputStream(file2);

        byte[] bytes = new byte[1024];
        int len;
        while ((len = inputStream.read(bytes)) != -1){
            outputStream.write(bytes,0,len);
        }

        outputStream.close();
        inputStream.close();
    }
}

2、处理流

案例1：缓冲流 ---> 图片复制

/**
 * 学习 缓冲流：BufferedInputStream  &  BufferedOutputStream
 * 案例：图片复制
 * 分解：先获取文件字节流，再用缓冲流套着字节流
 */
public class Test01 {
    public static void main(String[] args) throws Exception{
        File file1 = new File("D:\\小公主.jpg");
        File file2 = new File("D:\\小公主1.jpg");

        //创建节点流
        FileInputStream inputStream = new FileInputStream(file1);
        FileOutputStream outputStream = new FileOutputStream(file2);

        //创建处理流
        BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);

        byte[] bytes = new byte[1024 * 8];
        int len = 0;
        while ((len = bufferedInputStream.read(bytes)) != -1){
            //这一步自动有刷新缓冲区的操作
            bufferedOutputStream.write(bytes,0,len);
        }

        //如果处理流包裹着节点流，那么关闭处理流时节点流会同步关闭
        bufferedOutputStream.close();
        bufferedInputStream.close();
//        outputStream.close();
//        inputStream.close();
    }
}

案例2：缓冲流 ---> 文本复制

/**
 * 学习 缓冲流：BufferedReader  &  BufferedWriter
 * 案例：文本文件复制
 * 分解：先获取文件字符流，再用缓冲流套着字符流
 */
public class Test02 {
    public static void main(String[] args) throws Exception{
        File file1 = new File("D:\\text.txt");
        File file2 = new File("D:\\write.txt");

        FileReader inputStream = new FileReader(file1);
        FileWriter outputStream = new FileWriter(file2);

        BufferedReader bufferedReader = new BufferedReader(inputStream);
        BufferedWriter bufferedWriter = new BufferedWriter(outputStream);

/*        char[] chars = new char[1024 * 8];
        int len = 0;
        while ((len = bufferedReader.read(chars)) != -1){
            bufferedWriter.write(chars,0,len);
        }*/

        String s = bufferedReader.readLine();
        while (s != null){
            bufferedWriter.write(s);
            bufferedWriter.newLine();
            s = bufferedReader.readLine();
        }

        bufferedWriter.close();
        bufferedReader.close();
    }
}

案例3：转换流 ---> 文本读取

/**
 * 学习 转换流：InputStreamReader 
 * 案例：文本文件读取
 * 分解：先获取文件字节流，再用转换流套着字节流
 */
public class Test03 {
    public static void main(String[] args) throws Exception{
        File file1 = new File("D:\\text.txt");
        File file2 = new File("D:\\write.txt");

        FileInputStream inputStream = new FileInputStream(file1);
        FileOutputStream outputStream = new FileOutputStream(file2);

        //加入转换流
        InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputStream,"UTF-8");

        char[] chars = new char[1024];
        int len;
        while ((len = inputStreamReader.read(chars)) != -1){
            System.out.println(new String(chars,0,len));
        }

        inputStreamReader.close();
        outputStreamWriter.close();
    }
}

案例4：转换流 ---> 文本复制

/**
 * 学习 转换流：OutputStreamWriter
 * 案例：文本文件复制
 * 分解：先获取文件字节流，再用转换流套着字节流
 */
public class Test03 {
    public static void main(String[] args) throws Exception{
        File file1 = new File("D:\\text.txt");
        File file2 = new File("D:\\write.txt");

        FileInputStream inputStream = new FileInputStream(file1);
        FileOutputStream outputStream = new FileOutputStream(file2);

        //加入转换流
        InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputStream,"GBK");

        char[] chars = new char[1024];
        int len;
        while ((len = inputStreamReader.read(chars)) != -1){
            outputStreamWriter.write(chars,0,len);
        }

        outputStreamWriter.close();
        inputStreamReader.close();
    }
}