java.

io 包
回顾

使用 Data 类和 Calendar 类获取当前系统

时间及日期
使用 Random 类对象生成随机数
理解 Java 中的集合框架
使用 ArrayList 类创建动态数组
使用 HashMap 类创建键值对集合
使用 LinkedList 类创建链表
Vector 类
本章相关词汇

单 词 说 明
input 输入
output 输出
file 文件，档案
directory 目录
stream 流
write 写，书写
read 读，阅读
source 源头，来源
destination 目标，目的地
本章目标

了解 java.io 包
运用 File 类对文件或目录的属性进行操作
理解流，理解输入 / 输出流的概念
运用 FileInputStream 类和 FileOutputStream 类读 / 写字
节文件
运用 FileReader 类和 FileWriter 类配合 BufferedReader
类和 BufferedWriter 类读 / 写字符文件
使用 BufferedReader 类从控制台接受输入
运用 DataInputStream 类和 DataOutputStream 类读写
数据文件
java.io 包简介

java.io 包也是 Java 内置的包，其中包含

一系列对文件和目录的属性进行操作，对
文件进行读写操作的类；
程序中如果要使用到该包中的类，对文件
或流进行操作，则必须显式地声明如下语
句：
import java.io.*;
文件

什么是文件？
文件可以认为是相关记录或存放在一起的数据的
集合；
文件一般是存放在磁盘上的，例如：硬盘、软盘
和光盘等等。
File 类

File 类的对象不但可以表示文件，还可以
表示目录，在程序中一个 File 类对象可以
代表一个文件或目录；
当创建一个文件对象后，就可以利用它来
对文件或目录的属性进行操作，如：文件
名、最后修改日期、文件大小等等；
需要注意的是， File 对象并不能直接对文
件进行读 / 写操作，只能查看文件的属性；
File 类的构造方法

File 类的构造方法有 4 种重载方式，常用的如下

：
构 造 方 法 说 明

File(String pathname) 指定文件（或目录）名和路径创建文件对象

如：
// 在当前目录下创建一个与 aaa.txt 文件名相关联的文件对象
File f1 = new File("aaa.txt");
// 指明详细的路径以及文件名，请注意双斜线
File f2 = new File("D:\\Java\\Hello.java");
File 类中的常用方法

方 法 原 型 说 明
boolean exists() 判断文件是否存在，存在返回 true ，否则返回 false

boolean isFile() 判断是否为文件，是文件返回 true ，否则返回 false

boolean isDirectory() 判断是否为目录，是目录返回 true ，否则返回 false

String getName() 获得文件的名称

String getAbsolutePath() 获得文件的绝对路径

long length() 获得文件的长度（字节数）

boolean createNewFile() 创建新文件，创建成功返回 true ，否则返回 false ，

throws IOException 有可能抛出 IOException 异常，必须捕捉

boolean delete() 删除文件，删除成功返回 true ，否则返回 false

 File 类示例

public class FileDemo {

public static void main(String[] args) {
// 创建一个文件对象，使之与一个文件关联
File file = new File("test.txt");

// 显示与文件有关的属性信息
System.out.println(" 文件或目录是否存在： " + file.exists());
System.out.println(" 是文件吗： " + file.isFile());
System.out.println(" 是目录吗： " + file.isDirectory());
System.out.println(" 名称： " + file.getName());
System.out.println(" 绝对路径： " + file.getAbsolutePath());
System.out.println(" 最后修改时间： " + file.lastModified());
System.out.println(" 文件大小： " + file.length());
}
}
stream （流）

流是指一连串流动的数据信号，是以先进
先出的方式发送和接收数据的通道。

InputStream OutputStream
‘F’ ‘E’ ‘D’ ‘C’ ‘B’ ‘A’

来自数据源的数据流
流向目的地的数据流
流（续）
流的类型

根据流动方向的不同，流分为输入流和输出流；
对于输入和输出流，由于传输格式的不同，又分
为字节流和字符流：
– 字节流是指 8 位的通用字节流，以字节为基本单位，
在 java.io 包中，对于字节流进行操作的类大部分继
承于 InputStream （输入字节流）类和
OutputStream （输出字节流）类；
– 字符流是指 16 位的 Unicode 字符流，以字符（两个
字节）为基本单位，非常适合处理字符串和文本，对
于字符流进行操作的类大部分继承于 Reader （读取
流）类和 Writer （写入流）类。
使用 FileInputStream 类读文件

