File I/O
本章技能目标
- 会使用File类操作文件或目录的属性
- 熟练使用字节流读写文件
- 熟练使用字符流读写文件
- 会使用字节流读写二进制文件
本章讲解File I/O 的内容。首先学习File类,对文件和目录的属性进行操作,然后通过讲解字节流FileInputStream和FileOutStream类、字符流BufferedReader和BufferedWriter类,实现对文本文件的输入/输出操作。
最后讲解字节流DateInputStream和DataOutputStream类读写二进制文件。
1. 操作文件或目录的属性
程序的主要任务就是操作数据,通过允许程序读取文件的内容或想文件写入数据,可以是程序应用更为广泛。一般情况下,当数据位于内存中并且属于特定的类型时,程序才能操作他们。然而大多数的数据并不都是在内存中的,而是以文件的形式存放在外部的磁盘中,如硬盘、光盘、U盘等。文件是指相关记录或放在一起的数据的集合,目前我们熟悉的文件类型有很多,如扩展名为:txt、doc、xls、jpg、java、class等文件。
1.1 使用File类操作文件或目录属性
java.io.File用于表示文件(目录),也就是说程序员可以通过File类在程序中操作硬盘上的文件和目录。
File类只用于表示文件(目录)的信息(名称、大小等),换句话说只能访问文件或目录的相关属性,不能对文件的内容进行访问。
创建File对象可以代表文件或者文件夹。
创建一个File对象的语法样式如下:
File file = new File(String pathname);
通过将给定路径名字符串转换成抽象路径名来创建一个新 File 实例
提示:
抽象路径应尽量使用相对路径,并且目录的层级分隔符不要直接写”/”或”\”,应使用File.separator这个常量表示,以避免不同系统带来的差异
File的创建还可以根据 parent抽象路径名和child路径名字符串创建一个新File实例。
File file = new File(String parent, String child);
//或者:
File file = new File(File parent, String child)
File类常用的方法:
方法名称 | 说 明 |
---|---|
boolean exists( ) | 判断文件或目录是否存在 |
boolean isFile( ) | 判断是否是文件 |
boolean isDirectory( ) | 判断是否是目录 |
boolean mkdir() | 创建指定目录,成功返回 true;否则返回 false |
boolean mkdirs() | 创建指定目录以及父级目录,成功返回true,否则返回false。 |
String getPath( ) | 返回此对象表示的文件的相对路径名 |
String getAbsolutePath( ) | 返回此对象表示的文件的绝对路径名 |
String getName( ) | 返回此对象表示的文件或目录的名称 |
boolean delete( ) | 删除此对象指定的文件或目录 |
boolean createNewFile( ) | 创建名称的空文件,不创建文件夹 |
long length() | 返回文件的长度,单位为字节, 如果文件不存在,则返回 0L |
提示:
File类有很多方法,对于这些方法,不需要死记硬背,编程的时候,用到相关的方法,查看API即可
File类操作文件属性演示示例如下:
1.2 创建文件以及文件夹
代码如下:
File file = new File("test");
//mkdir()用于创建文件夹,如果成功
//创建文件夹,则返回true,否则false
boolean b = file.mkdir();
System.out.println(b);//true
//创建系列文件夹
File file2=new File("def//demo//test");
//mkdirs 用于创建一系列父子文件夹
b = file2.mkdirs();
System.out.println(b); //true
//使用绝对路径创建文件夹
File file3=new File("d://test//demo");
//new File("/home/soft01/demo/test");
file3.mkdirs();
//创建文件
//使用绝对路径创建文件
File file4 = new File("d://test//demo.txt");
//调用file对象的createNewFile方法时 注意文件所在的目录必须存在
b = file4.createNewFile();
System.out.println(b);//true
1.3 获取文件以及文件夹的属性
示例代码如下:
File dir = new File("d://test");
File file = new File(dir, "demo.txt");
// dir代表一个文件夹
// file 代表一个文件
// 检查是否是文件
System.out.println(dir.isFile());
System.out.println(file.isFile());
// 检查文件的长度
long length = file.length();
System.out.println(length);
// 检查文件的最后修改时间
long time = file.lastModified();
Date date = new Date(time);
System.out.println(date);
// 检查文件的读写属性
boolean read = file.canRead();
boolean write = file.canWrite();
boolean hidden = file.isHidden();
System.out.println(read);
System.out.println(write);
System.out.println(hidden);
System.out.println("相对路径:"+file.getPath());
System.out.println("绝对路径:"+file.getAbsolutePath());
1.4 列出文件夹的内容
listFiles方法用于返回一个抽象路径名数组,这些路径名表示此抽象路径名表示的目录中的文件。其方法定义:
File[] listFiles()
返回值:抽象路径名数组,这些路径名表示此抽象路径名表示的目录中的文件和目录。如果目录为空,那么数组也将为空。如果抽象路径名不表示一个目录,或者发生 I/O 错误,则返回 null
示例代码如下:
// 创建file对象代表test文件夹
// new File("D:/");
// new File("/home/soft01/");
File dir = new File("d://test");
// 查询 test文件夹的内容列表
// 返回值是File类型的数组,有的是文件有的是文件夹
File[] files = dir.listFiles();
// 在控制台输出文件夹中全部的内容
for (File file : files) {
// 文件夹显示为: [文件夹名]
if (file.isDirectory()) {
System.out.println("[" + file.getName() + "]");
} else {
System.out.println(file.getName());
System.out.println("相对路径:"+file.getPath());
System.out.println("绝对路径:"+file.getAbsolutePath());
System.out.println("文件大小:"+file.length()+"个字节");
}
}
1.5 递归打印多级目录
示例如下:
public static void printDir(File dir) {
// 获取子文件和目录
File[] files = dir.listFiles();
// 循环打印
/* 判断:
当是文件时,打印绝对路径.
当是目录时,继续调用打印目录的方法,形成递归调用.
*/
for (File file : files) {
// 判断
if (file.isFile()) {
// 是文件,输出文件绝对路径
System.out.println("文件名:"+ file.getAbsolutePath());
} else {
// 是目录,输出目录绝对路径
System.out.println("目录:"+file.getAbsolutePath());
// 继续遍历,调用printDir,形成递归
printDir(file);
}
}
}
1.6 递归删除文件夹的内容
删除一个文件夹的步骤:
- 列出文件夹的全部内容
- 遍历每个文件,并且调用文件的delete()
- 删除文件夹
- 返回删除的结果
示例代码如下:
public static boolean delete(File dir){
//删除一个文件夹的步骤:
//1. 列出文件夹的全部内容
//2. 遍历每个文件,并且调用文件的delete()
//3. 删除文件夹
//4. 返回删除的结果
if(! dir.exists()){ return false;}
File[] files=dir.listFiles();
for(File file:files){
if(file.isDirectory()){
//删除子文件夹
//删除子文件的算法与删除当前
//文件夹的算法是一致的。利用
//递归删除子文件夹
delete(file);
}else{
//删除文件
file.delete();
}
}
return dir.delete();//删除空目录
}
2. Java的流
读文件,是指把文件中的数据读取到内存中。反之,写文件就是把内存中的数据写到文件中。那么通过什么去读写文件呢?答案就是流。
流,是指一连串流动的字符,是以先进先出方式发送信息的通道。如图所示:
我们把这种数据的传输,可以看做是一种数据的流动,按照流动的方向,以内存为基准,分为输入input
和输出output
,即流向内存是输入流,流出内存的输出流。
什么是输入:
输入是一个从外界进入到程序的方向,通常我们需要“读取”外界的数据时,使用输入。所以输入是用来读取数据的。InputStream 代表输入流经常缩写为in/包含核心方法 read()/关闭方法 close()
什么是输出:
输出是一个从程序发送到外界的方向,通常我们需要”写出”数据到外界时,使用输出。所以输出是用来写出数据的。OutputStream 代表输出流经常缩写为out/包含核心方法 write()/关闭方法 close()
Java中I/O操作主要是指使用java.io
包下的内容,进行输入、输出操作。
输入也叫做读取数据,输出也叫做作写出数据。
2.1 IO的分类
根据数据的流向分为:输入流和输出流。
- 输入流 :把数据从
其他设备
上读取到内存
中的流。 - 输出流 :把数据从
内存
中写出到其他设备
上的流。
根据数据的类型分为:字节流和字符流。
- 字节流 :以字节为单位,读写数据的流。
- 字符流 :以字符为单位,读写数据的流。
2.2 流的顶级父类们
输入流 | 输出流 | |
---|---|---|
字节流 | 字节输入流 InputStream | 字节输出流 OutputStream |
字符流 | 字符输入流 Reader | 字符输出流 Writer |
3. 读写文本文件
字节流:一切皆为字节
一切文件数据(文本、图片、视频等)在存储时,都是以二进制数字的形式保存,都一个一个的字节,那么传输时一样如此。所以,字节流可以传输任意文件数据。在操作流的时候,我们要时刻明确,无论使用什么样的流对象,底层传输的始终为二进制数据。
3.1 使用字节流读取文本文件
1. 字节输入流InputStream类
java.io.InputStream
抽象类是表示字节输入流的所有类的超类,可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。
public void close()
:关闭此输入流并释放与此流相关联的任何系统资源。public abstract int read()
: 从输入流读取数据的下一个字节。public int read(byte[] b)
: 从输入流中读取一些字节数,并将它们存储到字节数组 b中 。
温馨提示:
close方法,当完成流的操作时,必须调用此方法,释放系统资源。
2. 字节输入流FileInputStream
java.io.FileInputStream
类是文件输入流,从文件中读取字节。
构造方法
FileInputStream(File file)
: 通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的 File对象 file命名。FileInputStream(String name)
: 通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的路径名 name命名。
当你创建一个流对象时,必须传入一个文件路径。该路径下,如果没有该文件,会抛出FileNotFoundException
。
- 构造举例,代码如下:
public class FileInputStreamConstructor {
public static void main(String[] args)throws IOException {
// 使用File对象创建流对象
File file = new File("a.txt");
FileInputStream fos = new FileInputStream(file);
// 使用文件名称创建流对象
FileInputStream fos = new FileInputStream("b.txt");
}
}
3. 使用FileInputStream读取文件
-
引入相关的类。示例代码如下:
import java.io.*;
-
创建一个文件输入流对象。示例代码如下:
//1、创建输入流对,负责读取D:/ 我的青春谁做主.txt文件 FileInputStream fis = new FileInputStream("D:/我的青春谁做主.txt");
-
利用文件输入流的方法读取文本文件的数据。示例代码如下:
// 定义变量,保存数据 int b ; // 循环读取 while ((b = fis.read())!=-1) { System.out.println((char)b); }
-
关闭文件输入流对象。示例代码如下:
fis.close();
示例代码如下:
public class FISRead {
public static void main(String[] args) throws IOException{
// 使用文件名称创建流对象
FileInputStream fis = new FileInputStream("read.txt");
// 读取数据,返回一个字节
int read = fis.read();
System.out.println((char) read);
read = fis.read();
System.out.println((char) read);
read = fis.read();
System.out.println((char) read);
read = fis.read();
System.out.println((char) read);
read = fis.read();
System.out.println((char) read);
// 读取到末尾,返回-1
read = fis.read();
System.out.println( read);
// 关闭资源
fis.close();
}
}
输出结果:
a
b
c
d
e
-1
循环读取:
public class FISRead {
public static void main(String[] args) throws IOException{
// 使用文件名称创建流对象
FileInputStream fis = null;
try{
fis = new FileInputStream("read.txt");
// 定义变量,保存数据
int b;
// 循环读取
while ((b = fis.read())!=-1) {
System.out.println((char)b);
}
// 关闭资源
}catch(Exception e){
e.printStackTrace();
}finally{
//5、关闭流
try {
if(fis!=null)
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
输出结果:
a
b
c
d
e
4. JDK7新特性try-with-resource
可以使用JDK7优化后的try-with-resource
语句,该语句确保了每个资源在语句结束时关闭。所谓的资源(resource)是指在程序完成后,必须关闭的对象。
使用jdk7新特性try-catch-resource简化代码如下:
// 使用文件名称创建流对象
try(FileInputStream fis = new FileInputStream("read.txt")){
// 定义变量,保存数据
int b;
// 循环读取
while ((b = fis.read())!=-1) {
System.out.println((char)b);
}
}catch(Exception e) {
e.printStackTrace();
}
5. JDK9改进try-with-resource
JDK9中try-with-resource
的改进,对于引入对象的方式,支持的更加简洁。被引入的对象,同样可以自动关闭,无需手动close,我们来了解一下格式。
代码使用演示:
// 创建流对象
final FileReader fr = new FileReader("in.txt");
FileWriter fw = new FileWriter("out.txt");
// 引入到try中
try (fr; fw) {
// 定义变量
int b;
// 读取数据
while ((b = fr.read())!=-1) {
// 写出数据
fw.write(b);
}
} catch (IOException e) {
e.printStackTrace();
}
6. 使用字节数组读取文件
使用字节数组读取:read(byte[] b)
,每次读取b的长度个字节到数组中,返回读取到的有效字节个数,读取到末尾时,返回-1
,代码使用演示:
public static void main(String[] args) {
// 使用文件名称创建流对象
try(FileInputStream fis = new FileInputStream("read.txt")){
// 定义变量,保存数据
int len;
//定义字节数组
//byte[] b = new byte[1024];
//available():获取读的文件所有的字节个数
byte[] b = new byte[fis.available()];
// 循环读取
while ((len = fis.read(b))!=-1) {
//System.out.println(new String(b,0,len));
System.out.println(new String(b));
}
}catch(Exception e) {
e.printStackTrace();
}
}
输出结果:
abcde
温馨提示:
使用数组读取,每次读取多个字节,减少了系统间的IO操作次数,从而提高了读写的效率,建议开发中使用。
3.2 使用字节流写入文本文件
1. 字节输出流OutputStream
java.io.OutputStream
抽象类是表示字节输出流的所有类的超类,将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。
public void close()
:关闭此输出流并释放与此流相关联的任何系统资源。public void flush()
:刷新此输出流并强制任何缓冲的输出字节被写出。public void write(byte[] b)
:将 b.length字节从指定的字节数组写入此输出流。public void write(byte[] b, int off, int len)
:从指定的字节数组写入 len字节,从偏移量 off开始输出到此输出流。public abstract void write(int b)
:将指定的字节输出流。
2. 字节输出流FileOutputStream
OutputStream
有很多子类,我们从最简单的一个子类开始。
java.io.FileOutputStream
类是文件输出流,用于将数据写出到文件。
构造方法
public FileOutputStream(File file)
:创建文件输出流以写入由指定的 File对象表示的文件。public FileOutputStream(String name)
: 创建文件输出流以指定的名称写入文件。
当你创建一个流对象时,必须传入一个文件路径。该路径下,如果没有这个文件,会创建该文件。如果有这个文件,会清空这个文件的数据。
public FileOutputStream(File file, boolean append)
: 创建文件输出流以写入由指定的 File对象表示的文件。public FileOutputStream(String name, boolean append)
: 创建文件输出流以指定的名称写入文件。
这两个构造方法,参数中都需要传入一个boolean类型的值,true
表示追加数据,false
表示清空原有数据。这样创建的输出流对象,就可以指定是否追加续写了。
代码演示如下:
// 使用File对象创建流对象
File file = new File("a.txt");
FileOutputStream fos = new FileOutputStream(file);
// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("b.txt");
// 使用文件名称创建流对象 并向该文件追加数据
FileOutputStream fos = new FileOutputStream("fos.txt",true);
3. 使用FileOutputStream写入文件
-
引入相关的类。示例代码如下:
import java.io.*;
-
创建一个文件输出流对象。示例代码如下:
// 使用文件名称创建流对象 FileOutputStream fos = new FileOutputStream("fos.txt");
-
利用文件输出流的方法把数据写入到文本文件中。示例代码如下:
// 写出数据 fos.write(97); // 写出第1个字节 // 字符串转换为字节数组 byte[] b = "程序员".getBytes(); // 写出字节数组数据 fos.write(b);
-
关闭文件输入流对象。示例代码如下:
fos.close();
示例代码如下:
try (OutputStream os = new FileOutputStream("read.txt")){
byte[] b = "abcde".getBytes();
os.write(b);
// 写出从索引2开始,2个字节。索引2是c,两个字节,也就是cd。
os.write(b,2,2);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
4. 复制文本文件
代码演示如下:
try(FileInputStream fis=new FileInputStream("D:/我的青春谁做主.txt");
FileOutputStream fos=new FileOutputStream("C:/myFile/myPrime.txt",true)) {
//1、创建输入流对,负责读取D:/ 我的青春谁做主.txt文件
//2、创建输出流对象
//3、创建中转站数组,存放每次读取的内容
byte[] words=new byte[fis.available()];
//4、通过循环实现文件读取
while(fis.read(words)!=-1){
fos.write(words);
}
System.out.println("复制完成,请查看文件!");
} catch (IOException e) {
e.printStackTrace();
}
3.3 使用字符流读取文本文件
当使用字节流读取文本文件时,可能会有一个小问题。就是遇到中文字符时,可能不会显示完整的字符,那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类,以字符为单位读写数据,专门用于处理文本文件。
1. 字符输入流Reader
java.io.Reader
抽象类是表示用于读取字符流的所有类的超类,可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。
public void close()
:关闭此流并释放与此流相关联的任何系统资源。public int read()
: 从输入流读取一个字符。public int read(char[] cbuf)
: 从输入流中读取一些字符,并将它们存储到字符数组 cbuf中 。
2. 字符输入流FileReader
java.io.FileReader
类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
温馨提示:
- 字符编码:字节与字符的对应规则。Windows系统的中文编码默认是GBK编码表。
- 字节缓冲区:一个字节数组,用来临时存储字节数据。
构造方法:
FileReader(File file)
: 创建一个新的 FileReader ,给定要读取的File对象。FileReader(String fileName)
: 创建一个新的 FileReader ,给定要读取的文件的名称。
当你创建一个流对象时,必须传入一个文件路径。类似于FileInputStream 。
代码如下:
// 使用File对象创建流对象
File file = new File("a.txt");
FileReader fr = new FileReader(file);
// 使用文件名称创建流对象
FileReader fr = new FileReader("b.txt");
3. 使用FileReader读取文件
-
引入相关的类。示例代码如下:
import java.io.*;
-
创建一个FileReader对象。示例代码如下:
// 使用文件名称创建流对象 FileReader fr = new FileReader("b.txt");
-
利用FileReader类的方法读取文本文件中的数据。示例代码如下:
// 定义变量,保存数据 读取单个字符 int b = fr.read();
-
关闭相关的流对象。示例代码如下:
fr.close();
示例代码如下:
// 使用文件名称创建流对象
FileReader fr = new FileReader("read.txt");
// 定义变量,保存数据
int b;
// 循环读取
// StringBuilder sb = new StringBuilder();
while ((b = fr.read())!=-1) {
System.out.println((char)b);
//sb.append((char)b);
}
// 关闭资源
fr.close();
3.4 使用字符流写入文件文件
1. 字符输出流Writer
java.io.Writer
抽象类是表示用于写出字符流的所有类的超类,将指定的字符信息写出到目的地。它定义了字节输出流的基本共性功能方法。
void write(int c)
:写入单个字符。void write(char[] cbuf)
:写入字符数组。abstract void write(char[] cbuf, int off, int len)
:写入字符数组的某一部分,off数组的开始索引,len写的字符个数。void write(String str)
:写入字符串。void write(String str, int off, int len)
: 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。void flush()
:刷新该流的缓冲。void close()
: 关闭此流,但要先刷新它。
2. 字符输出流FileWriter
java.io.FileWriter
类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
构造方法
FileWriter(File file)
: 创建一个新的 FileWriter,给定要读取的File对象。FileWriter(String fileName)
: 创建一个新的 FileWriter,给定要读取的文件的名称。
当你创建一个流对象时,必须传入一个文件路径,类似于FileOutputStream。
-
构造举例,代码如下:
// 使用File对象创建流对象 File file = new File("a.txt"); FileWriter fw = new FileWriter(file); // 使用文件名称创建流对象 FileWriter fw = new FileWriter("b.txt");
3. 使用FileWriter写文本文件
-
引入相关的类。示例代码如下:
import java.io.*;
-
创建一个FileWriter对象。示例代码如下:
// 使用文件名称创建流对象 FileWriter fw = new FileWriter("b.txt");
-
利用FileWriter类的方法写文本文件。示例代码如下:
fw.write("Hello");
-
相关流对象清空和关闭。示例代码如下:
fw.flush();//刷新该流的缓冲 fw.close();//关闭流
示例代码如下:
public class FWWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileWriter fw = new FileWriter("fw.txt");
// 写出数据
fw.write(97); // 写出第1个字符
fw.write('b'); // 写出第2个字符
fw.write('C'); // 写出第3个字符
fw.write(30000); // 写出第4个字符,中文编码表中30000对应一个汉字。
fw.write("我热爱我的团队");
//char[] chars = "教育改变生活".toCharArray();
// 写出字符数组
//fw.write(chars);
// 字符串
//String msg = "教育改变生活";
// 写出字符串
//fw.write(msg); //教育改变生活
/*
【注意】关闭资源时,与FileOutputStream不同。
如果不关闭,数据只是保存到缓冲区,并未保存到文件。
*/
fw.flush();
fw.close();
}
}
输出结果:
abC田我热爱我的团队
温馨提示:
- 虽然参数为int类型四个字节,但是只会保留一个字符的信息写出。
- 未调用close方法,数据只是保存到了缓冲区,并未写出到文件中。
因为内置缓冲区的原因,如果不关闭输出流,无法写出字符到文件中。但是关闭的流对象,是无法继续写出数据的。如果我们既想写出数据,又想继续使用流,就需要flush
方法了。
flush
:刷新缓冲区,流对象可以继续使用。close
:先刷新缓冲区,然后通知系统释放资源。流对象不可以再被使用了。
温馨提示:即便是flush方法写出了数据,操作的最后还是要调用close方法,释放系统资源。
字符流,只能操作文本文件,不能操作图片,视频等非文本文件。当我们单纯读或者写文本文件时 使用字符流 其他情况使用字节流
5. 二进制文件的读写
前面已经学习了如何读写文本文件,但常见的文件读写还有一种二进制文件的读写。接下来介绍如何读写二进制文件。读写二进制文件常用的类有DataInputStream和DataOutputStream。
5.1 使用字节流DataInputStream读二进制文件
DataInputStream 类是FileInputStream的子类,它是FileInputStream类的扩展。利用DataInputStream类读取二进制文件的实现步骤其实与用FileInputStream类读取文本文件的步骤极其相似,而且还要用FileInputStream类。
具体操作步骤如下:
-
引入相关的类。示例代码如下:
import java.io.*;
-
创建一个数据输入流对象。示例代码如下:
//创建输入流对象 FileInputStream fis = new FileInputStream("D:\\myDoc\\FileCopy.class"); DataInputStream dis = new DataInputStream(fis);
-
利用数据输入流类的方法读取二进制文本文件的数据。示例代码如下:
dis.read();
-
关闭数据输入流。示例代码如下:
dis.close();
示例代码如下:
public class DISDemo {
public static void main(String[] args) {
try(DataInputStream dis =
new DataInputStream(
new FileInputStream
("D:\\myDoc\\FileCopy.class"))){
int len = -1;
byte[] buf = new byte[1024];
while((len = dis.read(buf)) != -1) {
System.out.println(new String(buf,0,len));
}
}catch(Exception e) {
e.printStackTrace();
}
}
}
5.2 使用字节流DataOutputStream写二进制文件
DataOutputStream 类是FileOutputStream的子类,它是FileOutputStream类的扩展。利用DataOutputStream类写二进制文件的实现步骤其实与用FileOutputStream类写入文本文件的步骤极其相似,而且还要用FileOutputStream类。
具体操作步骤如下:
-
引入相关的类。示例代码如下:
import java.io.*;
-
创建一个数据输出流对象。示例代码如下:
FileOutputStream outFile = new FileOutputStream("D:\\myDoc\\temp.class"); DataOutputStream out = new DataOutputStream(outFile);
-
利用数据输出流类的方法写入二进制文本文件的数据。示例代码如下:
out.write(1);//将指定的字节数据写入二进制文件
-
关闭数据输出流。示例代码如下:
out.close();
示例代码如下:
public class ReadAndWriteBinaryFile {
public static void main(String[] args) {
try (DataInputStream dis =
new DataInputStream(new FileInputStream("D:\\myDoc\\FileCopy.class"));
DataOutputStream out =
new DataOutputStream(new FileOutputStream("D:\\myDoc\\temp.class"));) {
int temp;
// 读取文件并写入文件
while ((temp = dis.read()) != -1) {
out.write(temp);
}
} catch (IOException ioe) {
ioe.printStackTrace();
}
}
}
6. 缓冲流
之前学习了基本的一些流,作为IO流的入门,这次我们要见识一些更强大的流。比如能够高效读写的缓冲流,能够转换编码的转换流,能够持久化存储对象的序列化流等等。这些功能更为强大的流,都是在基本的流对象基础之上创建而来的,就像穿上铠甲的武士一样,相当于是对基本流对象的一种增强。
6.1 概述
缓冲流,也叫高效流(高级流),是对4个基本的FileXxx
流的增强,所以也是4个流,按照数据类型分类:
- 字节缓冲流:
BufferedInputStream
,BufferedOutputStream
- 字符缓冲流:
BufferedReader
,BufferedWriter
缓冲流的基本原理,是在创建流对象时,会创建一个内置的默认大小的缓冲区数组,通过缓冲区读写,减少系统IO次数,从而提高读写的效率。
6.2 字节缓冲流
1. 构造方法
public BufferedInputStream(InputStream in)
:创建一个 新的缓冲输入流。public BufferedOutputStream(OutputStream out)
: 创建一个新的缓冲输出流。
构造举例,代码如下:
// 创建字节缓冲输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
// 创建字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));
2. 效率测试
查询API,缓冲流读写方法与基本的流是一致的,我们通过复制大文件(375MB),测试它的效率。
-
基本流,代码如下:
public class FisCopyDemo { public static void main(String[] args) throws FileNotFoundException { // 记录开始时间 long start = System.currentTimeMillis(); // 创建流对象 try ( FileInputStream fis = new FileInputStream("D:\\Java\\jdk-11.0.7.rar"); FileOutputStream fos = new FileOutputStream("D:\\Java\\copy.rar") ){ // 读写数据 int b; while ((b = fis.read()) != -1) { fos.write(b); } } catch (IOException e) { e.printStackTrace(); } // 记录结束时间 long end = System.currentTimeMillis(); System.out.println("普通流复制时间:"+(end - start)+" 毫秒"); } } 十几分钟过去了...
-
缓冲流,代码如下:
public class BufferedDemo { public static void main(String[] args) throws FileNotFoundException { // 记录开始时间 long start = System.currentTimeMillis(); // 创建流对象 try ( BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\Java\\jdk-11.0.7.rar")); BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\Java\\copy.rar")); ){ // 读写数据 int b; while ((b = bis.read()) != -1) { bos.write(b); } } catch (IOException e) { e.printStackTrace(); } // 记录结束时间 long end = System.currentTimeMillis(); System.out.println("缓冲流复制时间:"+(end - start)+" 毫秒"); } } 缓冲流复制时间:2144 毫秒
如何更快呢?
使用数组的方式
低级流使用字节数组复制,代码如下:
public class FisCopyDemo {
public static void main(String[] args) throws FileNotFoundException {
// 记录开始时间
long start = System.currentTimeMillis();
// 创建流对象
try (
FileInputStream fis = new FileInputStream("D:\\Java\\jdk-11.0.7.rar");
FileOutputStream fos = new FileOutputStream("D:\\Java\\copy.rar")
){
// 读写数据
int b;
byte[] buf = new byte[8*1024];
while ((b = fis.read(buf)) != -1) {
fos.write(buf,0,b);
}
} catch (IOException e) {
e.printStackTrace();
}
// 记录结束时间
long end = System.currentTimeMillis();
System.out.println("普通流使用字节数组复制时间:"+(end - start)+" 毫秒");
}
}
// 普通流使用字节数组复制时间:262 毫秒
高级流使用字节数组复制,代码如下:
public class BufferedDemo {
public static void main(String[] args) throws FileNotFoundException {
// 记录开始时间
long start = System.currentTimeMillis();
// 创建流对象
try (
BufferedInputStream bis =
new BufferedInputStream(new FileInputStream("D:\\Java\\jdk-11.0.7.rar"));
BufferedOutputStream bos =
new BufferedOutputStream(new FileOutputStream("D:\\Java\\copy.rar"));
){
// 读写数据
int len;
byte[] bytes = new byte[8*1024];
while ((len = bis.read(bytes)) != -1) {
bos.write(bytes, 0 , len);
}
} catch (IOException e) {
e.printStackTrace();
}
// 记录结束时间
long end = System.currentTimeMillis();
System.out.println("缓冲流使用数组复制时间:"+(end - start)+" 毫秒");
}
}
// 缓冲流使用数组复制时间:304 毫秒
6.3 字符缓冲流
1. 构造方法
public BufferedReader(Reader in)
:创建一个 新的缓冲输入流。public BufferedWriter(Writer out)
: 创建一个新的缓冲输出流。
构造举例,代码如下:
// 创建字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("br.txt"));
// 创建字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
2. 特有方法
字符缓冲流的基本方法与普通字符流调用方式一致,不再阐述,我们来看它们具备的特有方法。
- BufferedReader:
public String readLine()
: 读一行文字。 - BufferedWriter:
public void newLine()
: 写一行行分隔符,由系统属性定义符号。
readLine
方法演示,代码如下:
public class BufferedReaderDemo {
public static void main(String[] args) throws IOException {
// 创建流对象
BufferedReader br = new BufferedReader(new FileReader("in.txt"));
// 定义字符串,保存读取的一行文字
String line = null;
// 循环读取,读取到最后返回null
while ((line = br.readLine())!=null) {
System.out.print(line);
System.out.println("------");
}
// 释放资源
br.close();
}
}
newLine
方法演示,代码如下:
public class BufferedWriterDemo throws IOException {
public static void main(String[] args) throws IOException {
// 创建流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
// 写出数据
bw.write("教育");
// 写出换行
bw.newLine();
bw.write("改变");
bw.newLine();
bw.write("生活");
bw.newLine();
// 释放资源
bw.close();
}
}
输出效果:
教育
改变
生活
7. 打印流
7.1 概述
平时我们在控制台打印输出,是调用print
方法和println
方法完成的,这两个方法都来自于java.io.PrintStream
类,该类能够方便地打印各种数据类型的值,是一种便捷的输出方式。
7.2 PrintStream类
构造方法
public PrintStream(String fileName)
: 使用指定的文件名创建一个新的打印流。
构造举例,代码如下:
PrintStream ps = new PrintStream("ps.txt");
7.3 改变打印流向
System.out
就是PrintStream
类型的,只不过它的流向是系统规定的,打印在控制台上。不过,既然是流对象,我们就可以玩一个"小把戏",改变它的流向。
public class PrintDemo {
public static void main(String[] args) throws IOException {
// 调用系统的打印流,控制台直接输出97
System.out.println(97);
// 创建打印流,指定文件的名称
PrintStream ps = new PrintStream("ps.txt");
// 设置系统的打印流流向,输出到ps.txt
System.setOut(ps);
// 调用系统的打印流,ps.txt中输出97
System.out.println(97);
System.out.println("字符");
ps.println("追加字符串");
ps.close();
}
}
输出:
教育改变生活
97
字符
追加字符串
8. 对象流
8.1 对象序列化概念
对象是存在于内存中的。有时候我们需要将对象保存到硬盘上,又有时我们需要将对象传输到另一台计算机上等等这样的操作。这时我们需要将对象转换为一个字节序列,而这个过程就称为对象序列化。相反,我们有这样一个字节序列需要将其转换为对应的对象,这个过程就称为对象的反序列化。
Java 提供了一种对象序列化的机制。
用一个字节序列可以表示一个对象,该字节序列包含该对象的数据
、对象的类型
和对象中存储的属性
等信息。字节序列写出到文件之后,相当于文件中持久保存了一个对象的信息。
反之,该字节序列还可以从文件中读取回来,重构对象,对它进行反序列化。对象的数据
、对象的类型
和对象中存储的数据
信息,都可以用来在内存中创建对象。看图理解序列化:
使用OOS实现对象序列化
ObjectOutputStream是用来对对象进行序列化的输出流。(将对象变成byte)
其实现对象序列化的方法为:void writeObject(Object o)
该方法可以将给定的对象转换为一个字节序列后写出。
使用OIS实现对象反序列化
ObjectInputStream是用来对对象进行反序列化的输入流。(将byte拼接为对象)
其实现对象反序列化的方法为:Object readObject()
该方法可以从流中读取字节并转换为对应的对象。
Serializable接口
ObjectOutputStream在对对象进行序列化时有一个要求,就是需要序列化的对象所属的类必须实现Serializable接口。
实现该接口不需要重写任何方法。其只是作为可序列化的标志。
建议:(必须遵守) 实现序列化接口是添加序列化序列化 版本号,可以保证对象序列化、反序列化的稳定。减少更改类对序列化的影响。
8.2 ObjectOutputStream类
java.io.ObjectOutputStream
类,将Java对象的原始数据类型写出到文件,实现对象的持久存储。
构造方法
public ObjectOutputStream(OutputStream out)
: 创建一个指定OutputStream的ObjectOutputStream。
构造举例,代码如下:
FileOutputStream fileOut = new FileOutputStream("employee.txt");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
序列化操作
- 一个对象要想序列化,必须满足两个条件:
-
该类必须实现
java.io.Serializable
接口,Serializable
是一个标记接口,不实现此接口的类将不会使任何状态序列化或反序列化,会抛出NotSerializableException
。 -
该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的,则该属性必须注明是瞬态的,使用
transient
关键字修饰。public class Student implements Serializable { private String name; private String address; //transient瞬态修饰成员,不会被序列化 private transient int age; //省略getter setter 以及 toString(); }
- 写出对象方法
-
public final void writeObject (Object obj)
: 将指定的对象写出。public class SerializeDemo { public static void main(String[] args) throws IOException { Student s = new Student(); s.setName("zhangsan"); s.setAddress("北京路"); s.setAge(21); // 创建序列化流对象 ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("stu.txt")); // 写出对象 out.writeObject(s); // 释放资源 out.close(); System.out.println("Serialized data is saved"); // 姓名,地址被序列化,年龄没有被序列化。 } } 输出结果: Serialized data is saved
8.3 ObjectInputStream类
ObjectInputStream反序列化流,将之前使用ObjectOutputStream序列化的原始数据恢复为对象。
构造方法
public ObjectInputStream(InputStream in)
: 创建一个指定InputStream的ObjectInputStream。
反序列化操作
如果能找到一个对象的class文件,我们可以进行反序列化操作,调用ObjectInputStream
读取对象的方法:
-
public final Object readObject ()
: 读取一个对象。public class DeserializeDemo { public static void main(String[] args) throws IOException, ClassNotFoundException { // 创建反序列化流 FileInputStream fileIn = new FileInputStream("stu.txt"); ObjectInputStream in = new ObjectInputStream(fileIn); // 读取一个对象 Student s = (Student) in.readObject(); // 释放资源 in.close(); // 无异常,直接打印输出 System.out.println(s); // 0 } } // 输出 Student [name=zhangsan, address=北京路, age=0]
对于JVM可以反序列化对象,它必须是能够找到class文件的类。如果找不到该类的class文件,则抛出一个 ClassNotFoundException
异常。
**另外,当JVM反序列化对象时,能找到class文件,但是class文件在序列化对象之后发生了修改,那么反序列化操作也会失败,抛出一个InvalidClassException
异常。**发生这个异常的原因如下:
- 该类的序列版本号与从流中读取的类描述符的版本号不匹配
- 该类包含未知数据类型
- 该类没有可访问的无参数构造方法
Serializable
接口给需要序列化的类,提供了一个序列版本号。serialVersionUID
该版本号的目的在于验证序列化的对象和对应类是否版本匹配。
public class Student implements Serializable {
/**
*
*/
private static final long serialVersionUID = -7522044567207948096L;
private String name;
private String address;
//transient瞬态修饰成员,不会被序列化
private transient int age;
//增加性别属性 不定义序列化版本时 反序列化时会抛出异常 InvalidClassException
private String gender;
//省略getter setter 以及 toString();
}
9. 转换流
9.1 字符编码和字符集
字符编码
计算机中储存的信息都是用二进制数表示的,而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制数转换之后的结果。按照某种规则,将字符存储到计算机中,称为编码 。反之,将存储在计算机中的二进制数按照某种规则解析显示出来,称为解码 。比如说,按照A规则存储,同样按照A规则解析,那么就能显示正确的文本符号。反之,按照A规则存储,再按照B规则解析,就会导致乱码现象。
编码:字符(能看懂的)–>字节(看不懂的)
解码:字节(看不懂的)–>字符(能看懂的)
-
字符编码
Character Encoding
: 就是一套自然语言的字符与二进制数之间的对应规则。编码表::生活中文字和计算机中二进制的对应规则
字符集
- 字符集
Charset
:也叫编码表。是一个系统支持的所有字符的集合,包括各国家文字、标点符号、图形符号、数字等。
计算机要准确的存储和识别各种字符集符号,需要进行字符编码,一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集、GBK字符集、Unicode字符集等。
可见,当指定了编码,它所对应的字符集自然就指定了,所以编码才是我们最终要关心的。
- ASCII字符集 :
- ASCII(American Standard Code for Information Interchange,美国信息交换标准代码)是基于拉丁字母的一套电脑编码系统,用于显示现代英语,主要包括控制字符(回车键、退格、换行键等)和可显示字符(英文大小写字符、阿拉伯数字和西文符号)。
- 基本的ASCII字符集,使用7位(bits)表示一个字符,共128字符。ASCII的扩展字符集使用8位(bits)表示一个字符,共256字符,方便支持欧洲常用字符。
- ISO-8859-1字符集:
- 拉丁码表,别名Latin-1,用于显示欧洲使用的语言,包括荷兰、丹麦、德语、意大利语、西班牙语等。
- ISO-8859-1使用单字节编码,兼容ASCII编码。
- GBxxx字符集:
- GB就是国标的意思,是为了显示中文而设计的一套字符集。
- GB2312:简体中文码表。一个小于127的字符的意义与原来相同。但两个大于127的字符连在一起时,就表示一个汉字,这样大约可以组合了包含7000多个简体汉字,此外数学符号、罗马希腊的字母、日文的假名们都编进去了,连在ASCII里本来就有的数字、标点、字母都统统重新编了两个字节长的编码,这就是常说的"全角"字符,而原来在127号以下的那些就叫"半角"字符了。
- GBK:最常用的中文码表。是在GB2312标准基础上的扩展规范,使用了双字节编码方案,共收录了21003个汉字,完全兼容GB2312标准,同时支持繁体汉字以及日韩汉字等。
- GB18030:最新的中文码表。收录汉字70244个,采用多字节编码,每个字可以由1个、2个或4个字节组成。支持中国国内少数民族的文字,同时支持繁体汉字以及日韩汉字等。
- Unicode字符集 :
- Unicode编码系统为表达任意语言的任意字符而设计,是业界的一种标准,也称为统一码、标准万国码。
- 它最多使用4个字节的数字来表达每个字母、符号,或者文字。有三种编码方案,UTF-8、UTF-16和UTF-32。最为常用的UTF-8编码。
- UTF-8编码,可以用来表示Unicode标准中任何字符,它是电子邮件、网页及其他存储或传送文字的应用中,优先采用的编码。互联网工程工作小组(IETF)要求所有互联网协议都必须支持UTF-8编码。所以,我们开发Web应用,也要使用UTF-8编码。它使用一至四个字节为每个字符编码,编码规则:
- 128个US-ASCII字符,只需一个字节编码。
- 拉丁文等字符,需要二个字节编码。
- 大部分常用字(含中文),使用三个字节编码。
- 其他极少使用的Unicode辅助字符,使用四字节编码。
9.2 编码引出的问题
在IDEA中,使用FileReader
读取项目中的文本文件。由于IDEA的设置,都是默认的UTF-8
编码,所以没有任何问题。但是,当读取Windows系统中创建的文本文件时,由于Windows系统的默认是GBK编码,就会出现乱码。
public class ReaderDemo {
public static void main(String[] args) throws IOException {
FileReader fileReader = new FileReader("E:\\File_GBK.txt");
int read;
while ((read = fileReader.read()) != -1) {
System.out.print((char)read);
}
fileReader.close();
}
}
输出结果:
���
那么如何读取GBK编码的文件呢?
9.3 InputStreamReader类
转换流java.io.InputStreamReader
,是Reader的子类,是从字节流到字符流的桥梁。它读取字节,并使用指定的字符集将其解码为字符。它的字符集可以由名称指定,也可以接受平台的默认字符集。
构造方法
InputStreamReader(InputStream in)
: 创建一个使用默认字符集的字符流。InputStreamReader(InputStream in, String charsetName)
: 创建一个指定字符集的字符流。
构造举例,代码如下:
InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt"));
InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");
指定编码读取
public class ReaderDemo2 {
public static void main(String[] args) throws IOException {
// 定义文件路径,文件为gbk编码
String FileName = "E:\\file_gbk.txt";
// 创建流对象,默认UTF8编码
InputStreamReader isr = new InputStreamReader(new FileInputStream(FileName));
// 创建流对象,指定GBK编码
InputStreamReader isr2 = new InputStreamReader(new FileInputStream(FileName) , "GBK");
// 定义变量,保存字符
int read;
// 使用默认编码字符流读取,乱码
while ((read = isr.read()) != -1) {
System.out.print((char)read); // ��Һ�
}
isr.close();
// 使用指定编码字符流读取,正常解析
while ((read = isr2.read()) != -1) {
System.out.print((char)read);// 大家好
}
isr2.close();
}
}
9.4 OutputStreamWriter类
转换流java.io.OutputStreamWriter
,是Writer的子类,是从字符流到字节流的桥梁。使用指定的字符集将字符编码为字节。它的字符集可以由名称指定,也可以接受平台的默认字符集。
构造方法
OutputStreamWriter(OutputStream in)
: 创建一个使用默认字符集的字符流。OutputStreamWriter(OutputStream in, String charsetName)
: 创建一个指定字符集的字符流。
构造举例,代码如下:
OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt"));
OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");
指定编码写出
public class OutputDemo {
public static void main(String[] args) throws IOException {
// 定义文件路径
String FileName = "E:\\out.txt";
// 创建流对象,默认UTF8编码
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(FileName));
// 写出数据
osw.write("你好"); // 保存为6个字节
osw.close();
// 定义文件路径
String FileName2 = "E:\\out2.txt";
// 创建流对象,指定GBK编码
OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream(FileName2),"GBK");
// 写出数据
osw2.write("你好");// 保存为4个字节
osw2.close();
}
}
转换流理解图解
转换流是字节与字符间的桥梁!