java io流

一、IO流是什么？
1、IO流概念

IO（Input Output）用于实现对数据的输入与输出操作，Java把不同的输入/输出源（键盘、文件、网络等）抽象表述为流（Stream），简单来说就是对于数据的输入/输出操作以流的方式进行。流是从起源到接收的有序数据，有了它程序就可以采用同一方式访问不同的输入/输出源。
 

2、IO流原理及流的分类

1、按照数据流向，可以将流分为输入流和输出流，其中输入流只能读取数据、不能写入数据，而输出流只能写入数据、不能读取数据。

输入流（input）：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。 输出流（output）：将程序（内存）数据输出到硬盘、光盘等存储设备中。

2、按照数据类型，可以将流分为字节流和字符流，其中字节流操作的数据单元是8位的字节，而字符流操作的数据单元是16位的字符。

3、按照处理功能，可以将流分为节点流（低级流）和处理流（高级流），其中节点流可以直接从/向一个特定的IO设备（磁盘、网络等）读/写数据，也称为低级流，而处理流是对节点流的连接或封装，用于简化数据读/写功能或提高效率，也称为高级流。

节点流：可以从或向一个特定的地方（节点）读写数据。如FileInputStream，FileReader。

 处理流：是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。如BufferedReader、BufferedWriter。处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。

 节点流是直接作用在文件上的流，可以理解为一个管道，文件在管道中传输。

 处理流是作用在已有的节点流基础上，是包在节点流的外面的管道(可多层)，其目的是让管道内的流可以更快的传输。
 

根据命名很容易理解各个流的作用：

• 以File开头的文件流用于访问文件；
• 以ByteArray/CharArray开头的流用于访问内存中的数组；
• 以Piped开头的管道流用于访问管道，实现进程之间的通信；
• 以String开头的流用于访问内存中的字符串；
• 以Buffered开头的缓冲流，用于在读写数据时对数据进行缓存，以减少IO次数；
• InputStreamReader、InputStreamWriter是转换流，用于将字节流转换为字符流；
• 以Object开头的流是对象流，用于实现对象的序列化；
• 以Print开头的流是打印流，用于简化打印操作；
• 以Pushback开头的流是推回输入流，用于将已读入的数据推回到缓冲区，从而实现再次读取；

 

1、FileInputStream 字节流

