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();}}}