1.字节流

（1）文件字节输入流：FileInputStream（读取硬盘，写入内存）

（2）文件字节输出流：FileOutputStream（读取内存、写入硬盘）

2.字符流

（3）文件字符输入流：FileReader（读取硬盘，写入内存）

（4）文件字符输出流：FileWriter（读取内存、写入硬盘）

????????文件字节流案例：使用FileInputStream+FileOutputStream复制粘贴文件，如下：

package com.dhrj.zs.file;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * created by on 2022/4/26
 * 描述：文件拷贝：使用FileInputStream + FileOutputStream
 * 一边读一边写，字节流方式可拷贝任意类型文件
 *
 * @author ZSAndroid
 * @create 2022-04-26-16:50
 */
public class FileStreamCopyTest {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            //复制目标(读取硬盘文件 到 内存数据)
            fis = new FileInputStream("MyJavaFileOutputStream");
            //粘贴目标(写出内存数据 到 硬盘文件)
            fos = new FileOutputStream("src/com/dhrj/zs/MyJavaFileOutputStream", true);
            //同时进行读写业务
            byte[] bytes = new byte[1024 * 1024];//1024B * 1024B = 1048576B = 1024KB =  1mb
            int readByteNum;
            while ((readByteNum = fis.read(bytes)) != -1) {
                fos.write(bytes, 0, readByteNum);
            }
            //刷新输出流管道
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

????????文件字符流案例：使用FileReader+FileWrter复制粘贴文件，如下：?

package com.dhrj.zs.file;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * created by on 2022/4/26
 * 描述：文件拷贝：使用FileReader + FileWriter
 * 一边读一边写，字符流方式仅支持拷贝普通文本文件
 *
 * @author ZSAndroid
 * @create 2022-04-26-18:02
 */
public class FileReaderWriterCopyTest {
    public static void main(String[] args) {
        FileReader fileReader = null;
        FileWriter fileWriter = null;
        try {
            fileReader = new FileReader("file");//读取输入
            fileWriter = new FileWriter("file2", true);//写出输出

            char[] chars = new char[1024 * 512]; // 1个char为2个字节，1024 * 512 = 1MB
            //同时读写业务
            int readerNum;
            while ((readerNum = fileReader.read(chars)) != -1) {
                fileWriter.write(chars, 0, readerNum);
            }
            //刷新输出流管道
            fileWriter.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileReader != null) {
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fileWriter != null) {
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

?二、转换流(字节流转字符流)

1.输入

????????字节输入流转换字符输入流InputStreamReader（仅作为转换）

2.输出

????????字节输出流转换字符输出流OutStreamWriter（仅作为转换）

三、缓冲流

1.字节流

（1）缓冲字节输入流BufferedInputStream（读取硬盘，写入内存）

（2）缓冲字节输出流BufferedOutputStream（读取内存、写入硬盘）

2.字符流+转换流

（1）缓冲字符输入流BufferedReader（读取硬盘，写入内存）

（2）缓冲字符输出流BufferedWriter（读取内存、写入硬盘

????????缓冲区字节输入流使用代码如下：?

package com.dhrj.zs.buffer;

import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * created by on 2022/4/26
 * 描述：缓冲区字节输入流
 *
 * @author ZSAndroid
 * @create 2022-04-26-19:04
 */
public class BufferInputStreamTest {
    public static void main(String[] args) {
        BufferedOutputStream bos = null;
        try {
            bos = new BufferedOutputStream(new FileOutputStream("MyBufferedOutputStream"));
            byte[] bytes = {'Z', 'S', 'A', 'n', 'd', 'r', 'o', 'i', 'd'};
            bos.write(bytes);
            //刷新输出流管道
            bos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

????????缓冲区字节输出流使用代码如下：

package com.dhrj.zs.buffer;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * created by on 2022/4/26
 * 描述：缓冲区字节输出流
 *
 * @author ZSAndroid
 * @create 2022-04-26-19:05
 */
public class BufferOutInputStreamTest {
    public static void main(String[] args) {
        BufferedInputStream bis = null;
        try {
            bis = new BufferedInputStream(new FileInputStream("MyJavaFileOutputStream"));
            byte[] bytes = new byte[1024 * 1024];  //每次读取1MB
            int readByteCount;
            while ((readByteCount = bis.read(bytes)) != -1) {
                System.out.println(new String(bytes, 0, readByteCount));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bis != null) {
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

????????缓冲区字符输入流 + InputStreamReader转换流(字节流转换为字符流)使用代码如下：?

package com.dhrj.zs.buffer;

import java.io.*;

/**
 * created by on 2022/4/26
 * 描述：缓冲区字符输入流 + InputStreamReader转换流(字节流 转换为 字符流)
 *
 * @author ZSAndroid
 * @create 2022-04-26-18:37
 */
public class BufferReaderTest {
    public static void main(String[] args) {
        BufferedReader reader = null;
        try {
            //FileInputStream 节点流 InputStreamReader 包装流 相对角度
            //InputStreamReader 节点流 BufferedReader 包装流 相对角度
            reader = new BufferedReader(new InputStreamReader(new FileInputStream("file")));
            String strResult = null;
            while ((strResult = reader.readLine()) != null) {
                System.out.println(strResult);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    //只需关闭包装流即可，底层源码自动关闭节点流
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

????????缓冲区字符输出流 + OutputStreamWriter转换流(字节流转换为字符流)?使用代码如下：?

package com.dhrj.zs.buffer;

import java.io.*;

/**
 * created by on 2022/4/26
 * 描述：缓冲区字符输出流  + OutputStreamWriter转换流(字节流 转换为 字符流)
 *
 * @author ZSAndroid
 * @create 2022-04-26-18:46
 */
public class BufferWriterTest {
    public static void main(String[] args) {
        BufferedWriter bufferedWriter = null;
        try {
            //FileOutputStream 节点流 OutputStreamWriter 包装流 相对角度
            //OutputStreamWriter 节点流 BufferedWriter 包装流 相对角度
            bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("MyBufferedWriter", true)));
            bufferedWriter.write("BufferWriterTest文件写入成功");
            //刷新输出流管道
            bufferedWriter.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bufferedWriter != null) {
                try {
                    //只需关闭包装流即可，底层源码自动关闭节点流
                    bufferedWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

?四、数据流（不常用）

1.DataInputStream(可以将非普通文本文件中的数据连同数据类型一并写入加密文件，打开乱码，只能用DataOutputStream按照写入顺序一致才能提取文件内容)

2.DataOutputStream（只能使用DataInputStream来读，读的顺序需要和写的顺序一致，才可以正常取出数据）

?五、标准输出流

1.PrintWriter

2.PrintStream

????????标准输出流PrintStream：更改控制台输出方向为MyPrintStreamFile文件使用代码如下：

package com.dhrj.zs.print;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * created by on 2022/4/26
 * 描述：标准输出流：更改控制台输出方向为MyPrintStreamFile文件
 *
 * @author ZSAndroid
 * @create 2022-04-26-20:20
 */
public class PrintStreamTest {
    public static void main(String[] args) {
        LogUtil.log("使用Java标准输出流自定义日志工具类，将打印输出的信息写入log.txt文件里");
    }
}

/**
 * 自定义打印日志工具类
 */
class LogUtil {
    public static void log(String msg) {
        PrintStream printStream = null;
        try {
            //指向日志文件log.txt，自动追加
            printStream = new PrintStream(new FileOutputStream("log.txt", true));
            //改变输出方向
            System.setOut(printStream);
            Date date = new Date();
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
            String strTime = simpleDateFormat.format(date);
            System.out.println(strTime + ":" +msg);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (printStream != null) {
                printStream.close();
            }
        }
    }
}