FileInputStream文件输入流。它通常用于对文件进行读取操作。
注意：这里读取中文会发生乱码，所以有用到读取中文（字符），可以使用字符流来操作。

  //1、读取文件的路径
        String filePath = "D:\\hwx.txt";
        FileInputStream fileInputStream = null;
        byte[] bytes = new byte[8];
        int read = 0;
        try {
            //2、创建对象FileInputStream用来读取文件内容
            fileInputStream = new FileInputStream(filePath);
            //3、如果返回-1，表示文件读取完毕
            while ((read = fileInputStream.read(bytes))!=-1){
                System.out.print(new String(bytes,0,read));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                //4、关闭流
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

2、FileReader 字符流

//1、读取文件的路径
        String filePath = "D:\\hwxs.txt";
        FileReader fileReader = null;
        int read = 0;
        char[] bytes =new char[1024];
        try {
            //2、创建对象FileReader用来读取文件内容
            fileReader = new FileReader(filePath);
            //3、如果返回-1，表示文件读取完毕
            while ((read = fileReader.read(bytes))!=-1){
                System.out.print(new String(bytes,0,read));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                //4、关闭流 这样用if判断，是因为如果没有创建FileReader成功，去关闭会报错
                if(fileReader!=null) {
                    fileReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

3、BufferedInputStream 字节处理流

  //1、读取文件的路径
        String filePath = "D:\\hwxs.txt";
        BufferedInputStream bufferedInputStream = null;
        byte[] bytes = new byte[8];
        int read = 0;
        try {
            //2、创建对象BufferedInputStream用来读取文件
            bufferedInputStream = new BufferedInputStream(new FileInputStream(filePath));
            //3、如果返回-1，表示文件读取完毕
            while ((read = bufferedInputStream.read(bytes)) != -1) {
                System.out.print(new String(bytes, 0, read));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //4、关闭流，注意只需要关闭bufferedInputStream处理流，底层会自动关闭节点流。
                if(bufferedInputStream!=null){
                    bufferedInputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

4、BufferedReader 字符处理流

//1、读取文件的路径
        String filePath = "D:\\hwxs.txt";
        BufferedReader bufferedReader = null;
        char[] bytes = new char[8];
        int read = 0;
        String line = null;//按行读取
        try {
            //2、创建对象FileInputStream用来读取文件内容
            bufferedReader = new BufferedReader(new FileReader(filePath));
            //3、如果返回-1，表示文件读取完毕
            while ((read = bufferedReader.read(bytes)) != -1) {
                System.out.print(new String(bytes, 0, read));
            }
            //3、如果返回null，表示文件读取完毕，按行读取（效率高）
            while ((line = bufferedReader.readLine())!=null){
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //4、关闭流，注意只需要关闭bufferedReader处理流，底层会自动关闭节点流。
                if(bufferedReader!=null){
                    bufferedReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

二、输出流 使用代码示例

1、FileOutputS

	//1、写入文件的路径
        String filePath = "D:\\hwxs.txt";
        FileOutputStream fileOutputStream = null;
        try {
             //根据项目需求，二选一
            //2、创建对象FileOutputStream用来写入文件内容
            fileOutputStream = new FileOutputStream(filePath);//会覆盖原来内容
            fileOutputStream = new FileOutputStream(filePath,true);//在原来的内容后面进行追加
            //3
            //3.1、写入一个字节
            fileOutputStream.write('A');
            //3.2、写入字符串
            fileOutputStream.write("JavaIo".getBytes());
            //3.3、将len字节从位于偏移量off的指定字节数组写入此文件输出流
            //write(byte b[], int off, int len)
            fileOutputStream.write("JavaIo".getBytes(),0,"JavaIo".length());
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                //4、关闭流
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

2、FileWriter 字符流

	//1、写入文件的路径
        String filePath = "D:\\hwxs.txt";
        FileWriter fileWriter = null;
        try {
            //2、创建对象FileOutputStream用来写入文件内容(根据需求2选其一)
            fileWriter = new FileWriter(filePath);//会覆盖原来内容
            fileWriter = new FileWriter(filePath,true);//在原来的内容后面进行追加
            //3
            //3.1、写入一个字节
            fileWriter.write('A');
            //3.2、写入字符串
            fileWriter.write("JavaIo流我最爱");
            //3.3、将len字节从位于偏移量off的指定字节数组写入此文件输出流
            //write(byte b[], int off, int len) 写入字符串指定部位
            fileWriter.write("JavaIo流我最爱".toCharArray(),0,"JavaIo流我最爱".length());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //4、关闭流
                if (fileWriter != null) {
                    fileWriter.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

3、BufferedOutputStream 字符处理流

	//1、写入文件的路径
        String filePath = "D:\\hwxs.txt";
        //2、创建对象BufferedOutputStream用来写入文件
        BufferedOutputStream bufferedOutputStream = null;

        try {
            //根据项目需求，二选一
            bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(filePath));//会覆盖原来内容
           // bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(filePath,true));//在原来的内容后面进行追加

            //3.1、写入一个字节
            bufferedOutputStream.write('A');
            //3.2、写入字符串
            bufferedOutputStream.write("JavaIo".getBytes());
            //3.3、将len字节从位于偏移量off的指定字节数组写入此文件输出流
            //write(byte b[], int off, int len) 写入字符串指定部位
            bufferedOutputStream.write("JavaIo".getBytes(),0,"JavaIo".length());

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(bufferedOutputStream!=null){
                    bufferedOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

4、BufferedWriter 字符处理流

 //1、写入文件的路径
        String filePath = "D:\\hwxs.txt";
        //2、创建对象BufferedWriter用来写入文件内容
        BufferedWriter bufferedWriter = null;
        try {
              //根据项目需求，二选一
              //会覆盖原来内容
            bufferedWriter = new BufferedWriter(new FileWriter(filePath));
            //在原来的内容后面进行追加
            bufferedWriter = new BufferedWriter(new FileWriter(filePath,true));
            bufferedWriter.write("我是第一行");
            
            //插入一个换行符
            bufferedWriter.newLine();
            
            bufferedWriter.write("我是第二行");

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(bufferedWriter!=null){
                    bufferedWriter.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }