IO流详解及常用方法

1.1. 什么是IO流

IO流： Input/Output Stream

流: 指的是一串流动的数据，在数据在流中按照指定的方向进行流动。实现数据的读取、写入的功能。

1.2. IO流的使用场景

使用File类，只能做关于文件的操作，获取属性、创建文件、删除文件、移动文件等操作，但是不包含读取文件中的内容。如果需要读取、修改文件中的内容，此时就需要使用IO流来完成了。

使用场景: 对某一个文件进行读取或者写入操作。

注意事项:
IO流是对一个文件进行读写的，不是一个文件夹！在使用IO流的时候，不要建立与一个文件夹的连接。

1.3. IO流的分类

按照不同的分类标准，能够得到不同分类的IO流：

按照流中流动的数据单位：

字节流：流中流动的数据，是以字节为单位的。

字符流: 流中流动的数据，是以字符为单位的。

按照流中数据流动的方向：

输入流：数据从文件流动到程序中。

输出流：数据从程序流动到文件中。

2.基础的IO流

2.1. 基础的IO流类的简介

其实在 http://java.io 包中，有很多很多的类，都是来描述IO流的。但是基本上所有的IO流的类，都是直接或间接的继承自四大父类流。

字节输入流: InputStream

字节输出流: OutputStream

字符输入流： Reader

字符输出流: Writer

2.2. IO流使用的注意事项

四大父类流，都是抽象类，都不能实例化对象。因此，需要借助他们的子类实现数据的读写。

流对象一旦实例化完成，将建立一个程序与文件之间的连接。这个连接会持有这个文件。如果这个连接不断，此时这个文件就是一个被使用中的状态，此时将无法对这个文件进行其他的操作，例如删除。

一个流在使用完成之后，切记！一定要进行流的关闭。

2.3. 建立程序与文件的连接

其实，就是建立了程序与文件之间连接的管道，实现数据在这个管道之内进行流动。管道分为不同的类型：字节输入流、字节输出流、字符输入流、字符输出流。下面以字节输入流 InputStream 为例。

2.3.1. 标准流程

try结构外面，声明流对象，为了在finally中使用。

在try结构里面，实例化流对象，并捕获异常。

在finally结构中，对流进行关闭。在关闭的时候，需要考虑流对象是否是null，以及要处理 IOException 异常。

importjava.io.*;/**
 * @Description 测试文件与程序的连接建立
 */publicclassIO1{publicstaticvoidmain(String[]args){// 在外面声明变量
InputStreaminputStream=null;try{// 实例化一个FileInputStream对象，向上转型为InputStream类型类型。
// 这个实例化如果完成，将会建立程序与文件之间的连接。
// 建立好之后，数据就可以从文件中流动到程序中。
// 注意: 数据流动到程序中，并不意味着文件中没有数据了！
// 这个过程中，会出现 FileNotFoundException 的异常，原因: 路径写错了，这个路径上没有文件
inputStream=newFileInputStream("file\\day25\\source");// 数据的读取操作
// 在数据读取的过程中，也会出现 IOException 异常。一旦出现异常，后序的代码都不执行了，直接执行catch语句了
// 流的关闭，不能放到try里面。需要放到finally中。
}catch(FileNotFoundExceptione){e.printStackTrace();}finally{// 流在使用结束之后，一定要进行关闭。
if(inputStream!=null){try{inputStream.close();}catch(IOExceptione){e.printStackTrace();}}}}}

2.3.2. try结构的特使使用

在 JDK1.7 之后，可以在try后面添加一对小括号。将 AutoClosable 接口实现类的对象，实例化放到小括号中完成。此时，在try结构执行结束的时候，会自动的调用AutoClosable接口实现类中的close方法，进行流的关闭。这样写的流的建立比较简单，也是后面我们最主要使用的方式。

importjava.io.*;/**
 * @Description 常见的IO流的创建的方式
 */publicclassIO2{publicstaticvoidmain(String[]args){/**
         * try结构的特殊语法: try ()
         * 将 AutoClosable 接口的实现类对象的实例化放到小括号中。
         * 此时，在离开了try结构的时候，会自动的对这个类进行close方法的调用
         */try(InputStreaminputStream=newFileInputStream("file\\day25\\source")){
		// 数据的读取操作
}catch(FileNotFoundExceptione){e.printStackTrace();}catch(IOExceptione){e.printStackTrace();}System.out.println(newFile("file\\day25\\source").delete());}}

2.4. InputStream

2.4.1. InputStream简介

这是一个字节输入流。从方向来说，是一个输入流，数据是从文件中流动到程序中，是为了读取文件中的数据的。从数据单位来说，这个流中流动的数据是以字节为单位的。

2.4.2. 文件的读取

importjava.io.FileInputStream;importjava.io.FileNotFoundException;importjava.io.IOException;importjava.io.InputStream;/**
 * @Description 使用字节流进行数据的读取
 */publicclassInputStreamTest{publicstaticvoidmain(String[]args){// 1. 建立程序与文件之间的连接，用来读取这个文件
try(InputStreaminputStream=newFileInputStream("file\\day25\\source")){// 2. 读取字节流中的数据，需要有一个字节数组，用来读取数据
//    这个数组长度，不用和文件一样大小，找一个大小合适的数组读取即可
byte[]array=newbyte[32];// 3. 声明一个整型变量，用来记录每次读取了多少个字节的数据
intlength=0;// 3. 循环读取数据
while((length=inputStream.read(array))!=-1){// 将读取到的字节数组中的数据，转成字符串输出
// 为了去除最后一次进行读取数据的时候，上次读取残留的问题
// 最后一次读取的数据，只有指定部分是我们需要的数据
Stringstr=newString(array,0,length);System.out.print(str);}}catch(IOExceptione){e.printStackTrace();}}}

2.5. OutputStream

2.5.1. OutputStream简介

字节输出流。从方向上来分，是一个输出流，数据从程序中流动到文件中，实现文件的写操作。从流中流动的数据单位来分，是一个字节流，流中流动的数据是以字节为单位的。

2.5.2. 文件的写

importjava.io.FileNotFoundException;importjava.io.FileOutputStream;importjava.io.IOException;importjava.io.OutputStream;/**
 * @Description 字节输出流，写文件
 */publicclassOutputStreamTest{publicstaticvoidmain(String[]args){// 1. 实例化一个管道，连接文件和程序。
//    对于FileOutputStream来说，如果目标文件不存在，则会自动的创建。
//    当无法创建这个文件的时候(父级目录不存在)，创建会失败，会触发 FileNotFoundException 。
try(OutputStreamoutputStream=newFileOutputStream("file\\day25\\dst",true)){// 2. 准备需要写入到这个文件中的数据
Stringmessage="你好，师姐";// 3. 将数据写入到输出流中，由输出流写入到文件中
outputStream.write(message.getBytes());// 冲刷缓冲区，将缓冲区中的数据强制流动到文件中。
// 在流关闭的时候，会自动的调用。
outputStream.flush();}catch(IOExceptione){e.printStackTrace();}}}

2.6. 案例: 文件拷贝

2.6.1. 需求分析

实现，将一个文件拷贝到另外一个地方。注意，这个不是剪切，拷贝完成之后，原文件还在。

实现方式：借助两个流来完成。

使用字节流输入，循环读取原文件中的数据。

使用字节输出流，将每次读取到的数据，写入到目标文件中。

2.6.2. 示例代码

importjava.io.*;/**
 * @Description 使用字节流实现文件的拷贝
 */publicclassFileCopy{publicstaticvoidmain(String[]args){booleanret=copy("C:\\Users\\luds\\Desktop\\src.mp4","C:\\Users\\luds\\Desktop\\dst.mp4");System.out.println(ret);}/**
     * 实现功能: 将源文件中的数据拷贝到目标文件
     * @param srcPath 原文件路径
     * @param dstPath 目标文件路径
     * @return 拷贝的结果
     */privatestaticbooleancopy(StringsrcPath,StringdstPath){// 1. 判断目标路径上，是否有文件存在
Filedst=newFile(dstPath);if(dst.exists()){returnfalse;}// 2. 实现文件的拷贝
try(InputStreaminputStream=newFileInputStream(srcPath);OutputStreamoutputStream=newFileOutputStream(dst)){// 拷贝的过程
// 2.1. 实例化一个字节数组
byte[]array=newbyte[1024];// 2.2. 声明一个整型变量，用来记录每次读取到了多少个字节的数据
intlength=0;// 2.3. 循环读取数据
while((length=inputStream.read(array))!=-1){// 2.4. 将读取到的数据，写入到输出流中
outputStream.write(array,0,length);}// 2.5. 冲刷缓冲区
outputStream.flush();returntrue;}catch(IOExceptione){e.printStackTrace();returnfalse;}}}

