带你从零学大数据系列之Java篇---第二十六章:IO流详解
课程大纲:
- IO流的简介
- 基础的IO流(重点)
- 常见的其他流
http://1.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 异常。
import java.io.*;
/**
* @Description 测试文件与程序的连接建立
*/
public class IO1 {
public static void main(String[] args) {
// 在外面声明变量
InputStream inputStream = null;
try {
// 实例化一个FileInputStream对象，向上转型为InputStream类型类型。
// 这个实例化如果完成，将会建立程序与文件之间的连接。
// 建立好之后，数据就可以从文件中流动到程序中。
// 注意: 数据流动到程序中，并不意味着文件中没有数据了！
// 这个过程中，会出现 FileNotFoundException 的异常，原因: 路径写错了，这个路径上没有文件
inputStream = new FileInputStream("file\\day25\\source");
// 数据的读取操作
// 在数据读取的过程中，也会出现 IOException 异常。一旦出现异常，后序的代码都不执行了，直接执行catch语句了
// 流的关闭，不能放到try里面。需要放到finally中。
} catch (FileNotFoundException e) {
e.printStackTrace();
} finally {
// 流在使用结束之后，一定要进行关闭。
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}2.3.2. try结构的特使使用
在 JDK1.7 之后， 可以在try后面添加一对小括号。 将 AutoClosable 接口实现类的对象， 实例化放到小括号中完成。 此时， 在try结构执行结束的时候， 会自动的调用AutoClosable接口实现类中的close方法， 进行流的关闭。 这样写的流的建立比较简单， 也是后面我们最主要使用的方式。
import java.io.*;
/**
* @Description 常见的IO流的创建的方式
*/
public class IO2 {
public static void main(String[] args) {
/**
* try结构的特殊语法: try ()
* 将 AutoClosable 接口的实现类对象的实例化放到小括号中。
* 此时，在离开了try结构的时候，会自动的对这个类进行close方法的调用
*/
try (InputStream inputStream = new FileInputStream("file\\day25\\source")) {
// 数据的读取操作
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
System.out.println(new File("file\\day25\\source").delete());
}
}2.4. InputStream
2.4.1. InputStream简介
这是一个字节输入流。 从方向来说， 是一个输入流， 数据是从文件中流动到程序中， 是为了读取文件中的数据的。 从数据单位来说， 这个流中流动的数据是以字节为单位的。
2.4.2. 文件的读取
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
/**
* @Description 使用字节流进行数据的读取
*/
public class InputStreamTest {
public static void main(String[] args) {
// 1. 建立程序与文件之间的连接，用来读取这个文件
try (InputStream inputStream = new FileInputStream("file\\day25\\source")) {
// 2. 读取字节流中的数据，需要有一个字节数组，用来读取数据
// 这个数组长度，不用和文件一样大小，找一个大小合适的数组读取即可
byte[] array = new byte[32];
// 3. 声明一个整型变量，用来记录每次读取了多少个字节的数据
int length = 0;
// 3. 循环读取数据
while ((length = inputStream.read(array)) != -1) {
// 将读取到的字节数组中的数据，转成字符串输出
// 为了去除最后一次进行读取数据的时候，上次读取残留的问题
// 最后一次读取的数据，只有指定部分是我们需要的数据
String str = new String(array, 0, length);
System.out.print(str);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}2.5. OutputStream
2.5.1. OutputStream简介
字节输出流。 从方向上来分， 是一个输出流， 数据从程序中流动到文件中， 实现文件的写操作。 从流中流动的数据单位来分， 是一个字节流， 流中流动的数据是以字节为单位的。
2.5.2. 文件的写
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
/**
* @Description 字节输出流，写文件
*/
public class OutputStreamTest {
public static void main(String[] args) {
// 1. 实例化一个管道，连接文件和程序。
// 对于FileOutputStream来说，如果目标文件不存在，则会自动的创建。
// 当无法创建这个文件的时候(父级目录不存在)，创建会失败，会触发 FileNotFoundException 。
try (OutputStream outputStream = new FileOutputStream("file\\day25\\dst", true)) {
// 2. 准备需要写入到这个文件中的数据
String message = "你好，师姐";
// 3. 将数据写入到输出流中，由输出流写入到文件中
outputStream.write(message.getBytes());
// 冲刷缓冲区，将缓冲区中的数据强制流动到文件中。
// 在流关闭的时候，会自动的调用。
outputStream.flush();
} catch (IOException e) {
e.printStackTrace();
}
}
}
2.6. 案例: 文件拷贝
2.6.1. 需求分析
实现， 将一个文件拷贝到另外一个地方。 注意， 这个不是剪切， 拷贝完成之后， 原文件还在。
实现方式： 借助两个流来完成。
- 使用字节流输入， 循环读取原文件中的数据。
- 使用字节输出流， 将每次读取到的数据， 写入到目标文件中。
2.6.2. 示例代码
import java.io.*;
/**
* @Description 使用字节流实现文件的拷贝
*/
public class FileCopy {
public static void main(String[] args) {
boolean ret = copy("C:\\Users\\luds\\Desktop\\src.mp4", "C:\\Users\\luds\\Desktop\\dst.mp4");
System.out.println(ret);
}
/**
* 实现功能: 将源文件中的数据拷贝到目标文件
* @param srcPath 原文件路径
* @param dstPath 目标文件路径
* @return 拷贝的结果
*/
private static boolean copy(String srcPath, String dstPath) {
// 1. 判断目标路径上，是否有文件存在
File dst = new File(dstPath);
if (dst.exists()) {
return false;
}
// 2. 实现文件的拷贝
try (InputStream inputStream = new FileInputStream(srcPath);
OutputStream outputStream = new FileOutputStream(dst)) {
// 拷贝的过程
// 2.1. 实例化一个字节数组
byte[] array = new byte[1024];
// 2.2. 声明一个整型变量，用来记录每次读取到了多少个字节的数据
int length = 0;
// 2.3. 循环读取数据
while ((length = inputStream.read(array)) != -1) {
// 2.4. 将读取到的数据，写入到输出流中
outputStream.write(array, 0, length);
}
// 2.5. 冲刷缓冲区
outputStream.flush();
return true;
}
catch (IOException e) {
e.printStackTrace();
return false;
}
}
}2.7. Reader
2.7.1. Reader的简介
这是一个字符输入流。 从方向来说， 是一个输入流， 数据是从文件中流动到程序中， 是为了读取文件中的数据的。 从数据单位来说， 这个流中流动的数据是以字符为单位的。
2.7.2. 读取文件
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
/**
* @Description 字符输入流读取数据
*/
public class ReaderTest {
public static void main(String[] args) {
// 读取过程与字节输入流完全相同，只需要将使用到的类换一下即可。
try (Reader reader = new FileReader("file\\day25\\src")) {
// 1. 实例化一个字符数组
char[] array = new char[100];
// 2. 声明一个变量，用来记录每次读取到了多少个数据
int length = 0;
// 3. 循环读取数据
while ((length = reader.read(array)) != -1) {
String str = new String(array, 0, length);
System.out.print(str);
}
}
catch (IOException e) {
e.printStackTrace();
}
}
}2.8. Writer
2.8.1. Writer的简介
字符输出流。 从方向上来分， 是一个输出流， 数据从程序中流动到文件中， 实现文件的写操作。 从流中流动的数据单位来分， 是一个字符流， 流中流动的数据是以字符为单位的。
2.8.2. 文件的写操作
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
/**
* @Description 使用字符流写数据
*/
public class WriterTest {
public static void main(String[] args) {
// 1. 实例化相关的类
try (Writer writer = new FileWriter("file\\day25\\target", true)) {
// 2. 将数据写入到输出流中
writer.write("hello, world");
// 3. 冲刷缓冲区
writer.flush();
}
catch (IOException e) {
e.printStackTrace();
}
}
}
2.9. 案例: 文件拷贝
2.9.1. 需求分析
实现， 将一个文件拷贝到另外一个地方。 注意， 这个不是剪切， 拷贝完成之后， 原文件还在。
实现方式： 借助两个流来完成。
- 使用字符输入流， 循环读取原文件中的数据。
- 使用字符输出流， 将每次读取到的数据， 写入到目标文件中。
2.9.2. 示例代码
/**
* 使用字符流实现文件的拷贝
* @param srcPath 原文件路径
* @param dstPath 目标文件路径
*/
private static void fileCopy2(String srcPath, String dstPath) {
// 2. 循环读取目标文件中的数据
try (Reader reader = new FileReader(srcPath); Writer writer = new FileWriter(dstPath)) {
// 3. 循环读取源文件中的数据
char[] array = new char[100];
int length = 0;
while ((length = reader.read(array)) != -1) {
// 4. 将读取到的数据写入到输出流
writer.write(array, 0, length);
}
writer.flush();
return true;
}
catch (IOException e) {
e.printStackTrace();
return false;
}
}3. 常见的其他流
3.1. 缓冲流
3.1.1. 缓冲流的简介
给普通的IO流， 套上一个缓冲区。 所有的使用缓冲流进行的读写操作， 都是和缓冲区进行交互的， 避免了频繁的IO操作。 这样一来， 带来的好处就是可以提高读写的效率。 这个缓冲区， 其实是一个数组。
常见的缓冲流:
- BufferedInputStream : 缓冲字节输入流
- BufferedOutputStream ： 缓冲字节输出流
- BufferedReader ： 缓冲字符输入流
- BufferedWriter ： 缓冲字符输出
3.1.2. 缓冲字节流
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
/**
* @Description BufferedInputStream使用
*/
public class BufferedInputStreamTest {
public static void main(String[] args) {
// 过程和InputStream一模一样的
// 缓冲字节输入流流是需要基于一个字节输入流来进行实例化的
// 在这里，BufferedInputStream构造方法中的InputStream对象，只是用来做当前的对象的实例化，在使用结束的时候，理论上来讲，是需要关闭的
// 实际在使用中，使用结束后，只需要关闭BufferedInputStream即可。
try (BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("file\\day26\\source"))) {
// 1. 实例化一个字节数组
byte[] array = new byte[1024];
// 2. 声明一个整型变量，用来记录每次读取了多少个字节数据
int length = 0;
// 3. 循环读取
while ((length = bufferedInputStream.read(array)) != -1) {
// 4. 将读取到的数据转成字符串输出到控制台
String msg = new String(array, 0, length);
System.out.println(msg);
}
}
catch (IOException e) {
e.printStackTrace();
}
}
}
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* @Description BufferedOutputStream
*/
public class BufferedOutputStreamTest {
public static void main(String[] args) {
// 1. 实例化一个缓冲字节输出流对象
try (BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("file\\day26\\target"))) {
// 2. 将数据写入到输出流中
bufferedOutputStream.write("hello world".getBytes());
bufferedOutputStream.flush();
} catch (IOException e) {
e.printStackTrace();
}
}
}3.1.3. 缓冲字符流
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
/**
* @Description
*/
public class BufferedReaderTest {
public static void main(String[] args) {
// 借助一个字符流，实例化一个缓冲字符输入流
try (BufferedReader bufferedReader = new BufferedReader(new FileReader("file\\day26\\src"))) {
// 从流中读取数据
char[] array = new char[100];
int length = 0;
while ((length = bufferedReader.read(array)) != -1) {
System.out.print(new String(array, 0, length));
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
/**
* @Description
*/
public class BufferedWriterTest {
public static void main(String[] args) {
// 借助一个字符输出流，实例化一个缓冲字符输出流对象
try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("file\\day26\\dst"))) {
bufferedWriter.write("hello world");
bufferedWriter.flush();
} catch (IOException e) {
e.printStackTrace();
}
}
}3.1.4. 缓冲流中的特殊方法
BufferedReader 类中多了一个方法 readLine()
- 意义: 读取缓冲流中的一行数据， 可以逐行读取。 一直到读取到的数据是null， 表示数据读取完了， 没有下一行数据了。
- 注意事项: readLine() 是逐行读取， 但是， 只能读取到一行中的内容， 并不能读取走换行符。
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
/*
* @Date 2020/4/26
* @Description
*/
public class BufferedReaderSpecial {
public static void main(String[] args) {
try (BufferedReader reader = new BufferedReader(new FileReader("file\\day26\\src"))) {
// 1. 定义一个字符串，用来接收每一行读取到的数据
String line = "";
// 2. 循环读取数据
while ((line = reader.readLine()) != null) {
// 3. 将读取到的数据输出
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
}BufferedWriter 类中多了一个方法 newLine()
- 意义： 无参的方法， 写一个换行符。
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
/**
* @Description
*/
public class BufferedWriterSpecial {
public static void main(String[] args) {
try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("file\\day26\\dst"))) {
bufferedWriter.write("hello world");
bufferedWriter.newLine();
bufferedWriter.write("你好，世界");
bufferedWriter.newLine();
bufferedWriter.write("end");
} catch (IOException e) {
e.printStackTrace();
}
}
}使用缓冲字符流进行文件的拷贝
import java.io.*;
/**
* @Description 使用缓冲字符流实现文本文件的拷贝
*/
public class BufferedCopy {
public static void main(String[] args) {
try (BufferedReader reader = new BufferedReader(new FileReader("file\\day26\\src"));
BufferedWriter writer = new BufferedWriter(new FileWriter("file\\day26\\destination"))) {
String line = "";
while ((line = reader.readLine()) != null) {
writer.write(line);
writer.newLine();
}
writer.flush();
}
catch (IOException e) {
e.printStackTrace();
}
}3.2. Scanner类
3.2.1. 简介
这个类， 并不是一个IO流。 是一个扫描器， 这个类最主要的作用， 是从一个文件中或者从一个流中浏览数据。 在这个类中封装了若干个方法， 方便了数据的读取。
3.2.2. API
注意事项
这里nextLine和BufferedReader中的readLine都可以读取一行数据。 但是区别在于： 结束条件不同。
- BufferedReader: 如果读取到的数据是null, 说明没有下一行数据了。
- Scanner: 如果没有下一行了，再去读取，会出现异常。 所以， 此时的结束条件是 hasNextLine() 为false。
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
import java.util.regex.Pattern;
/**
* @Description Scanner类的方法
*/
public class ScannerTest {
public static void main(String[] args) {
// 其实，Scanner在使用结束之后，也是需要进行关闭的。 调用close方法。
try (Scanner scanner = new Scanner(new File("file\\day26\\src"))) {
// 读取文件中的内容
while (scanner.hasNextLine()) {
System.out.println(scanner.hasNextLine());
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}3.3. 标准输入输出流
3.3.1. 简介
标准输入流: http://System.in : 连接了程序和控制台。 读取控制台中的内容。
标准输出流: System.out ： 连接了程序和控制台。 将程序中的内容输出到控制台。
3.3.2. 标准输入流
import java.io.BufferedInputStream;
import java.io.IOException;
import java.util.Scanner;
/**
* @Description 标准输入流
*/
public class SystemInTest {
public static void main(String[] args) {
try (BufferedInputStream bis = new BufferedInputStream(System.in)) {
byte[] array = new byte[128];
int length = 0;
while ((length = bis.read(array)) != -1) {
String str = new String(array, 0, length);
System.out.println(str);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}3.3.3. 标准输出流
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
/**
* @Description 标准输出流
*/
public class SystemOutTest {
public static void main(String[] args) {
PrintStream original = System.out;
// PrintStream: 是一个打印流，可以将数据输出到指定位置。
try (PrintStream ps = new PrintStream(new FileOutputStream("file\\day26\\logs", true))) {
// ps.println("hello world！");
// 重定向标准输出流
System.setOut(ps);
System.out.println("123");
}
catch (IOException e) {
e.printStackTrace();
} finally {
System.setOut(original);
}
System.out.println("你好");
// System.out; 标准输出流地址
// System.out -> ps
}
}3.4. 转换流
3.4.1. 为什么要用转换流
在进行文件读取的时候， 如果项目采用的字符集和文件的字符集不同，会出现乱码的情况。
3.4.2. 输入流
import java.io.*;
/**
* @Description 转换流
* 转换输入流：可以以指定的字符集读取某一个文件中的数据
* 转换输出流：可以以指定的字符集把数据写入到某一个文件
*/
public class TransforeTest {
public static void main(String[] args) {
read();
}
private static void read() {
// 当前的项目是 utf-8, 读取的文件是 GBK
// 如果需要以指定的字符集进行文件的读取，需要使用 InputStreamReader(InputStream inputStream, String charsetName)
try (InputStreamReader reader = new InputStreamReader(new FileInputStream("file\\day26\\src"), "GBK")) {
char[] array = new char[128];
int length = 0;
while ((length = reader.read(array)) != -1) {
System.out.println(new String(array, 0, length));
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
3.4.3. 输出流
import java.io.*;
/**
* @Description 转换流
* 转换输入流：可以以指定的字符集读取某一个文件中的数据
* 转换输出流：可以以指定的字符集把数据写入到某一个文件
*/
public class TransforeTest {
public static void main(String[] args) {
write();
}
private static void write() {
// 以指定的字符集写数据
try (OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream("file\\day26\\dst", true), "GBK")) {
writer.write("hello world");
writer.write("你好，世界");
} catch (IOException e) {
e.printStackTrace();
}
}
}3.5. 对象流
3.5.1. 简介
ObjectInputStream、 ObjectOutputStream， 主要是用来做对象的序列化和反序列化的。
- 序列化： 将内存中的某个对象， 以文件的形式保存到本地。
- 反序列化： 将本地保存的某一个文件， 信息读取出来， 存到某一个对象中。
序列化、 反序列化， 是对象的持久化存储的一种常用手段。
3.5.2. 注意事项
- 所有的要序列化到本地的类的对象， 类必须实现
java.io.Serilizable接口。 - 如果需要序列化多个文件到本地， 尽量不要序列化到一个文件中。 如果需要序列化多个文件到本地， 通常采用的方式， 是村集合。 将多个对象存入一个集合中， 将这个集合序列化到本地。
3.5.3. 示例代码
import java.io.*;
/**
* @Description
*/
public class Test {
public static void main(String[] args) {
load();
}
/**
* 反序列化
*/
private static void load() {
try(ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("file\\day26\\person"))) {
// 读取文件中的数据
Object obj = inputStream.readObject();
if (obj instanceof Person) {
Person xiaoming = (Person)obj;
System.out.println(xiaoming);
}
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
/**
* 序列化
*/
private static void save() {
// 实例化一个Person对象
Person xiaoming = new Person("xiaoming", 12, 100);
// 序列化对象
try (ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("file\\day26\\person"))) {
// 序列化
outputStream.writeObject(xiaoming);
outputStream.flush();
} catch (IOException e) {
e.printStackTrace();
}
}
}3.6. Properties
3.6.1. 简介
Properties也不是一个IO流， 是一个集合。 是Hashtable的子类。
使用Properties主要是为了描述程序中的属性列表文件。 有时候， 我们会将一些比较简单的项目的配置信息， 以 .properties 格式的文件进行存储。 可以使用Properties对象读写 .properties 文件。
3.6.2. 示例代码
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
/**
* @Description
*/
public class Program {
public static void main(String[] args) {
// 1. 实例化一个Properties对象
Properties properties = new Properties();
// 2. 加载一个 .properties 文件中的数据
try {
properties.load(new FileReader("file\\day27\\my.properties"));
} catch (IOException e) {
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. 通过键，获取值
String level = properties.getProperty("userlevel");
String id = properties.getProperty("userid", "123");
System.out.println(properties);
// 5. 将内存中的数据，同步到文件中
try {
properties.store(new FileWriter("file\\day27\\my.properties"), "hello");
} catch (IOException e) {
e.printStackTrace();
}
}
}