目录
一、IO 流技术介绍
1.1 什么是IO?
1.2 流的概念
1.3 数据源
1.3.1 什么是数据源?
1.3.2数据源的分类
二、第一个简单的IO流程序
三、IO流经典写法(适用于任何JDK版本)
四、IO流新语法经典写法(仅限于JDK1.7以后)
五、Java中流的概念细分
5.1 按流的方向分类
5.2 按处理的数据单元分类
5.3 按处理对象不同分类
六、Java中常用IO流类的体系
七、Java中IO的四大抽象类
7.1 InputStream
7.2 OutputStream
7.3 Reader
7.4 Writer
八、常用流详解
8.1 文件字节流
8.1.1 FileInputStream文件字节输入流
8.1.2 FileOutputStream文件字节输出流
8.1.3 通过字节缓冲区提高读写速度
8.1.4 缓冲字节流
8.2 文件字符流
8.2.1 FileReader文件字符输入流
8.2.2 FileWriter文件字符输出流
8.2.3 缓冲字符流
8.2.4 小练习:为文件中的内容添加行号
8.3 转换流
8.3.1 转换流处理乱码问题
8.3.2 小练习:通过字节流读取文本文件并添加行号
8.3.3 字符输出流
8.4 数据流
8.5 对象流
8.5.1 对象流处理基本数据类型
8.5.2 对象流将对象序列化到文件
8.5.3 将对象反序列化到内存中
九、File类在IO中的作用
十、装饰器模式构建IO流体系
10.1 装饰器模式简介
10.2 IO流体系中的装饰器模式
十一、Apache IO包
11.1 FileUtils类中常用方法的介绍
11.1.1使用FileUtils工具类读取文件
11.1.2使用FileUtils工具类实现目录拷贝
11.2 IOUtils的妙用
输入(Input)指的是:可以让程序从外部系统获得数据(核心含义是“读”,读取外部数据)。
输出(Output)指的是:程序输出数据给外部系统从而可以操作外部系统(核心含义是“写”,将数据写出到外部系统)。
输入/输出流的划分是相对程序而言的,并不是相对数据源。
流是一个抽象、动态的概念,是一连串连续动态的数据集合。
对于输入流而言,数据源就像水箱,流(stream)就像水管(水管实际上就是IO中不同的对象,不同的对象代表不同的管道)中流动着的水流,程序就是我们最终的用户。我们通过流(A Stream)将数据源(Source)中的数据(information)输送到程序(Program)中。
对于输出流而言,目标数据源就是目的地(dest),我们通过流(A Stream)将程序(Program)中的数据(information)输送到目的数据源(dest)中。
数据源data source,提供数据的原始媒介。常见的数据源有:数据库、文件、其他程序、内存、网络连接、IO设备。如图所示。
源设备:为程序提供数据,一般对应输入流。
目标设备:程序数据的目的地,一般对应输出流。
当程序需要读取数据源的数据时,就会通过IO流对象开启一个通向数据源的流,通过这个IO流对象的相关方法可以顺序读取数据源中的数据。
package cn.it.bz.IO;
import java.io.FileInputStream;
public class TestIO01 {
public static void main(String[] args) {
//先准备管道(流对象)
try {
FileInputStream fileInputStream = new FileInputStream("D:/a.txt");
int read1 = fileInputStream.read();//读取文件中的一个字节,返回该字节的ASCII码
int read2 = fileInputStream.read();//读取文件中第二个字节
int read3 = fileInputStream.read();//读取文件中第三个字节
int read4 = fileInputStream.read();//读取文件中第四个字节
System.out.println("输出第一个字节:"+read1);
System.out.println("输出第二个字节:"+read2);
System.out.println("输出第三个字节:"+read3);
System.out.println("输出第四个字节:"+read4); //读完后没东西读了,就输出-1
//关闭流,占用系统资源,可能造成系统崩溃
fileInputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
package cn.it.bz.IO;
import java.io.*;
public class TestIO02 {
public static void main(String[] args) {
FileInputStream fis = null;
try {
fis = new FileInputStream("d:/a.txt"); // 内容是:abc
StringBuilder sb = new StringBuilder();
int temp = 0;
//当temp等于-1时,表示已经到了文件结尾,停止读取
while ((temp = fis.read()) != -1) {
sb.append((char) temp); //将ASCII码转换为字符
}
System.out.println(sb);
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
//这种写法,保证了即使遇到异常情况,也会关闭流对象。
if (fis != null) {
fis.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
在JDK7以及以后的版本中可以使用try-with-resource语法更优雅的关闭资源。在java.lang.AutoCloseable接口中包含了一个close方法,该方法用于关闭资源。只要是实现了java.lang.AutoCloseable接口的对象,都可以使用try-with-resource关闭资源。
package cn.it.bz.IO;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class TestIO03 {
public static void main(String[] args) {
//使用try-with-resource方式关闭资源。
//在try中打开资源,不需要在代码中添加finally块关闭资源。
try(FileInputStream fileInputStream = new FileInputStream("D:/a.txt")){
StringBuilder stringBuilder = new StringBuilder();
int temp = 0;
while ((temp = fileInputStream.read()) != -1){
stringBuilder.append((char)temp);
}
System.out.println(stringBuilder);
}catch (IOException e){
}
}
}
”处理流的流”解释:
假设程序要读取外部文件中的内容,我们就要选择FileReader作为流对象,但是FileReader只能一个一个字符地读取文件中的字符,这时就需要使用BufferedReader、BufferedInputStream处理FileReader流对象,于是就不再是一个一个字符地读取文件,而是能实现一行一行地读取文件按。
节点流处于IO操作的第一线,所有操作必须通过它们进行;处理流可以对节点流进行包装,提高性能或提高程序的灵活性。
Java为我们提供了多种多样的IO流,我们可以根据不同的功能及性能要求挑选合适的IO流,如图所示,为Java中IO流类的体系。
从上图发现,很多流都是成对出现的,比如:FileInputStream/FileOutputStream,显然是对文件做输入和输出操作的。我们下面简单做个总结:
InputStream/OutputStream
字节流的抽象类。
Reader/Writer
字符流的抽象类。
FileInputStream/FileOutputStream
节点流:以字节为单位直接操作“文件”。
ByteArrayInputStream/ByteArrayOutputStream
节点流:以字节为单位直接操作“字节数组对象”。
ObjectInputStream/ObjectOutputStream
处理流:以字节为单位直接操作“对象”。
DataInputStream/DataOutputStream
处理流:以字节为单位直接操作“基本数据类型与字符串类型”。
FileReader/FileWriter
节点流:以字符为单位直接操作“文本文件”(注意:只能读写文本文件)。
BufferedReader/BufferedWriter
处理流:将Reader/Writer对象进行包装,增加缓存功能,提高读写效率。
BufferedInputStream/BufferedOutputStream
处理流:将InputStream/OutputStream对象进行包装,增加缓存功能,提高读写效率
InputStreamReader/OutputStreamWriter
处理流:将字节流对象转化成字符流对象。
PrintStream
处理流:将OutputStream进行包装,可以方便地输出字符,更加灵活。
文件字节流:sream结尾。
文件字符流:reader、writer结尾。
InputStream/OutputStream和Reader/writer类是所有IO流类的抽象父类,我们有必要简单了解一下这个四个抽象类的作用。然后,通过它们具体的子类熟悉相关的用法。
此抽象类是表示字节输入流的所有类的父类。InputSteam是一个抽象类,它不可以实例化。 数据的读取需要由它的子类来实现。根据节点的不同,它派生了不同的节点流子类 ,例如:FileInputStream 以字节为单位直接操作“文件”。
继承自InputSteam的流都是用于向程序中输入数据,且数据的单位为字节(8 bit)。
方法名 | 使用说明 |
int read() | 读取一个字节的数据,并将字节的值作为int类型(字符的ASCII码)返回(0-255之间的一个值)。如果未读出字节则返回-1(返回值为-1表示读取结束) |
void close() | 关闭输入流对象,释放相关系统资源 |
此抽象类是表示字节输出流的所有类的父类。输出流接收输出字节并将这些字节发送到某个目的地。
方法名 | 使用说明 |
void write(int n) | 向目的地中写入一个字节 |
void close() | 关闭输出流对象,释放相关系统资源 |
Reader用于读取的字符流抽象类,数据单位为字符。
方法名 | 使用说明 |
int read() | 读取一个字符的数据,并将字符的值作为int类型返回(0-65535之间的一个值,即Unicode值)。如果未读出字符则返回-1(返回值为-1表示读取结束) |
void close() | 关闭流对象,释放相关系统资源 |
Writer用于输出的字符流抽象类,数据单位为字符。
方法名 | 使用说明 |
void write(int n) | 向输出流中写出一个字符 |
void close() | 关闭流对象,释放相关系统资源 |
FileInputStream通过字节的方式读取文件,适合读取所有类型的文件(图像、视频、文本文件等)。文件字节流是一个字节一个字节读取数据,如果数据源的编码方式和目的地的解码方式不同就会造成乱码问题。
package cn.it.bz.IO;
import java.io.FileInputStream;
import java.io.IOException;
public class TestFileInputStream {
public static void main(String[] args) {
//将磁盘D中a.txt以字节输入到程序中
try(FileInputStream fileInputStream = new FileInputStream("D:/a.txt");)
{
StringBuilder stringBuilder = new StringBuilder();
int temp = 0;
while ((temp = fileInputStream.read()) != -1){//获取文件中数据的字节
//将字节转成字符
stringBuilder.append((char)temp);
}
System.out.println(stringBuilder);
} catch (IOException e) {
e.printStackTrace();
}
}
}
需要注意的是read()方法无参数,返回值是int类型,代表的是文件中字符对应的ASCII编码。返回值如果是-1的话表示文件已经读取完毕。对于得到的ASCII一般需要在程序中再将其强制转换为char字符类型
FileOutputStream 通过字节的方式写数据到文件中,适合所有类型的文件(图像、视频、文本文件等。这里的字节指的是写出数据的参数是字节,不是将字符的字节输到文件中。
package cn.it.bz.IO;
import java.io.FileOutputStream;
import java.io.IOException;
public class TestFileOutputStream {
public static void main(String[] args) {
//将Java以字节输出到D盘下的a.txt文件中
//true:表示会追加到文件末尾。false(默认):表示重写整个文件的内容。
try (FileOutputStream fileOutputStream = new FileOutputStream("d:/a.txt",true);)
{
//准备输出的数据
String data = " java";
//将字符串转为字节数组:j=>106 a=>97 v=>118 a=>97
byte[] bytes = data.getBytes();
fileOutputStream.write(data.getBytes());
//刷新,将数据从内存中写入到磁盘中
fileOutputStream.flush();
} catch (IOException E) {
E.printStackTrace();
}
}
}
需要注意的是write()方法的参数是字节或者是字节数组,输出到文件的时候会自动将字节或者是字节数组转换为对应ASCII码表示的字符。
package cn.it.bz.IO;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class TestFileBuffer {
public static void main(String[] args) {
//获取当前时间的毫秒数
long startTime = System.currentTimeMillis();
copyFile("D:/a.txt","d:/b.txt");
long endTime = System.currentTimeMillis();
System.out.println(endTime-startTime);
}
//文件复制。source:源文件。destination:目的地文件
public static void copyFile(String source,String destination){
//流的关闭顺序是后开先关
try(FileInputStream fileInputStream = new FileInputStream(source);
FileOutputStream fileOutputStream = new FileOutputStream(destination))
{
//字节缓冲区。因为输入输出流是文件字节流,因此使用字节数组作为缓冲区
byte[] buffer = new byte[1024];
//先将文件读到程序
int temp = 0;
while ((temp = fileInputStream.read(buffer))!= -1){
System.out.println("temp:"+temp);
//将文件写出去。buffer:表示一次写出的字节的大小。off:表示从第0个位置开始写出。temp:表示写出的文件取决于temp,temp决定了缓冲区有多少字节数。
fileOutputStream.write(buffer,0,temp);
}
//将数据写出到磁盘中
fileOutputStream.flush();
}catch (Exception e){
e.printStackTrace();
}
}
}
fileInputStream.read(buffer)将文件中的数据,读入到缓冲区buffer中,返回的是该组数据的大小。假设,被读取文件的最后一组只有200个字节,那么输入字节流也只会读取这200个字节存放到缓冲区,缓冲区剩下的空间是没有数据的。
fileOutputStream.write(buffer,0,temp);将本次循环中的数据写出到目标文件中,如果不给0,temp这两个参数,则将缓冲区中1024个字节全部输出到目标文件中,也就是即使缓冲区中1024个字节只有200个字节是数据,那输出流也会将这1024个字节输出到你目标文件中,剩下的824个字节用空格补齐。
注意 在使用字节缓冲区时,我们需要注意:
Java缓冲流本身并不具有IO流的读取与写入功能,只是在别的流(节点流或其他处理流)上加上缓冲功能提高效率,就像是把别的流包装起来一样,因此缓冲流是一种处理流(包装流)。
BufferedInputStream和BufferedOutputStream这两个流是缓冲字节流,通过内部缓存数组(其实和前面的缓冲区数组一样,只不过缓冲区大小默认是8192个字节,可以通过构造方法来修改该缓冲区的大小)来提高操作流的效率。
package cn.it.bz.IO;
import java.io.*;
public class TestFileBufferedStream {
public static void main(String[] args) {
//获取当前时间的毫秒数
long startTime = System.currentTimeMillis();
copyFile("D:/abc.jpg","d:/2.jpg");
long endTime = System.currentTimeMillis();
long time = endTime-startTime;
System.out.println("时间:"+time);
}
public static void copyFile(String source,String destination){
//两个节点流,两个处理流
try(FileInputStream fileInputStream = new FileInputStream(source);
FileOutputStream fileOutputStream = new FileOutputStream(destination);
BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
)
{
int temp = 0;
while ((temp = bufferedInputStream.read()) != -1){
bufferedOutputStream.write(temp);
}
}catch (IOException e){
e.printStackTrace();
}
}
}
前面介绍的文件字节流可以处理所有的文件,如果我们处理的是文本文件,也可以使用文件字符流,它以字符为单位进行操作。
文件字符流一般用于读写文本文件,不用于读取二进制文件,会产生乱码。字符流在遇到英文时一次读取一个字节,在遇到中文时一次读取多个字节(gbk编码一次读三个。utf-8一次读两个),这和字符集有关。
使用文件字符输入流读取数据时,遇到汉字会读取多个字节,GBK编码的汉字一次读取两个字节,UTF-8 编码的一次读取三个字节,在程序得到汉字字节时会将其按照指定或者是默认的解码规则解码得到十进制数。
package cn.it.bz.IO;
import java.io.FileReader;
import java.io.IOException;
public class TestFileReader {
public static void main(String[] args) {
//创建文件字符输入流对象
try(FileReader fileReader = new FileReader("D:/a.txt");)
{
StringBuilder stringBuilder = new StringBuilder();
int temp = 0;
while ((temp = fileReader.read()) != -1){
System.out.println(temp);
stringBuilder.append((char)temp); //将字符解码得到的十进制数据还原回字符
}
System.out.println("输出:"+stringBuilder);
}catch (IOException e){
e.printStackTrace();
}
}
}
package cn.it.bz.IO;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class TestFileWriter {
public static void main(String[] args) {
//创建文件字符输出流对象,默认将源文件的内容覆盖,true表示开启追加。
try(FileWriter fileWriter = new FileWriter("D:/a.txt",true);)
{
fileWriter.write("张三\r\n");//"\r\n"表示回车换行
fileWriter.flush();
}catch (IOException e){
e.printStackTrace();
}
}
}
BufferedReader/BufferedWriter增加了缓存机制,大大提高了读写文本文件的效率。
字符输入缓冲流
BufferedReader是针对字符输入流的缓冲流对象,提供了更方便的按行读取的方法:readLine(); 在使用字符流读取文本文件时,我们可以使用该方法以行为单位进行读取。
package cn.it.bz.IO;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class TestBufferedReader {
public static void main(String[] args) {
//创建字符输入缓冲流和字符输入节点流
try(BufferedReader bufferedReader = new BufferedReader(new FileReader("D:/a.txt")))
{
String temp = "";
while ((temp = bufferedReader.readLine()) != null){//循环读取一行字符串
System.out.println(temp);
}
}catch (IOException e){
e.printStackTrace();
}
}
}
字符输出缓冲流
BufferedWriter是针对字符输出流的缓冲流对象,在字符输出缓冲流中可以使用newLine();方法实现换行处理。
package cn.it.bz.IO;
import java.io.*;
public class TestBufferedWriter {
public static void main(String[] args) {
//创建字符输入缓冲流和字符输入节点流
try(BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("D:/a.txt")))
{
//向文件写出字符串
bufferedWriter.write("摄像头");
bufferedWriter.newLine(); //换行
bufferedWriter.write("青青子衿悠悠我心");
bufferedWriter.flush();
}catch (IOException e){
e.printStackTrace();
}
}
}
注意
package cn.it.bz.IO;
import java.io.*;
public class TestLineNumber {
public static void main(String[] args) {
try(BufferedReader bufferedReader = new BufferedReader(new FileReader("D:/a.txt"));
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("D:/a1.txt"))
) {
String temp = " ";
int i = 1;
while ((temp = bufferedReader.readLine()) != null){
//向a1.txt文件写入数据
bufferedWriter.write(i+"、"+temp);
//换行
bufferedWriter.newLine();
//i+1
i++;
}
//刷新
bufferedWriter.flush();
}catch (IOException e){
e.printStackTrace();
}
}
}
InputStreamReader字节流转换为字符流/OutputStreamWriter将字符流转换为字节流。转换流也是处理流。
计算机中数据的存储规则:
计算机中的数据都是二进制的数据,八个二进制位组成一个字节,英文字母占一个字节,汉字占两个字节。
ASCII字符集:
ASCII字符集最多表示128个字符(7位)且只能存储英文字符,一个字节最多表示256个字符(8位),因此英文字符占一个字节足够。计算机中存储的二进制数据都是8位,只有7位的ASCII码是不能直接存储到计算机中的。因此还需要对7位的ASCII码进行编码,使其转换为8为的二进制数据,编码的结果就是在ASCII码的最高位补0。
GBK字符集:
中国win电脑上显示的ANSI实际上就是指的GBK字符编码集。GBK完全兼容ASCII
需要注意的是:解码是将二进制转为十进制。
Unicode字符编码:
存储全世界的字符编码,Unicode字符编码针对的是全世界的字符,因此针对不同国家地区的文字采取不同的编码方式,最常见的就是UTF-8(注意UTF-8不是字符集),规定英文字符占一个字节且最高位为0(0xxxxxxx),汉字占三个字节从高位到低位依次是 1110xxxx 10xxxxxxxx 10xxxxxxxx。
乱码产生的原因:
1、读取字符时没有读完。
2、编码和解码方式不统一。
如何避免产生乱码?
1、不使用字节流读取文件
2、使用相同的编码和解码方式
package cn.it.bz.IO;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class TestInputStreamReader {
public static void main(String[] args) {
try(
//创建文件字节输入流对象
FileInputStream fileInputStream = new FileInputStream("D:/a2.txt");
//创建字节到字符的转换流
InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream,"gbk");
)
{
StringBuilder stringBuilder = new StringBuilder();
int temp = 0;
while ((temp = inputStreamReader.read()) != -1){
stringBuilder.append((char) temp);
}
System.out.println(stringBuilder);
}catch (IOException e){
e.printStackTrace();
}
}
}
package cn.it.bz.IO;
import java.io.*;
public class TestLineNumber2 {
public static void main(String[] args) {
try (
//创建字节文件输入流
FileInputStream fileInputStream = new FileInputStream("D:/a.txt");
//将字节流转换为字符流(解决中文乱码)
InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream,"utf-8") ;
//再使用字符缓冲(读一行)
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
//创建字符文件输出流
FileWriter fileWriter = new FileWriter("D:/a1.txt");
//创建文件字符缓冲区
BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
)
{
int i = 1;
StringBuilder stringBuilder = new StringBuilder();
String s = "";
while ((s = bufferedReader.readLine()) != null){
System.out.println(s);
//添加行号
bufferedWriter.write(i+"、"+s);
//换行,相当于是bufferedWriter.write("\r\n")
bufferedWriter.newLine();
i++;
}
//释放资源
bufferedWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
原理图:
package cn.it.bz.IO;
import java.io.IOException;
import java.io.PrintWriter;
public class TestPrintWriter {
public static void main(String[] args) {
//创建字符流输出对象
try(PrintWriter printWriter = new PrintWriter("D:/a.txt")) {
printWriter.print("Java");//不换行
printWriter.print("百战");
printWriter.println("sxt");//换行
printWriter.println("哈哈哈");
printWriter.flush();
}catch (IOException e){
e.printStackTrace();
}
}
}
小练习:通过字符输出流添加行号
package cn.it.bz.IO;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
public class TestLineNumber3 {
public static void main(String[] args) {
try(
//读入一行数据数据
BufferedReader bufferedReader = new BufferedReader(new FileReader("D:/a.txt"));
//输出数据
PrintWriter printWriter = new PrintWriter("D:/a1.txt")) {
int i = 1;
String s = "";
while ((s = bufferedReader.readLine()) != null){
printWriter.println(i+"、"+s);
i++;
}
//释放资源
printWriter.flush();
}catch (IOException e){
e.printStackTrace();
}
}
}
数据流将“基本数据类型与字符串类型”作为数据源,从而允许程序以与机器无关的方式从底层输入输出流中操作Java基本数据类型与字符串类型。数据流是处理流,不是节点流,而且只能处理文件字节流,不能处理文件字符流。
package cn.it.bz.IO;
import com.sun.org.apache.xerces.internal.impl.dv.dtd.IDREFDatatypeValidator;
import java.io.*;
public class TestDataOutputStream {
public static void main(String[] args) {
//先向文件写数据,在从文件获取数据。
try(DataOutputStream dataOutputStream = new DataOutputStream(new FileOutputStream("D:/a.txt"));
DataInputStream dataInputStream = new DataInputStream(new FileInputStream("d:/a.txt"))
) {
//将如下数据写到文件
dataOutputStream.writeChar('张');
dataOutputStream.writeUTF("输出字符串");
dataOutputStream.writeInt(123);
dataOutputStream.writeDouble(Math.random());
dataOutputStream.writeBoolean(true);
dataOutputStream.flush();
//读取顺序需要和写入顺序一样才行
System.out.println(dataInputStream.readChar());
System.out.println(dataInputStream.readUTF());
System.out.println(dataInputStream.readInt());
System.out.println(dataInputStream.readDouble());
System.out.println(dataInputStream.readBoolean());
}catch (IOException E){
E.printStackTrace();
}
}
}
1、使用数据流时,读取的顺序一定要与写入的顺序一致,否则不能正确读取数据。
2、数据流只能处理文件字节流,不能处理文件字符流
我们前边学到的数据流只能实现对基本数据类型和字符串类型的读写,并不能读取对象(字符串除外),如果要对某个对象进行读写操作,我们需要学习一对新的处理流:ObjectInputStream/ObjectOutputStream。对象流实际上是数据流的升级版,使用对象流也能实现对Java中基本数据类型的读写操作,还能对自定义对象进行读写操作。对象流和数据流一样都是处理流,只能处理字节流不能处理字符流。
package cn.it.bz.IO;
import java.io.*;
public class TestObjectStreamBasicType {
public static void main(String[] args) {
try(ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("D:/a.txt"));
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("D:/a.txt"))
) {
//数据写出
objectOutputStream.writeInt(123);
objectOutputStream.writeChar('h');
objectOutputStream.writeBoolean(true);
//刷新
objectOutputStream.flush();
//按照写入的顺序读取数据
System.out.println(objectInputStream.readInt());
System.out.println(objectInputStream.readChar());
System.out.println(objectInputStream.readBoolean());
}catch (IOException E){
E.printStackTrace();
}
}
}
ObjectOutputStream可以将一个内存中的Java对象通过序列化的方式写入到磁盘的文件中。被序列化的对象必须要实现Serializable序列化接口,否则会抛出异常。
package cn.it.bz.IO;
import java.io.*;
public class TestObjectOutputStream {
public static void main(String[] args) {
try(ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("D:/a.txt"));
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("D:/a.txt"))) {
//创建Users对象
Users users = new Users(123,"zhangsan","12");
//将对象序列化到文件
objectOutputStream.writeObject(users);
//刷新
objectOutputStream.flush();
}catch (IOException e){
e.printStackTrace();
}
}
}
如果想一次性将多个对象序列化到文件中,可以将对象放在集合中,集合实现了序列化接口。
package cn.it.bz.IO;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
public class TestObjectInputStream {
public static void main(String[] args) {
//创建对象输入字节流与文件字节输入流对象
try(ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("d:/a.txt"))){
//将对象反序列化到内存中
Users users = (Users) objectInputStream.readObject();
System.out.println(users);
}catch(Exception e){
e.printStackTrace();
}
}
}
File是操作文件的,当以文件作为数据源或目标时,除了可以使用字符串作为文件以及位置的指定以外,我们也可以使用File类指定。
package cn.it.bz.IO;
import java.io.*;
public class TestFile {
public static void main(String[] args) {
try(BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(new File("D:/a.txt")),"gbk"))) {
String s ="";
while ((s = bufferedReader.readLine()) != null){
System.out.println(s);
}
}catch (IOException e){
e.printStackTrace();
}
}
}
装饰器模式是GOF23种设计模式中较为常用的一种模式。它可以实现对原有类的包装和装饰,使新的类具有更强的功能。
package cn.it.bz.IO;
class Iphone{
private String name;
public Iphone(String name) {
this.name = name;
}
public void show() {
System.out.println("我是" + name + ",可以在屏幕上显示");
}
}
//装饰器
class TouyingPhone {
public Iphone phone;
public TouyingPhone(Iphone p) {
this.phone = p;
}
// 对Iphone功能的扩展
public void show() {
phone.show();
System.out.println("还可以投影,在墙壁上显示");
}
}
public class TestDecoration {
public static void main(String[] args) {
Iphone iphone = new Iphone("苹果18");
//将有投影能力的手机壳装到手机上
TouyingPhone touyingPhone = new TouyingPhone(iphone);
touyingPhone.show();
}
}
IO流体系中大量使用了装饰器模式,让流具有更强的功能、更强的灵活性。比如:
FileInputStream fis = new FileInputStream(src);
BufferedInputStream bis = new BufferedInputStream(fis);
显然BufferedInputStream装饰了原有的FileInputStream,让普通的FileInputStream也具备了缓存功能,提高了效率。
Apache基金会介绍
Apache软件基金会(也就是Apache Software Foundation,简称为ASF),是专门为支持开源软件项目而办的一个非盈利性组织。在它所支持的Apache项目与子项目中,所发行的软件产品都遵循Apache许可证(Apache License)。 官方网址为:www.apache.org
很多著名的Java开源项目都来源于这个组织。比如:commons、kafka、lucene、maven、shiro、struts等技术,以及大数据技术中的:hadoop(大数据第一技术)、hbase、spark、storm、mahout等。
commons-io工具包
Apache的commons-io工具包中提供了IOUtils/FileUtils,为我们提供了更加简单、功能更加强大的文件操作和IO流操作功能。
下载与添加commons-io包
下载地址
Commons IO – Download Apache Commons IO
在项目中创建lib文件境jar包拖入到该文件中,然后右键lib选择Add as Library
打开FileUtils的api文档,我们抽出一些工作中比较常用的静态方法,进行总结和讲解。总结如下:
方法名 | 使用说明 |
---|---|
cleanDirectory | 清空目录,但不删除目录 |
contentEquals | 比较两个文件的内容是否相同 |
copyDirectory | 将一个目录内容拷贝到另一个目录。可以通过FileFilter过滤需要拷贝的文件 |
copyFile | 将一个文件拷贝到一个新的地址 |
copyFileToDirectory | 将一个文件拷贝到某个目录下 |
copyInputStreamToFile | 将一个输入流中的内容拷贝到某个文件 |
deleteDirectory | 删除目录 |
deleteQuietly | 删除文件 |
listFiles | 列出指定目录下的所有文件 |
openInputSteam | 打开指定文件的输入流 |
readFileToString | 将文件内容作为字符串返回 |
readLines | 将文件内容按行返回到一个字符串数组中 |
size | 返回文件或目录的大小 |
write | 将字符串内容直接写到文件中 |
writeByteArrayToFile | 将字节数组内容写到文件中 |
writeLines | 将容器中的元素的toString方法返回的内容依次写入文件中 |
writeStringToFile | 将字符串内容写到文件中 |
package cn.it.bz.IO;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
public class TestUtils1 {
public static void main(String[] args) throws IOException {
//content表示读取的文件中的全部的内容
String content = FileUtils.readFileToString(new File("D:/a.txt"), "gbk");
System.out.println(content);
}
}
我们可以使用FileUtils完成目录拷贝,在拷贝过程中可以通过文件过滤器(FileFilter)选择拷贝内容。
package cn.it.bz.IO;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
public class TestFileUtils2 {
public static void main(String[] args) throws IOException {
FileUtils.copyDirectory(new File("D:\\图片"), new File("d:/aaa"), new FileFilter() {
//给定文件拷贝规则,只拷贝以png结尾的文件
@Override
public boolean accept(File pathname) {
if (pathname.getName().endsWith(".png")){
return true; //拷贝
}
return false; //不拷贝
}
}
);
}
}
打开IOUtils的api文档,我们发现它的方法大部分都是重载的。所以,我们理解它的方法并不是难事。因此,对于方法的用法总结如下:
方法名 | 使用说明 |
---|---|
buffer | 将传入的流进行包装,变成缓冲流。并可以通过参数指定缓冲大小 |
closeQueitly | 关闭流 |
contentEquals | 比较两个流中的内容是否一致 |
copy | 将输入流中的内容拷贝到输出流中,并可以指定字符编码 |
copyLarge | 将输入流中的内容拷贝到输出流中,适合大于2G内容的拷贝 |
lineIterator | 返回可以迭代每一行内容的迭代器 |
read | 将输入流中的部分内容读入到字节数组中 |
readFully | 将输入流中的所有内容读入到字节数组中 |
readLine | 读入输入流内容中的一行 |
toBufferedInputStream,toBufferedReader | 将输入转为带缓存的输入流 |
toByteArray,toCharArray | 将输入流的内容转为字节数组、字符数组 |
toString | 将输入流或数组中的内容转化为字符串 |
write | 向流里面写入内容 |
writeLine | 向流里面写入一行内容 |
package cn.it.bz.IO;
import org.apache.commons.io.IOUtils;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class TestIOUtilsDemo {
public static void main(String[] args) throws IOException {
String content = IOUtils.toString(new FileInputStream("D:/a.txt"), "gbk");
System.out.println(content);
}
}
实际上就是相当于文件字节输入流套上了文件字符转换流(并指定解码规则)再套上文件字符缓冲流。