最常见的十六种IO流

什么是IO？

I：input，O：Output

通过IO可以完成硬盘文件的读和写。

IO流的分类：

1、按照流的方向来划分：（以内存作为参照物）往内存中去叫做：输入（Input），或者叫做：读（Read）；从内存中和出来叫做：输出（Output），或者叫做：写（Write）。

2、按照读取数据的方式不同划分：按照字节的方式读取数据，一次读取一个字节byte，等同于一次读取8个二进制位，这种流是万能的，什么类型的文件都可以读取；有的流是按照字符的方式读取，一次读取一个字符，这种流是为了方便读取普通文本文件而存在的。

综上所述：流分为：输入流，输出流，字节流，字符流。

IO流的四大家族：

java.io.InputStream 字节输入流

java.io.OutputStream 字节输出流

java.io.Reader 字符输入流

java.io.Writer 字符输出流

*总结：Java中只要类名以Stream结尾的都是字节流，以Reader\Writer结尾的都是字符流。

*所有的流都实现了：java.io.Closeable接口，都有Close（）方法，都是可以关闭的；养成好习惯，流用完以后都要关闭。

*所有的输出流都实现了：java.io.Flushable接口，都有Flush（）方法，都是可以刷新的；养成好习惯，用过输出流以后都要使用Flush（）方法，来将管道内的数据强行的输出完（清空管道）！！！

Java.io包下需要掌握的流有16个：

文件专属：

java.io.FileInputStream

java.io.FileOutputStream

java.io.FileReader

java.io.FileWriter

转换流：(将字节流转化为字符流)

java.io.InputStreamReader

java.io.OutputStreamWriter

缓冲流专属：

java.io.BufferedReader

java.io.BufferedWriter

java.io.BufferedInputStream

java.io.BufferedOutputStream

数据流专属：

java.io.DataInputStream

java.io.DataOutptStream

标准输出流：

java.io.PrintWriter

java.io.PrintReader

对象专属流：

java.io.ObjectInputStream

java.io.ObjectOutPutStream

常用流的使用：

FileInputStream：

public class FileInputStreamTest02 {
    public static void main(String[] args) {
        FileInputStream fis = null;
//        准备一个长度自定义的byte数组
        byte[] bytes = new byte[4];
        try {
            fis = new FileInputStream("F:\\iotest\\test02.txt");
            //开始读
            int readCount = 0;
            while ((readCount = fis.read(bytes)) != -1) {
                System.out.print(new String(bytes,0,readCount));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
           if (fis != null) {
               try {
                   fis.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
        }
    }
}

FileOutputStream：

public class FileOutputStreamTest01 {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
//            fos = new FileOutputStream("F:\\iotest\\test03.txt");//当文件不存在的时候，会自动新建文件
            开始写
            byte[] bytes = {97,98,99,100,101,102};
            将byte数组全部写出
//            fos.write(bytes);
            将byte数组的一部分写出
//            fos.write(bytes,0,2);
            **********以上方式谨慎使用，它会在写入之前将原文件清空
            fos = new FileOutputStream("F:\\iotest\\test03.txt",true);
            fos.write(bytes);
            String s = "啦啦啦啦啦啦啦";
            byte[] bytes1= s.getBytes(StandardCharsets.UTF_8);
            fos.write(bytes1);
//            写完之后刷新
            fos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            if (fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileReader：

public class FileReaderTest01 {
    public static void main(String[] args) {
        FileReader reader = null;
        try {
            reader = new FileReader("F:\\iotest\\test04.txt");
            char[] chars = new char[4];
            int readCount = 0;
            while ((readCount = reader.read(chars)) != -1) {
                System.out.println(new String(chars,0,readCount));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileWriter:

public class FileWriterTest01 {
    public static void main(String[] args) {
        FileWriter fileWriter = null;
        try {
            fileWriter = new FileWriter("F:\\iotest\\test04.txt",true);
            char[] chars = {'山','大','地','纬'};
            fileWriter.write(chars);
            fileWriter.write("我是一名Java软件工程师");
//            输出流一定要刷新
            fileWriter.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            if (fileWriter != null) {
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}