2.7. Reader

2.7.1. Reader的简介

这是一个字符输入流。从方向来说，是一个输入流，数据是从文件中流动到程序中，是为了读取文件中的数据的。从数据单位来说，这个流中流动的数据是以字符为单位的。

2.7.2. 读取文件

importjava.io.FileReader;importjava.io.IOException;importjava.io.Reader;/**
 * @Description 字符输入流读取数据
 */publicclassReaderTest{publicstaticvoidmain(String[]args){// 读取过程与字节输入流完全相同，只需要将使用到的类换一下即可。
try(Readerreader=newFileReader("file\\day25\\src")){// 1. 实例化一个字符数组
char[]array=newchar[100];// 2. 声明一个变量，用来记录每次读取到了多少个数据
intlength=0;// 3. 循环读取数据
while((length=reader.read(array))!=-1){Stringstr=newString(array,0,length);System.out.print(str);}}catch(IOExceptione){e.printStackTrace();}}}

2.8. Writer

2.8.1. Writer的简介

字符输出流。从方向上来分，是一个输出流，数据从程序中流动到文件中，实现文件的写操作。从流中流动的数据单位来分，是一个字符流，流中流动的数据是以字符为单位的。

2.8.2. 文件的写操作

importjava.io.FileWriter;importjava.io.IOException;importjava.io.Writer;/**
 * @Description 使用字符流写数据
 */publicclassWriterTest{publicstaticvoidmain(String[]args){// 1. 实例化相关的类
try(Writerwriter=newFileWriter("file\\day25\\target",true)){// 2. 将数据写入到输出流中
writer.write("hello, world");// 3. 冲刷缓冲区
writer.flush();}catch(IOExceptione){e.printStackTrace();}}}

2.9. 案例: 文件拷贝

2.9.1. 需求分析

实现，将一个文件拷贝到另外一个地方。注意，这个不是剪切，拷贝完成之后，原文件还在。

实现方式：借助两个流来完成。

使用字符输入流，循环读取原文件中的数据。

使用字符输出流，将每次读取到的数据，写入到目标文件中。

2.9.2. 示例代码

/**
  * 使用字符流实现文件的拷贝
  * @param srcPath 原文件路径
  * @param dstPath 目标文件路径
  */privatestaticvoidfileCopy2(StringsrcPath,StringdstPath){// 2. 循环读取目标文件中的数据
try(Readerreader=newFileReader(srcPath);Writerwriter=newFileWriter(dstPath)){// 3. 循环读取源文件中的数据
char[]array=newchar[100];intlength=0;while((length=reader.read(array))!=-1){// 4. 将读取到的数据写入到输出流
writer.write(array,0,length);}writer.flush();returntrue;}catch(IOExceptione){e.printStackTrace();returnfalse;}}

3. 常见的其他流

3.1. 缓冲流

3.1.1. 缓冲流的简介

给普通的IO流，套上一个缓冲区。所有的使用缓冲流进行的读写操作，都是和缓冲区进行交互的，避免了频繁的IO操作。这样一来，带来的好处就是可以提高读写的效率。这个缓冲区，其实是一个数组。

常见的缓冲流:

BufferedInputStream : 缓冲字节输入流

BufferedOutputStream ：缓冲字节输出流

BufferedReader ：缓冲字符输入流

BufferedWriter ：缓冲字符输出

3.1.2. 缓冲字节流