FileInputStream 类称为文件输入流，继承于
InputStream 类，是进行文件读操作的最基
本类；
它的作用是将文件中的数据输入到内存中，
我们可以利用它来读文件；
由于它属于字节流，因此在读取 Unicode 字
符（如中文）的文件时可能会出现问题。
FileInputStream 类的构造方法

FileInputStream 类的构造方法有 3 种重载方式

，以下是常用的几种。

构 造 方 法 说 明

FileInputStream(File file) 使用 File 对象创建文件输入流对象，如

throws FileNotFoundException 果文件打开失败，将抛出异常

FileInputStream(String name) 使用文件名或路径创建文件输入流对象，

throws FileNotFoundException 如果文件打开失败，将抛出异常
FileInputStream 类的常用方法

方 法 原 型 说 明

int read() 读取文件中的数据，一次读取一个字节，读

取的数据作为返回值返回，如果读到文件末
throws IOException 尾则返回 -1 ，有可能抛异常，必须捕捉

读取文件中的数据，将读到的数据存放到
int read(byte[] b) byte 型数组中，并返回读取的字节的数量，
throws IOException 未读到数据返回 -1 ，有可能抛异常，必须
捕捉

void close()
关闭流对象，有可能抛异常，必须捕捉
throws IOException
FileInputStream 对象读文件示例 1

public class FileInputStreamDemo1 {

public static void main(String[] args) {
try {
File file = new File("test.txt"); // 创建文件对象
// 使用文件对象创建文件输入流对象，相当于打开文件
FileInputStream fis = new FileInputStream(file);
for (int i = 0; i < file.length(); i++) {
char ch = (char)(fis.read()); // 循环读取字符
System.out.print(ch);
}
System.out.println();
fis.close(); // 关闭流
} catch (FileNotFoundException fnfe) {
System.out.println(" 文件打开失败。 ");
} catch (IOException ioe) {
ioe.printStackTrace();
}
}
}
FileInputStream 对象读文件示例 2

public class FileInputStreamDemo2 {

public static void main(String[] args) {
try {
File file = new File("test.txt"); // 创建文件对象
FileInputStream fis = new FileInputStream(file);
// 根据文件的字节长度创建字节数组
byte[] buf = new byte[(int)(file.length())];
fis.read(buf); // 读取文件中的数据存放到字节数组中
String str = new String(buf); // 利用字节数组创建字符串
System.out.println(str); // 打印字符串
fis.close(); // 关闭流
} catch (FileNotFoundException fnfe) {
System.out.println(" 文件打开失败。 ");
} catch (IOException ioe) {
ioe.printStackTrace();
}
}
}
使用 FileOutputStream 类写文件

FileOutputStream 类称为文件输出流，继承
于 OutputStream 类，是进行文件写操作的
最基本类；
它的作用是将内存中的数据输出到文件中，
我们可以利用它来写文件。
 FileOutputStream 类的构造方法

FileOutputStream 类的构造方法有 5 种重载方式，以下

是常用的几种。
构 造 方 法 说 明

FileOutputStream(File file) 使用 File 对象创建文件输出流对象，如果文

throws FileNotFoundException 件打开失败，将抛出异常

FileOutputStream(File file, boolean append) 使用 File 对象创建文件输出流对象，并由参

数 append 指定是否追加文件内容， true 为
throws FileNotFoundException 追加， false 为不追加，异常情况同上

FileOutputStream(String name) 直接使用文件名或路径创建文件输出流对象，

throws FileNotFoundException 异常情况同上

FileOutputStream(String name, boolean append) 直接使用文件名或路径创建文件输出流对象，

并由参数 append 指定是否追加，异常情况同
throws FileNotFoundException 上
FileOutputStream 类的常用方法

方 法 原 型 说 明

void write(int b) 往文件中写数据，一次写一个字节，有可能

throws IOException 抛异常，必须捕捉

void write(byte[] b) 往文件中写数据，将 byte 数组中的数据全

throws IOException 部写入到文件中，有可能抛异常，必须捕捉

void close()
关闭流对象，有可能抛异常，必须捕捉
throws IOException
FileOutputStream 对象写文件示例 1