importjava.io.BufferedInputStream;importjava.io.FileInputStream;importjava.io.IOException;/**
 * @Description BufferedInputStream使用
 */publicclassBufferedInputStreamTest{publicstaticvoidmain(String[]args){// 过程和InputStream一模一样的
// 缓冲字节输入流流是需要基于一个字节输入流来进行实例化的
// 在这里，BufferedInputStream构造方法中的InputStream对象，只是用来做当前的对象的实例化，在使用结束的时候，理论上来讲，是需要关闭的
// 实际在使用中，使用结束后，只需要关闭BufferedInputStream即可。
try(BufferedInputStreambufferedInputStream=newBufferedInputStream(newFileInputStream("file\\day26\\source"))){// 1. 实例化一个字节数组
byte[]array=newbyte[1024];// 2. 声明一个整型变量，用来记录每次读取了多少个字节数据
intlength=0;// 3. 循环读取
while((length=bufferedInputStream.read(array))!=-1){// 4. 将读取到的数据转成字符串输出到控制台
Stringmsg=newString(array,0,length);System.out.println(msg);}}catch(IOExceptione){e.printStackTrace();}}}

importjava.io.BufferedOutputStream;importjava.io.FileOutputStream;importjava.io.IOException;/*
 * @Description BufferedOutputStream
 */publicclassBufferedOutputStreamTest{publicstaticvoidmain(String[]args){// 1. 实例化一个缓冲字节输出流对象
try(BufferedOutputStreambufferedOutputStream=newBufferedOutputStream(newFileOutputStream("file\\day26\\target"))){// 2. 将数据写入到输出流中
bufferedOutputStream.write("hello world".getBytes());bufferedOutputStream.flush();}catch(IOExceptione){e.printStackTrace();}}}

3.1.3. 缓冲字符流

importjava.io.BufferedReader;importjava.io.FileReader;importjava.io.IOException;/**
 * @Description
 */publicclassBufferedReaderTest{publicstaticvoidmain(String[]args){// 借助一个字符流，实例化一个缓冲字符输入流
try(BufferedReaderbufferedReader=newBufferedReader(newFileReader("file\\day26\\src"))){// 从流中读取数据
char[]array=newchar[100];intlength=0;while((length=bufferedReader.read(array))!=-1){System.out.print(newString(array,0,length));}}catch(IOExceptione){e.printStackTrace();}}}

importjava.io.BufferedWriter;importjava.io.FileWriter;importjava.io.IOException;/**
 * @Description
 */publicclassBufferedWriterTest{publicstaticvoidmain(String[]args){// 借助一个字符输出流，实例化一个缓冲字符输出流对象
try(BufferedWriterbufferedWriter=newBufferedWriter(newFileWriter("file\\day26\\dst"))){bufferedWriter.write("hello world");bufferedWriter.flush();}catch(IOExceptione){e.printStackTrace();}}}

3.1.4. 缓冲流中的特殊方法

BufferedReader 类中多了一个方法 readLine()

意义: 读取缓冲流中的一行数据，可以逐行读取。一直到读取到的数据是null，表示数据读取完了，没有下一行数据了。

注意事项: readLine() 是逐行读取，但是，只能读取到一行中的内容，并不能读取走换行符。

importjava.io.BufferedReader;importjava.io.FileReader;importjava.io.IOException;/*
 * @Date 2020/4/26
 * @Description
 */publicclassBufferedReaderSpecial{publicstaticvoidmain(String[]args){try(BufferedReaderreader=newBufferedReader(newFileReader("file\\day26\\src"))){// 1. 定义一个字符串，用来接收每一行读取到的数据
Stringline="";// 2. 循环读取数据
while((line=reader.readLine())!=null){// 3. 将读取到的数据输出
System.out.println(line);}}catch(IOExceptione){e.printStackTrace();}}

BufferedWriter 类中多了一个方法 newLine()

意义：无参的方法，写一个换行符。

importjava.io.BufferedWriter;importjava.io.FileWriter;importjava.io.IOException;/**
 * @Description
 */publicclassBufferedWriterSpecial{publicstaticvoidmain(String[]args){try(BufferedWriterbufferedWriter=newBufferedWriter(newFileWriter("file\\day26\\dst"))){bufferedWriter.write("hello world");bufferedWriter.newLine();bufferedWriter.write("你好，世界");bufferedWriter.newLine();bufferedWriter.write("end");}catch(IOExceptione){e.printStackTrace();}}}

使用缓冲字符流进行文件的拷贝

importjava.io.*;/**
 * @Description 使用缓冲字符流实现文本文件的拷贝
 */publicclassBufferedCopy{publicstaticvoidmain(String[]args){try(BufferedReaderreader=newBufferedReader(newFileReader("file\\day26\\src"));BufferedWriterwriter=newBufferedWriter(newFileWriter("file\\day26\\destination"))){Stringline="";while((line=reader.readLine())!=null){writer.write(line);writer.newLine();}writer.flush();}catch(IOExceptione){e.printStackTrace();}}

3.2. Scanner类

3.2.1. 简介

这个类，并不是一个IO流。是一个扫描器，这个类最主要的作用，是从一个文件中或者从一个流中浏览数据。在这个类中封装了若干个方法，方便了数据的读取。

3.2.2. API

注意事项

这里nextLine和BufferedReader中的readLine都可以读取一行数据。但是区别在于：结束条件不同。

BufferedReader: 如果读取到的数据是null, 说明没有下一行数据了。

Scanner: 如果没有下一行了，再去读取，会出现异常。所以，此时的结束条件是 hasNextLine() 为false。

importjava.io.File;importjava.io.FileNotFoundException;importjava.util.Scanner;importjava.util.regex.Pattern;/**
 * @Description Scanner类的方法
 */publicclassScannerTest{publicstaticvoidmain(String[]args){// 其实，Scanner在使用结束之后，也是需要进行关闭的。 调用close方法。
try(Scannerscanner=newScanner(newFile("file\\day26\\src"))){// 读取文件中的内容
while(scanner.hasNextLine()){System.out.println(scanner.hasNextLine());}}catch(FileNotFoundExceptione){e.printStackTrace();}}

3.3. 标准输入输出流

3.3.1. 简介

标准输入流: http://System.in : 连接了程序和控制台。读取控制台中的内容。

标准输出流: System.out ：连接了程序和控制台。将程序中的内容输出到控制台。

3.3.2. 标准输入流

importjava.io.BufferedInputStream;importjava.io.IOException;importjava.util.Scanner;/**
 * @Description 标准输入流
 */publicclassSystemInTest{publicstaticvoidmain(String[]args){try(BufferedInputStreambis=newBufferedInputStream(System.in)){byte[]array=newbyte[128];intlength=0;while((length=bis.read(array))!=-1){Stringstr=newString(array,0,length);System.out.println(str);}}catch(IOExceptione){e.printStackTrace();}}}

3.3.3. 标准输出流

importjava.io.File;importjava.io.FileOutputStream;importjava.io.IOException;importjava.io.PrintStream;/**
 * @Description 标准输出流
 */publicclassSystemOutTest{publicstaticvoidmain(String[]args){PrintStreamoriginal=System.out;// PrintStream: 是一个打印流，可以将数据输出到指定位置。
try(PrintStreamps=newPrintStream(newFileOutputStream("file\\day26\\logs",true))){// ps.println("hello world！");
// 重定向标准输出流
System.setOut(ps);System.out.println("123");}catch(IOExceptione){e.printStackTrace();}finally{System.setOut(original);}System.out.println("你好");// System.out;      标准输出流地址
// System.out -> ps
}}

3.4. 转换流

3.4.1. 为什么要用转换流

在进行文件读取的时候，如果项目采用的字符集和文件的字符集不同，会出现乱码的情况。

3.4.2. 输入流

importjava.io.*;/**
 * @Description 转换流
 *      转换输入流：可以以指定的字符集读取某一个文件中的数据
 *      转换输出流：可以以指定的字符集把数据写入到某一个文件
 */publicclassTransforeTest{publicstaticvoidmain(String[]args){read();}privatestaticvoidread(){// 当前的项目是 utf-8, 读取的文件是 GBK
// 如果需要以指定的字符集进行文件的读取，需要使用 InputStreamReader(InputStream inputStream, String charsetName)
try(InputStreamReaderreader=newInputStreamReader(newFileInputStream("file\\day26\\src"),"GBK")){char[]array=newchar[128];intlength=0;while((length=reader.read(array))!=-1){System.out.println(newString(array,0,length));}}catch(IOExceptione){e.printStackTrace();}}}

3.4.3. 输出流

importjava.io.*;/**
 * @Description 转换流
 *      转换输入流：可以以指定的字符集读取某一个文件中的数据
 *      转换输出流：可以以指定的字符集把数据写入到某一个文件
 */publicclassTransforeTest{publicstaticvoidmain(String[]args){write();}privatestaticvoidwrite(){// 以指定的字符集写数据
try(OutputStreamWriterwriter=newOutputStreamWriter(newFileOutputStream("file\\day26\\dst",true),"GBK")){writer.write("hello world");writer.write("你好，世界");}catch(IOExceptione){e.printStackTrace();}}}

3.5. 对象流

3.5.1. 简介

ObjectInputStream、 ObjectOutputStream，主要是用来做对象的序列化和反序列化的。

序列化：将内存中的某个对象，以文件的形式保存到本地。

反序列化：将本地保存的某一个文件，信息读取出来，存到某一个对象中。

序列化、反序列化，是对象的持久化存储的一种常用手段。

3.5.2. 注意事项

所有的要序列化到本地的类的对象，类必须实现 java.io.Serilizable 接口。

如果需要序列化多个文件到本地，尽量不要序列化到一个文件中。如果需要序列化多个文件到本地，通常采用的方式，是村集合。将多个对象存入一个集合中，将这个集合序列化到本地。

3.5.3. 示例代码

importjava.io.*;/**
 * @Description
 */publicclassTest{publicstaticvoidmain(String[]args){load();}/**
     * 反序列化
     */privatestaticvoidload(){try(ObjectInputStreaminputStream=newObjectInputStream(newFileInputStream("file\\day26\\person"))){// 读取文件中的数据
Objectobj=inputStream.readObject();if(objinstanceofPerson){Personxiaoming=(Person)obj;System.out.println(xiaoming);}}catch(IOException|ClassNotFoundExceptione){e.printStackTrace();}}/**
     * 序列化
     */privatestaticvoidsave(){// 实例化一个Person对象
Personxiaoming=newPerson("xiaoming",12,100);// 序列化对象
try(ObjectOutputStreamoutputStream=newObjectOutputStream(newFileOutputStream("file\\day26\\person"))){// 序列化
outputStream.writeObject(xiaoming);outputStream.flush();}catch(IOExceptione){e.printStackTrace();}}}

3.6. Properties

3.6.1. 简介

Properties也不是一个IO流，是一个集合。是Hashtable的子类。

使用Properties主要是为了描述程序中的属性列表文件。有时候，我们会将一些比较简单的项目的配置信息，以 .properties 格式的文件进行存储。可以使用Properties对象读写 .properties 文件。

3.6.2. 示例代码

importjava.io.FileReader;importjava.io.FileWriter;importjava.io.IOException;importjava.util.Properties;/**
 * @Description
 */publicclassProgram{publicstaticvoidmain(String[]args){// 1. 实例化一个Properties对象
Propertiesproperties=newProperties();// 2. 加载一个 .properties 文件中的数据
try{properties.load(newFileReader("file\\day27\\my.properties"));}catch(IOExceptione){e.printStackTrace();}// 3. 遍历
System.out.println(properties);// 4. 键值对的增删改查
//    由于这个类是Map的实现类，因此在Map集合中定义的所有的方法，它都有。
//    但是，对于Properties类的来说，增删改查基本上不用从Map中继承到的方法。
//    因为，从Map集合中继承下来的方法，键和值都是Object类型的。
// 4.1. 可以在集合中新增一个键值对，也可以修改集合中的存在的键值对。
properties.setProperty("userlevel","12");properties.setProperty("password","ABCDEFG");// 4.2. 通过键，获取值
Stringlevel=properties.getProperty("userlevel");Stringid=properties.getProperty("userid","123");System.out.println(properties);// 5. 将内存中的数据，同步到文件中
try{properties.store(newFileWriter("file\\day27\\my.properties"),"hello");}catch(IOExceptione){e.printStackTrace();}}}