public class FileOutputStreamDemo1 {

// 在函数内部不进行异常处理，将异常抛出函数外部
public static void main(String[] args) throws IOException {
String str = "Hello world!";
File file = new File("test.txt"); // 创建文件对象
// 通过文件对象创建文件输出流对象
// 附加第二个参数 true ，指定进行文件追加，默认为不追加
FileOutputStream fos = new FileOutputStream(file, true);

// 逐个将字符写入到文件中
for (int i = 0; i < str.length(); i++) {
fos.write(str.charAt(i));
}
fos.close(); // 关闭流
}
}
FileOutputStream 对象写文件示例 2

public class FileOutputStreamDemo2 {

// 在函数内部不进行异常处理，将异常抛出函数外部
public static void main(String[] args) throws Exception {
String str = "I Love Java";
// 通过文件名创建文件输出流对象
FileOutputStream fos = new FileOutputStream("test.txt");

// 将字符串转化为字节数组
byte[] buffer = str.getBytes();
// 将字节数组中包含的数据一次性写入到文件中
fos.write(buffer);
// 关闭流
fos.close();
}
}
FileInputStream/FileOutputStream 小结

FileInputStream 类和 FileOutputStream
类是成对出现的，一个进行输入（读文件
）操作，一个进行输出（写文件）操作；
由于采用字节方式进行数据传输，不必考
虑数据的格式问题，这两个类对文件操作
的效率较高；
可以使用这两个类完成复制文件的操作。
复制文件示例

public class CopyFileDemo {

public static void main(String[] args) throws IOException {
File srcFile = new File("src.dat"); // 源文件对象
File destFile = new File("dest.dat"); // 目标文件对象
if (!(destFile.exists())) { // 判断目标文件是否存在
destFile.createNewFile(); // 如果不存在则创建新文件
}
// 使用源文件对象创建文件输入流对象
FileInputStream fis = new FileInputStream(srcFile);
// 使用目标文件对象创建文件输出流对象
FileOutputStream fos = new FileOutputStream(destFile);
byte[] buf = new byte[1024]; // 创建字节数组，作为临时缓冲
System.out.println(" 开始复制文件 ...");
while (fis.read(buf) != -1) { // 循环从文件输入流中读取数据
fos.write(buf); // 写入到文件输出流中
}
System.out.println(" 文件复制成功！ ");
fis.close(); // 关闭流
fos.close();
}
}
字符流

FileInputStram 类和 FileOutputStream 类虽
然可以高效率地读 / 写文件，但对于 Unicode
编码的文件，使用它们有可能出现乱码；
考虑到 Java 是跨平台的语言，要经常操作
Unicode 编码的文件，使用字符流操作文件
是有必要的；
使用字符流将涉及到以下 4 个类：
– FileReader 类和 FileWriter 类；
– BufferedReader 类和 BufferedWriter 类。
FileReader 类

FileReader 类称为文件读取流，允许以字符流的形式对
文件进行读操作，其构造方法有 3 种重载方式，以下是
常用的几种：
构 造 方 法 说 明
FileReader(File file) 使用 File 对象创建文件读取流对象，如
throws FileNotFoundException 果文件打开失败，将抛出异常

FileReader(String name) 使用文件名或路径创建文件读取流对象，

throws FileNotFoundException 如果文件打开失败，将抛出异常

该类将从文件中逐个地读取字符，效率比较低下，因此
一般将该类对象包装到缓冲流中进行操作。
BufferedReader 类

BufferedReader 类主要为字符流提供缓冲，以提高效率
，其构造方法有 2 种重载方式，以下是常用的几种：
构 造 方 法 说 明
BufferedReader(Reader in) 将字符读取流对象包装成缓冲读取流对象

以下是 BufferedReader 类的常用方法：

方 法 原 型 说 明

String readLine() 从缓冲读取流中读取一行字符，以字符串的

throws IOException 形式返回，有可能抛异常，必须捕捉
void close()
关闭流对象，有可能抛异常，必须捕捉
throws IOException
FileReader 配合 BufferedReader 读文件示例

public class RraderDemo {

public static void main(String[] args) throws IOException {
File file = new File("test.txt");
// 通过文件对象创建文件读取流对象
FileReader fr = new FileReader(file);
// 将文件读取流包装成缓冲读取流
BufferedReader br = new BufferedReader(fr);

String str;
while ((str = br.readLine()) != null) {// 逐行读取数据
System.out.println(str);
}
br.close(); // 关闭流
fr.close(); // 关闭流
}
}
FileWriter 类

FileWriter 类称为文件写入流，以字符流的形式对文件进行
写操作，其构造方法有 5 种重载，以下是常用的几种：

构 造 方 法 说 明
FileWriter(File file) 使用 File 对象创建文件写入流对象，如果文件打
throws IOException 开失败，将抛出异常，必须捕捉

FileWriter(File file, boolean append) 使用 File 对象创建文件写入流对象，并由参数

throws IOException append 指定是否追加，异常情况同上

FileWriter(String name) 直接使用文件名或路径创建文件写入流对象，异

throws IOException 常情况同上

FileWriter(String name, boolean append) 直接使用文件名或路径创建文件写入流对象，并

throws IOException 由参数 append 指定是否追加，异常情况同上
与 FileReader 类相似， FileWriter 类同样需要使用缓冲流进
行包装。
BufferedWriter 类

BufferedWriter 类可以为 FileWriter 类提供缓冲，其构造

方法有 2 种重载方式，以下是常用的几种：
构 造 方 法 说 明
BufferedWriter(Writer out) 将字符写入流对象包装成缓冲写入流对象

以下是 BufferedWriter 类的常用方法：

方 法 原 型 说 明

void write(String str) 将一行字符串写入到缓冲写入流中，有可能

throws IOException 抛异常，必须捕捉
void newLine() 将一个回车换行符写入到文件中，从而达到
throws IOException 换行的效果，有可能抛异常，必须捕捉
FileWriter 配合 BufferedWriter 写文件示例

public class WriterDemo {

public static void main(String[] args) throws IOException {
File file = new File("test.txt");
// 通过文件对象创建文件输出字符流对象
FileWriter fw = new FileWriter(file);
// 将文件输出字符流包装成缓冲流
BufferedWriter bw = new BufferedWriter(fw);
bw.write(" 大家好！ ");
bw.write(" 我正在学习 Java 。 ");
bw.newLine(); // 换个新行
bw.write(" 请多多指教。 ");
bw.newLine(); // 换新行
bw.write("Luckybug@21cn.com");
bw.close(); // 关闭流
fw.close(); // 关闭流
}
}
从控制台接受输入

System.in 的 read 方法可以从控制台接受输入；

但由于 in 实际上是一个 InputStream 类的对象，它只能
以字节形式接收数据，并且一次只能接受一个字节，这
使输入操作很不便；
必须将 System.in 进行处理，才可以顺利地从控制台接
受输入，这将使用到 :
– InputStreamReader 类
– BufferedReader 类
转换和包装 System.in

InputStreamReader 类用于将 InputStream 类型的字节输

入流对象转换成 Reader 类型的字符读取流对象；
其构造方法有 4 种重载方式，常用的如下：
构 造 方 法 说 明
InputStreamReader(InputStream in) 将 InputStream 对象转换成 Reader 对象

可以使用它来转换 System.in ，如：

InputStreamReader isr = new
InputStreamReader(System.in);
这样的字符流效率很低，再使用 BufferedReader 类来为
其建立缓冲，如：
BufferedReader br = new BufferedReader(isr);
这样，就可以从控制台接受输入了。
从控制台接受输入示例

public class ConsoleInputDemo {

public static void main(String[] args) throws IOException {
// 将 System.in 转化成字符流对象
InputStreamReader isr = new InputStreamReader(System.in);
// 用缓冲流进行包装
BufferedReader br = new BufferedReader(isr);

System.out.println(" 请输入您的姓名： ");

String name = br.readLine(); // 接受输入
System.out.println(" 请输入您的年龄： ");
int age = Integer.parseInt(br.readLine()); // 接受输入

System.out.println(" 您的姓名： " + name);

System.out.println(" 您的年龄： " + age);

br.close(); // 关闭流
isr.close(); // 关闭流
}
}
 从控制台输入并写入到文件示例

/* 本例从控制台接受输入，然后写入到文件中，直到用户输入 "!!!" 为止 */
File file = new File("input.txt"); // 创建文件对象
if (!file.exists()) {// 判断该文件是否存在，如果不存在则创建新文件
file.createNewFile();
}
FileWriter fr = new FileWriter(file); // 针对文件对象创建文件写入流对象
BufferedWriter bw = new BufferedWriter(fr); // 为文件写入流建立缓冲流

// 将控制台输入对象转化成字符流，并建立缓冲流
BufferedReader bin = new BufferedReader(new InputStreamReader(System.in));

String str = bin.readLine(); // 接受从控制台输入的一行字符串

while (!(str.equals("!!!"))) {// 如果输入 "!!!" 则代表输入结束
bw.write(str); // 将从控制台输入的字符串写入到文件中
bw.newLine(); // 换新行
str = bin.readLine(); // 再从控制台接受输入
}

// 关闭所有已经打开的流
bw.close();
fr.close();
bin.close();
基本数据类型的读 / 写

FileInputStream 和 FileOutputStream 在
读写文件时不考虑数据的类型；
FileWriter 和 FileReader 在读写文件时，
将所有的数据都看做字符；
但有时候，我们需要将各种类型的数据写
入文件或是从文件中读
取， DataInputStream 类和
DataOutputStream 类可以满足需要。
DataInputStream 类

DataInputStream 类可以输入任何类型的数据，
但它不可以单独使用，需要要配合其它字节输入
流一起使用；
DataInputStream 类的构造方法只有一种方式：
构 造 方 法 说 明
利用其它的字节输入流创建数据输入
DataInputStream(InputStream in)
流对象

如：
// 将文件输入流包装成数据输入流，以便从文件中读取各种类型的数据
FileInputStream fis = new FileInputStream("data.dat");
DataInputStream dis = new DataInputStream(fis);
DataInputStream 类的常用方法

方 法 原 型 说 明
final boolean readBoolean()
从数据输入流中读取一个 boolean 型数据
throws IOException
final char readChar()
从数据输入流中读取一个 char 型数据
throws IOException
final int readInt()
从数据输入流中读取一个 int 型数据
throws IOException
final long readLong()
从数据输入流中读取一个 long 型数据
throws IOException
final float readFloat()
从数据输入流中读取一个 float 型数据
throws IOException
final float readDouble()
从数据输入流中读取一个 double 型数据
throws IOException
DataOutputStream 类

DataOutputStream 类可以输出任何类型的数据
，同样也需要配合其他字节输出流一起使用；
DataOutputStream 类的构造方法如下：
构 造 方 法 说 明
利用其它的字节输出流创建数据
DataOutputStream(OutputStream out)
输出流对象

如：
// 将文件输出流包装成数据输出流，以便往文件中写入各种类型的数据
FileOutputStream fos = new
FileOutputStream("data.dat");
DataOutputStream dos = new DataOutputStream(fos);
DataOutputStream 类的常用方法

方 法 原 型 说 明
final void writeBoolean(boolean
v) 往数据输出流中写入一个 boolean 型数据
throws IOException
final void writeChar(char v)
往数据输出流中写入一个 char 型数据
throws IOException
final void writeInt(int v)
往数据输出流中写入一个 int 型数据
throws IOException
final void writeLong(long v)
往数据输出流中写入一个 long 型数据
throws IOException
final void writeFloat(float v)
往数据输出流中写入一个 float 型数据
throws IOException
final void writeDouble(double v)
往数据输出流中写入一个 double 型数据
throws IOException
总结 1

java.io 包是 Java 内置的包，其中包含一系列对

输入 / 输出进行操作的类；
File 类的对象可以访问文件（或目录）的属性，
但不可以进行读 / 写操作；
从方向上讲，流分为输入流和输出流，但从格式
上区分的话，流分为字节流和字符流；
使用 FileInputStream 类和 FileOutputStream 类
以字节流方式对文件进行读 / 写操作，这是操作
文件最基本的两个类；
总结 2

FileReader 类和 FileWriter 类配合

BufferedReader 类和 BufferedWriter 类可以以
字符流方式对文件进行读 / 写操作；
从控制台接受输入要使用到 InputStreamReader
类和 BufferedReader 类；
DataInputStream 类和 DataOutputStream 类允
许读 / 写各种基本数据类型；
绝大部分的 IO 操作都可能抛出 IOException 。