JavaSE 14 IO，javase14io
JavaSE 14 IO，javase14io
1、File类
概念
File类位于java.io包下。其提供了一系列对文件或目录进行操作的方法。
构造方法
⑴ public File(String pathname) {}
根据指定的路径字符串，构造一个File对象。
一个File对象，可以看作是指向磁盘中一个具体的文件或目录的指针（引用）。
例如：
File file1 = new File(“D:\Program\log.txt”); // 文件
File file2 = new File(“D:\Program”); // 目录【文件夹】
⑵ public File(String parent, String child) {}
根据父级路径和子级路径，构造一个File对象。
⑶ public File(File parent, String child) {}
根据父级目录和子级路径，构造一个File对象。
方法列举
mkdir
public boolean mkdir() {}
创建一级目录
mkdirs
public boolean mkdirs() {}
创建多级目录
createNewFile
public boolean createNewFile() throws IOException {}
创建文件
delete
public boolean delete() {}
删除文件或空目录
exists
public boolean exists() {}
判断某文件对象表示的文件或目录是否存在。
isDirectory
public boolean isDirectory() {}
判断某文件对象所表示的是否是一个目录。
isFile
public boolean isFile() {}
判断某文件对象所表示的是否是一个文件。
isHidden
public boolean isHidden() {}
判断某文件对象所表示的文件是否是一个隐藏文件。
length
public long length() {}
返回文件的大小。以字节为单位；如果文件不存在或是特殊的系统文件，则返回 0L。如果此文件对象表示一个目录，则返回值是不确定的。
getName
public String getName() {}
返回文件或目录的名称。
getAbsolutePath
public String getAbsolutePath() {}
返回文件或目录的绝对路径。
getParent
public String getParent() {}
返回父目录的路径名。如果此文件或目录没有指定父目录，则返回 null。
getParentFile
public File getParentFile() {}
返回父目录的File对象。如果此文件或目录没有指定父目录，则返回 null。
list
public String[] list() {}
返回一个String数组，其元素为File对象所在的路径下的，所有文件或目录的名字。
listFiles
public File[] listFiles() {}
返回一个File数组，其元素为File对象所在的路径下的，所有文件或目录的File对象。
遍历指定目录下的所有文件
private void showFiles(File file) {
File[] files = file.listFiles();
for (int i = 0; i < files.length; i++) {
if (files[i].isFile()) {
System.out.println(files[i]);
} else {
showFiles(files[i]); // 如果是目录则继续遍历显示【自己调用自己】
}
}
}
Tip：这里用到了递归的思想。
满足递归的条件：⑴ 定义在方法中。⑵ 自己调用自己。⑶ 有一个终止条件。
一般来讲，除非不得已，否则尽量少用递归，减少对内存的消耗。
2、文件流
概念
数据，在程序和节点之间进行传输。
节点
⑴ 源节点：输入流的源设备。如：键盘等。
⑵ 目标节点：输出流的目标设备。如：显示器等。
分类
按流向
⑴ 输入流：数据从其他节点流向程序。
⑵ 输出流：数据从程序流向其他节点。
按传输的单位
⑴ 字节流：按照字节传输，一个字节一个字节地传输。一般通过字节流来读写不包含中文的二进制文件。像图片、音频、视频等。
⑵ 字符流：按照字符传输，一个字符一个字符地传输。一般通过字符流来读写纯文本文件（尤其是包含中文的，可以一定程度上解决乱码问题）。
按功能
⑴ 基础流：用于基本的读写功能。
⑵ 包装流：在基础流的基础上，增强了一些其他的功能（提高效率、读写对象数据）。
3、文件流的体系图
字节输入流【InputStream抽象类】
FileInputStream
ObjectInputStream
BufferedInputStream
字节输出流【OutputStream抽象类】
FileOutputStream
ObjectOutputStream
BufferedOutputStream
字符输入流【Reader抽象类】
FileReader
BufferedReader
IutputStreamReader
字符输出流【Writer抽象类】
FileWriter
BufferedWriter
OutputStreamWriter
4、FileInputStream类
功能
按字节将文件中的数据读取到程序中。
构造方法
⑴ public FileInputStream(String name) throws FileNotFoundException {}
构造一个FileInputStream对象，该对象指向一个路径字符串对应的具体文件。
⑵ public FileInputStream(File file) throws FileNotFoundException {}
构造一个FileInputStream对象，该对象指向一个File对象对应的具体文件。
方法列举
read()
public native int read() throws IOException;
读取单个字节并返回，返回值类型为int。如果没有读到内容，则返回-1。
read(byte[] b)
public int read(byte b[]) throws IOException {}
读取一定长度的字节，并保存到byte数组中，返回读取到的字节数。如果没有读到内容，则返回-1。
read(byte[] b, int off, int len)
public int read(byte b[], int off, int len) throws IOException {}
读取指定长度的字节，并保存到byte数组的指定部分中，返回读取到的字节数。如果没有读到内容，则返回-1。
第二个参数为byte数组保存的起始位置（从0开始），第三个参数为一次读取的长度。
close
public void close() throws IOException {}
关闭FileInputStream对象，并释放与此流有关的所有系统资源。
使用时用到的其他类的方法
String(byte[] bytes)
public String(byte[] bytes) {}
将传入的byte数组构造成一个字符串。
注意：使用此构造方法时，应当注意byte数组的元素是否已经全部替换（更新）过，否则单纯输出，而不判断读取到的字节数量，会输出已经存在于数组中的旧的数据。推荐使用下面的构造方法。
String(byte[] bytes, int offset, int length)
public String(byte bytes[], int offset, int length) {}
将传入的byte数组的指定部分，构造成一个字符串。第二个参数为byte数组的起始位置（从0开始），第三个参数为要取出的元素个数。
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.IOException;
public class Test {
public static void main(String[] args) throws IOException {
InputStream is = new FileInputStream("C:\\Users\\Administrator\\Desktop\\Test.java");
// 读取单个字节
int data = is.read();
System.out.println(data); // 105
data = is.read();
System.out.println((char)data); // m
// 读取多个字节并保存到byte数组中
byte[] buffer = new byte[10];
int len = is.read(buffer);
System.out.println(new String(buffer)); // port java.
System.out.println(len); // 10
// 读取指定长度字节并保存到byte数组的指定位置处
byte[] b = new byte[10];
int l = is.read(b, 2, 5);
System.out.println(new String(b, 3, 2)); // o.
System.out.println(l); // 5
// 关闭流
is.close();
}
}
使用示例
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.IOException;
public class Test {
public static void main(String[] args) {
InputStream is = null;
try {
is = new FileInputStream("C:\\Users\\Administrator\\Desktop\\Test.java");
byte[] buffer = new byte[32];
int len;
while (-1 != (len = is.read(buffer))) {
System.out.print(new String(buffer, 0, len)); // 这里就用到了第二个构造方法，如果不判断读取到的字节长度，结果可能不会理想 【注意不要换行】
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != is) {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
5、FileOutputStream类
功能
按字节将程序中的数据输出到文件中。
构造方法
⑴ public FileOutputStream(String name) throws FileNotFoundException {}
构造一个FileOutputStream对象，该对象指向一个路径字符串对应的具体文件。写入的内容会覆盖原有的文件。
⑵ public FileOutputStream(File file) throws FileNotFoundException {}
构造一个FileOutputStream对象，该对象指向一个File对象对应的具体文件。写入的内容会覆盖原有的文件。
⑶ public FileOutputStream(String name, boolean append) throws FileNotFoundException {}
构造一个FileOutputStream对象，该对象指向一个路径字符串对应的具体文件。第二个参数为是否将写入的内容追加到原有的文件末位。true为追加。
⑷ public FileOutputStream(File file, boolean append) throws FileNotFoundException {}
构造一个FileOutputStream对象，该对象指向一个File对象对应的具体文件。写入的内容会覆盖原有的文件。第二个参数为是否将写入的内容追加到原有的文件末位。true为追加。
注意：当输出的目标文件不存在时，执行输出语句，会创建目标文件。但不能没有路径，否则报错：(系统找不到指定的路径。)。
方法列举
write(int b)
public void write(int b) throws IOException {}
写入单个字节。
write(byte[] b)
public void write(byte b[]) throws IOException {}
写入byte数组。
write(byte[] b, int off, int len)
public void write(byte b[], int off, int len) throws IOException {}
写入byte数组的指定部分。第二个参数为byte数组的起始位置（从0开始），第三个参数为要写入的元素个数。
close
public void close() throws IOException {}
关闭FileOutputStream对象，并释放与此流有关的所有系统资源。
使用时用到的其他类的方法
【String类中的getBytes方法】
public byte[] getBytes() {}
将字符串转换为一个byte数组。
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class Test {
public static void main(String[] args) throws IOException {
OutputStream os = null;
os = new FileOutputStream("src\\test\\a.txt"); // 可以没有a.txt，但不能没有src\test路径
// 输出单个字符
os.write('a');
os.write(97);
// 输出byte数组内的元素内容
String str = "字符串";
byte[] b = str.getBytes();
os.write(b);
// 输出byte数组中指定的元素内容
os.write("Hello Java!".getBytes(), 6, 5);
os.close(); // 最终结果【aa字符串Java!】
}
}
使用示例
复制文件
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class Test {
public static void main(String[] args) {
String src = "???"; // 源文件路径
String dest = "???"; // 目标文件路径
InputStream is = null;
OutputStream os = null;
try {
is = new FileInputStream(src);
os = new FileOutputStream(dest);
byte[] buffer = new byte[1024 * 8];
int len;
while (-1 != (len = is.read(buffer))) {
os.write(buffer, 0, len);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != os) {
try {
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (null != is) {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
6、FileReader类
功能
按字符将文件中的数据读取到程序中。
构造方法
⑴ public FileReader(String fileName) throws FileNotFoundException {}
构造一个FileReader对象，该对象指向一个路径字符串对应的具体文件。
⑵public FileReader(File file) throws FileNotFoundException {}
构造一个FileReader对象，该对象指向一个File对象对应的具体文件。
方法列举
read()
public int read() throws IOException {}
读取单个字符并返回，返回值类型为int。如果没有读到内容，则返回-1。
read(char[] c)
public int read(char cbuf[]) throws IOException {}
读取一定长度的字符，并保存到char数组中，返回读取到的字符数。如果没有读到内容，则返回-1。
read(char[] c, int offset, int length)
public int read(char cbuf[], int offset, int length) throws IOException {}
读取指定长度的字符，并保存到char数组的指定部分中，返回读取到的字符数。如果没有读到内容，则返回-1。
第二个参数为char数组保存的起始位置（从0开始），第三个参数为一次读取的长度。
close
public void close() throws IOException {}
关闭FileReader对象，并释放与此流有关的所有系统资源。
使用时用到的其他类的方法
String(char[] c)
public String(char value[]) {}
将传入的char数组构造成一个字符串。
注意：使用此构造方法时，应当注意char数组的元素是否已经全部替换（更新）过，否则单纯输出，而不判断读取到的字节数量，会输出已经存在于数组中的旧的数据。推荐使用下面的构造方法。
String(char[] c, int offset, int length)
public String(char value[], int offset, int count) {}
将传入的char数组的指定部分，构造成一个字符串。第二个参数为char数组的起始位置（从0开始），第三个参数为要取出的元素个数。
//测试文字
import java.io.FileReader;
import java.io.IOException;
public class Test {
public static void main(String[] args) throws IOException {
FileReader fr = new FileReader("C:\\Users\\Administrator\\Desktop\\Test.java");
// 读取单个字符
int data = fr.read();
System.out.println((char)data); // /【斜杠】
data = fr.read();
System.out.println((char)data); // / 【斜杠】
data = fr.read();
System.out.println((char)data); // 测
// 读取多个字符，并保存到一个char数组中
char[] buffer = new char[10];
int len = fr.read(buffer);
System.out.println(len); // 10
System.out.println(new String(buffer)); // 试文字 \n impor
// 读取多个字符，保存到char数组的指定位置处
char[] c = new char[10];
int l = fr.read(c, 2, 6);
System.out.println(l); // 6
System.out.println(new String(c, 4, 4)); // java
fr.close();
}
}
使用示例
读取文本文件内容
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class Test {
public static void main(String[] args) {
FileReader fr = null;
try {
fr = new FileReader("C:\\Users\\Administrator\\Desktop\\Test.java");
char[] buffer = new char[1024 * 8];
int len;
while (-1 != (len = fr.read(buffer))) {
System.out.println(new String(buffer, 0, len));
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != fr) {
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
7、FileWriter类
功能
用字符将程序中的数据输出到文件中。
构造方法
⑴public FileWriter(String fileName) throws IOException {}
构造一个FileWriter对象，该对象指向一个路径字符串对应的具体文件。写入的内容会覆盖原有的文件。
⑵ public FileWriter(File file) throws IOException {}
构造一个FileWriter对象，该对象指向一个File对象对应的具体文件。写入的内容会覆盖原有的文件。
⑶ public FileWriter(String fileName, boolean append) throws IOException {}
构造一个FileWriter对象，该对象指向一个路径字符串对应的具体文件。第二个参数为是否将写入的内容追加到原有的文件末位。true为追加。
⑷ public FileWriter(File file, boolean append) throws IOException {}
构造一个FileWriter对象，该对象指向一个File对象对应的具体文件。写入的内容会覆盖原有的文件。第二个参数为是否将写入的内容追加到原有的文件末位。true为追加。
注意：当输出的目标文件不存在时，执行输出语句，会创建目标文件。但不能没有路径，否则报错：(系统找不到指定的路径。)。
方法列举
write(int c)
public void write(int c) throws IOException {}
写入单个字符。
write(char[] c)
public void write(char cbuf[]) throws IOException {}
写入char数组。
write(char[] c, int off, int len)
public void write(char cbuf[], int off, int len) throws IOException {}
写入char数组的指定部分。第二个参数为byte数组的起始位置（从0开始），第三个参数为要写入的元素个数。
writer(String str)
public void write(String str) throws IOException {}
写入字符串。
在Windows操作系统下，换行：\r\n
writer(String str, int off, int len)
public void write(String str, int off, int len) throws IOException {}
写入字符串的指定部分。第二个参数为子字符串的起始位置（从0开始），第三个参数为要写入的字符个数。
flush
public void flush() throws IOException {}
刷新该流的缓冲。该方法的作用是：立即将该流中已保存在缓冲区中的所有字符，写入到目标文件中。
close
public void close() throws IOException {}
先刷新FileWriter对象,再关闭FileWriter对象，并释放与此流有关的所有系统资源。
注意：当用FileWriter写文件时，必须使用flush或close方法，否则数据将不能保证被写入到物理设备（如磁盘驱动器）中。
使用时用到的其他类的方法
String类中的toCharArray方法
public char[] toCharArray() {}
将字符串转换为一个char数组。
import java.io.FileWriter;
import java.io.IOException;
public class Test {
public static void main(String[] args) throws IOException {
FileWriter fw = new FileWriter("???");
// 写入单个字符
fw.write('A');
fw.write(65);
// 写入字符数组
String str = "hello java!";
char[] buffer = str.toCharArray();
fw.write(buffer);
// 写入字符数组的指定位置
fw.write("Hello World".toCharArray(), 6, 5);
// 写入字符串
fw.write("这是一个字符串\r\n");
// 写入字符串的指定子字符
fw.write("美好的程序", 3, 2);
fw.close(); // 最终结果【AAhello java!World这是一个字符串 \n 程序】
}
}
使用示例
复制文本文件
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Test {
public static void main(String[] args) {
String src = "???"; // 源文件路径
String dest = "???"; // 目标文件路径
FileReader fr = null;
FileWriter fw = null;
try {
fr = new FileReader(src);
fw = new FileWriter(dest);
char[] buffer = new char[1024 * 8];
int len;
while (-1 != (len = fr.read(buffer))) {
fw.write(buffer, 0, len);
fw.flush(); // 刷新缓冲区
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != fw) {
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (null != fr) {
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
8、包装流
功能
包装流主要用于增强功能。
分类
⑴ 缓冲流
⑵ 包装流
9、缓冲流【包装流之一】
功能
主要用于提高读写的效率。原因在于流中维护了一个数组，可以实现批量的读写。 BufferedInputStream用于增强InputStream的效率 BufferedOutputStream用于增强OutputStream的效率 BufferedReader用于增强Reader的效率 BufferedWriter用于增强Writer的效率使用特点
⑴ 创建缓冲流对象Buffered基础流对象 名 = new Buffered基础流对象();
⑵ 调用读写方法 其使用和基础流一样。
不同的是： BufferedReader中多了一个readLine方法。
BufferedWriter中多了一个newLine方法。
⑶ 关闭流对象 只关闭最外层的缓冲流即可。
10、BufferedInputStream【缓冲流之一】
构造方法
⑴ public BufferedInputStream(InputStream in) {}
构造一个BufferedInputStream，默认缓冲大小为8192【8KB】。需要传入一个InputStream。
⑵ public BufferedInputStream(InputStream in, int size) {}
构造一个指定缓冲大小的BufferedInputStream。需要传入一个InputStream。
使用示例
见BufferedOutputStream的使用示例。
11、BufferedOutputStream【缓冲流之一】
构造方法
⑴ public BufferedOutputStream(OutputStream out) {}
构造一个BufferedOutputStream，默认缓冲大小为8192【8KB】。需要传入一个OutputStream。
⑵ public BufferedOutputStream(OutputStream out, int size) {}
构造一个指定缓冲大小的BufferedOutputStream。需要传入一个OutputStream。
使用示例
【复制文件】
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Test {
public static void main(String[] args) {
String src = "???"; // 源文件路径
String dest = "???"; // 目标文件路径
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
bis = new BufferedInputStream(new FileInputStream(src));
bos = new BufferedOutputStream(new FileOutputStream(dest));
byte[] buffer = new byte[1024];
int len;
while (-1 != (len = bis.read(buffer))) {
bos.write(buffer, 0, len);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != bos) {
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (null != bis) {
try {
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
12、BufferedReader【缓冲流之一】
构造方法
⑴ public BufferedReader(Reader in) {}
构造一个BufferedReader，默认缓冲大小为8192【8KB】。需要传入一个Reader。
⑵ public BufferedReader(Reader in, int sz) {}
构造一个指定缓冲大小的BufferedReader。需要传入一个Reader。
比BufferedReader多出的方法
readLine
public String readLine() throws IOException {}
读取一个文本行。通过下列字符之一即可认为某行已终止：换行 (‘\n’)、回车 (‘\r’) 或回车后直接跟着换行。 如果已到达流末尾（取不出字符），则返回 null。
使用示例
见BufferedWriter的使用示例。
13、BufferedWriter【缓冲流之一】
构造方法
⑴ public BufferedWriter(Writer out) {}
构造一个BufferedWriter，默认缓冲大小为8192【8KB】。需要传入一个Writer。
⑵ public BufferedWriter(Writer out, int sz) {}
构造一个指定缓冲大小的BufferedWriter。需要传入一个Writer。
比BufferedWriter多出的方法
newLine
public void newLine() throws IOException {}
写入一个行分隔符。行分隔符字符串根据当前系统的不同而不同。
使用示例
【重复复制文本文件的内容到同一文件中】
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Test {
public static void main(String[] args) {
String src = "???"; // 源文件路径
String dest = "???"; // 目标文件路径
BufferedReader br = null;
BufferedWriter bw = null;
try {
br = new BufferedReader(new FileReader(src));
bw = new BufferedWriter(new FileWriter(dest, true)); // 追加文本
String str;
while (null != (str = br.readLine())) {
bw.write(str);
bw.newLine(); // 换行
bw.flush(); // 刷新缓冲区
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != bw) {
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (null != br) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
14、对象流
功能
可以在字节流的基础上实现基本数据类型和引用数据类型的读写，并且保证读写出来的是同一个对象。
分类
ObjectOutputStream 序列化流
ObjectInputStream 反序列化流
15、序列化和反序列化
序列化
用ObjectOutputStream将数据持久化到本地或网络的机制。
反序列化
用ObjectInputStream将本地或网络的数据读取到内存中的机制。
使用序列化的原因
如果没有用序列化，则没有办法保证读写的对象是同一个。
使用序列化的特点
⑴ 使用序列化读取流读取的文件，必须是曾经用序列化写入流写入过的文件。
⑵ 读写的顺序必须一致，否则不能达到预期的效果。
⑶ 读写的元素的类型必须实现序列化。
因为：
① 只能将实现Serializable接口的对象写入流中。
② 只有实现Serializable接口或Externalizable接口的对象才能从流中读取。
如何实现序列化
让对象类型实现Serializable接口或实现Externalizable接口。建议实现Serializable接口，因为它是一个标志性接口【空接口】，即它没有定义方法。
public interface Serializable {
}
16、ObjectOutputStream【序列化流类】
构造方法
public ObjectOutputStream(OutputStream out) throws IOException {}
构造一个ObjectOutputStream，需要传入一个OutputStream。输出的文件一般以.dat结尾。
方法列举
writeInt
public void writeInt(int val) throws IOException {}
写入一个int值。占4个字节。
writeDouble
public void writeDouble(double val) throws IOException {}
写入一个double值。占8个字节。
writeChar
public void writeChar(int val) throws IOException {}
写入一个char值。占2个字节。
writeBoolean
public void writeBoolean(boolean val) throws IOException {}
写入一个boolean值。占1个字节。
writeUTF
public void writeUTF(String str) throws IOException {}
写入一个字符串（String）。字节占位不一定。
writeChars
public void writeChars(String str) throws IOException {}
以 char 序列形式写入一个 String。
writeObject
public final void writeObject(Object obj) throws IOException {}
写入一个对象。字节占位不一定。
使用示例
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class Test {
public static void main(String[] args) {
String path = "???.dat"; // 数据文件输出路径 【一般以.dat结尾】
ObjectOutputStream oos = null;
try {
oos = new ObjectOutputStream(new FileOutputStream(path));
oos.writeInt(123); // 写入一个int值
oos.writeDouble(3.14); // 写入一个double值
oos.writeChar(97); // 写入一个char值
oos.writeChar('a'); // 写入一个char值
oos.writeBoolean(false); // 写入一个boolean值
oos.writeUTF("这是一个字符串"); // 写入一个字符串
oos.writeChars("可以看到我吗？"); // 以char序列形式写入一个字符串
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != oos) {
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
17、ObjectInputStream【反序列化流类】
构造方法
public ObjectInputStream(InputStream in) throws IOException {}
构造一个ObjectInputStream，需要传入一个InputStream。
方法列举
readInt
public int readInt() throws IOException {}
读取一个int值。每次读4个字节。
readDouble
public double readDouble() throws IOException {}
读取一个double值。每次读8个字节。
readChar
public char readChar() throws IOException {}
读取一个char值。每次读2个字节。
readBoolean
public boolean readBoolean() throws IOException {}
读取一个boolean值。每次读1个字节。
readUTF
public String readUTF() throws IOException {}
读取一个字符串（String）。
readObject
public final Object readObject() throws IOException, ClassNotFoundException {}
读取一个对象。
使用示例
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
public class Test {
public static void main(String[] args) {
String path = "???.dat"; // 数据文件的路径 【一般以.dat结尾】
ObjectInputStream ois = null;
try {
ois = new ObjectInputStream(new FileInputStream(path));
System.out.println(ois.readInt()); // 读入一个int值 【123】
System.out.println(ois.readDouble()); // 读入一个double值 【3.14】
System.out.println(ois.readChar()); // 读入一个char值 【a】
System.out.println(ois.readChar()); // 读入一个char值 【a】
System.out.println(ois.readBoolean()); // 读入一个boolean值 【false】
System.out.println(ois.readUTF()); // 读入一个字符串 【这是一个字符串】
// 读取以char的序列形式写入的字符串
try {
for (;;) {
char c = ois.readChar();
System.out.println(c);
}
} catch (EOFException e) { // 没有字符可以再继续取出了 【End Of File Exception】当输入过程中意外到达文件或流的末尾时，抛出此异常。
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != ois) {
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
序列化和反序列化示例【对象】
⑴【要被序列化的自定义类型】
import java.io.Serializable;
/**
* 要被序列化的对象类
*/
public class Person implements Serializable {
private static final long serialVersionUID = 1L; // 序列号不可以省略！
private String name; // 姓名
private int age; // 年龄
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return name + ":" + age;
}
}
⑵ 【实现序列化的类】
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;
public class PersonObjectOutputStream {
public static void main(String[] args) {
String path = "C:\\Users\\Administrator\\Desktop\\aa.dat"; // 数据文件路径 【一般以.dat结尾】
ObjectOutputStream oos = null;
try {
oos = new ObjectOutputStream(new FileOutputStream(path));
Person person = new Person("张三", 14);
oos.writeObject(person); // 添加单个对象
List<Person> persons = new ArrayList<Person>();
persons.add(new Person("lisi",12));
persons.add(new Person("wnagwu",16));
persons.add(new Person("zhaoliu",14));
persons.add(new Person("tianqi",21));
oos.writeObject(persons); // 添加一个元素为对象的集合
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != oos) {
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
⑶ 【实现反序列化的类】
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;
import java.util.Iterator;
public class PersonObjectInputStream {
public static void main(String[] args) {
String path = "C:\\Users\\Administrator\\Desktop\\aa.dat"; // 数据文件路径 【一般以.dat结尾】
ObjectInputStream ois = null;
try {
ois = new ObjectInputStream(new FileInputStream(path));
/*
* 反序列化 【读取时的顺序要和写入时的顺序一一对应】
*/
Person person = (Person) ois.readObject(); // 读取单个对象
System.out.println(person);
ArrayList<Person> persons = (ArrayList<Person>) ois.readObject(); // 读取集合对象
Iterator<Person> iterator = persons.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
if (null != ois) {
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
⑷ 【注意事项】
① 要被序列化的类型需要实现Serializable接口，并添加序列号【serialVersionUID】。
如果没有实现Serializable接口：
序列化时会报错：java.io.NotSerializableException: 全类名
反序列化时会报错：java.io.InvalidClassException: 全类名; class invalid for deserialization
如果没有序列号，反序列化时会报错：java.io.InvalidClassException: 全类名; local class incompatible: stream classdesc serialVersionUID = ???, local class serialVersionUID = ???
② 实现反序列化的类，读取对象的顺序，要和实现序列化的类，写入对象的顺序一致。即读写顺序要一致。
③ 修改了序列化类型的属性，需要重新输出对象数据文件。否则再次读取对象时，对象的属性变为对应数据类型的默认值。例如int类型属性值变为0、String类型属性值变为null等。
18、数据流
功能
数据流提供了一系列的读写基本数据类型和String类型的方法。但它没有读写其他对象类型的方法。
分类
DataOutputStream
DataInputStream
层级关系
DataOutput【接口】
DataOutputStream【实现类】
ObjectOutput【子接口】
ObjectOutputStream【实现类】
DataInput【接口】
DataInputStream【实现类】
ObjectInput【子接口】
ObjectInputStream【实现类】
19、DataOutputStream【数据流类之一】
构造方法
public DataOutputStream(OutputStream out) {}
构造一个DataOutputStream，需要传入一个OutputStream。
方法列举
writeInt
public final void writeInt(int v) throws IOException {}
写入一个int值。占4个字节。
writeDouble
public final void writeDouble(double v) throws IOException {}
写入一个double值。占8个字节。
writeChar
public final void writeChar(int v) throws IOException {}
写入一个char值。占2个字节。
writeBoolean
public final void writeBoolean(boolean v) throws IOException {}
写入一个boolean值。占1个字节。
writeUTF
public final void writeUTF(String str) throws IOException {}
写入一个字符串（String）。字节占位不一定。
writeChars
public final void writeChars(String s) throws IOException {}
以 char 序列形式写入一个 String。
使用示例
import java.io.DataOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Test {
public static void main(String[] args) {
String path = "???.dat";
DataOutputStream dos = null;
try {
dos = new DataOutputStream(new FileOutputStream(path));
dos.writeInt(123);
dos.writeDouble(23.3);
dos.writeChar('男');
dos.writeChar(65);
dos.writeBoolean(true);
dos.writeUTF("字符串");
dos.writeChars("可以看到这个？");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != dos) {
try {
dos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
19、DataInputStream【数据流类之一】
构造方法
public DataInputStream(InputStream in) {}
构造一个DataInputStream，需要传入一个InputStream。
方法列举
readInt
public final int readInt() throws IOException {}
读取一个int值。每次读4个字节。
readDouble
public final double readDouble() throws IOException {}
读取一个double值。每次读8个字节。
readChar
public final char readChar() throws IOException {}
读取一个char值。每次读2个字节。
readBoolean
public final boolean readBoolean() throws IOException {}
读取一个boolean值。每次读1个字节。
readUTF
public final String readUTF() throws IOException {}
读取一个字符串（String）。
注意读写顺序的顺序必须一致。
使用示例
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Test {
public static void main(String[] args) {
String path = "src\\a.dat";
DataInputStream dis = null;
try {
dis = new DataInputStream(new FileInputStream(path));
/*
* 注意读写顺序要一致！
*/
System.out.println(dis.readInt()); // 123
System.out.println(dis.readDouble()); // 23.3
System.out.println(dis.readChar()); // 男
System.out.println(dis.readChar()); // A
System.out.println(dis.readBoolean()); // true
System.out.println(dis.readUTF()); // 字符串
try {
for (;;) {
char c = dis.readChar();
System.out.println(c);
}
} catch (EOFException e) {
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != dis) {
try {
dis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
20、打印流
功能
打印流都提供了一系列的对基本数据类型和引用数据类型的打印方法。它们只有输出没有输入。
分类
PrintStream 继承自 FilterOutputStream
PrintWriter 继承自 Writer
方法
public void print(Object obj) {}
不换行打印
println
public void println() {}
换行（通过写入行分隔符字符串终止当前行）
public void println(Object x) {}
换行打印
printf
public PrintStream printf(String format, Object … args) {}
public PrintWriter printf(String format, Object … args) {}
格式化输出
format
public PrintStream format(String format, Object … args) {}
public PrintWriter format(String format, Object … args) {}
使用指定格式字符串和参数将格式化字符串写入此输出流中。
特点
⑴ 打印流在调用打印方法时，不会抛出异常，因为底层代码已经处理过了（try-catch过了）。
⑵ 创建打印流对象时，可以指定输出设备的编码。
⑶ 打印流可以实现自动刷新，必须调用println或printf或format方法，同时需要调用特定的构造方法。
21、PrintStream【打印流类之一】
构造方法
⑴public PrintStream(String fileName) throws FileNotFoundException {}
构造一个PrintStream对象，该对象指向一个路径字符串对应的具体文件。
⑵public PrintStream(File file) throws FileNotFoundException {}
构造一个PrintStream对象，该对象指向一个File对象对应的具体文件。
⑶ public PrintStream(OutputStream out) {}
构造一个PrintStream对象，需要传入一个OutputStream。
⑷public PrintStream(OutputStream out, boolean autoFlush) {}
构造一个PrintStream对象，需要传入一个OutputStream。可以指定是否自动刷新【第二个参数：true为自动刷新，false为不需要自动刷新】。
⑸public PrintStream(OutputStream out, boolean autoFlush, String encoding) throws UnsupportedEncodingException {}
构造一个PrintStream对象，需要传入一个OutputStream。可以指定是否自动刷新【第二个参数：true为自动刷新，false为不需要自动刷新】。还可以指定字符编码【第三个参数】，若指定了不支持的字符编码，会报错：java.io.UnsupportedEncodingException。
使用示例
将文本输出到一个文本文件中
import java.io.FileNotFoundException;
import java.io.PrintStream;
public class Test {
public static void main(String[] args) {
PrintStream ps = null;
try {
ps = new PrintStream("???.txt");
ps.print("这是一句话（不会换行）");
ps.print("\r\n"); // Wimdows换行
ps.println(123);
ps.printf("字符：%c，整数：%d，浮点数：%.2f，字符串：%s", '哈', 26, 3.14, "这就是字符串！");
ps.println();
ps.format("字符：%c，整数：%d，浮点数：%.2f，字符串：%s", '哈', 26, 3.14, "这就是字符串！");
} catch (FileNotFoundException e) {
e.printStackTrace();
} finally {
if (null != ps) {
ps.close();
}
}
}
}
追加输出到文本文件中
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
public class Test {
public static void main(String[] args) {
PrintStream ps = null;
try {
ps = new PrintStream(new FileOutputStream("C:\\Users\\Administrator\\Desktop\\testsss.txt", true)); // 调用FileOutputStream的特有构造方法
ps.println("我是被重复输出的字符串");
} catch (FileNotFoundException e) {
e.printStackTrace();
} finally {
if (null != ps) {
ps.close();
}
}
}
}
原理：调用FileOutputStream的两个参数的构造方法，并将第二个参数设置为true。这时输出就变为了追加输出。再将其作为参数传入PrintStream的构造方法。
输出到指定字符编码的文本文件中
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.io.UnsupportedEncodingException;
public class Test {
public static void main(String[] args) {
PrintStream ps = null;
try {
ps = new PrintStream(new FileOutputStream("???.txt"), true, "utf-8"); // 输出到编码为utf-8的文本文件中
ps.println("测试字符串");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} finally {
if (null != ps) {
ps.close();
}
}
}
}
22、PrintWriter【打印流类之一】
构造方法
⑴public PrintWriter(String fileName) throws FileNotFoundException {}
构造一个PrintWriter对象，该对象指向一个路径字符串对应的具体文件。
⑵public PrintWriter(File file) throws FileNotFoundException {}
构造一个PrintWriter对象，该对象指向一个File对象对应的具体文件。
⑶ public PrintWriter (Writer out) {}
构造一个PrintWriter对象，需要传入一个Writer。
public PrintWriter(OutputStream out) {}
构造一个PrintWriter对象，需要传入一个OutputStream 。
⑷public PrintWriter(Writer out, boolean autoFlush) {}
构造一个PrintWriter对象，需要传入一个Writer。可以指定是否自动刷新【第二个参数：true为自动刷新，false为不需要自动刷新】。
public PrintWriter(OutputStream out, boolean autoFlush) {}
构造一个PrintWriter对象，需要传入一个OutputStream。可以指定是否自动刷新【第二个参数：true为自动刷新，false为不需要自动刷新】。
⑸public PrintWriter(File file, String csn) throws FileNotFoundException, UnsupportedEncodingException {}
构造一个PrintWriter对象，该对象指向一个File对象对应的具体文件。还可以指定字符编码【第二个参数】，若指定了不支持的字符编码，会报错：java.io.UnsupportedEncodingException。
注意：当用PrintWriter写文件时，必须使用flush或close方法，否则数据将不能保证被写入到物理设备（如磁盘驱动器）中。
使用示例
输出到指定字符编码的文本文件中
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
public class Test {
public static void main(String[] args) {
PrintWriter pw = null;
try {
pw = new PrintWriter("???.txt", "utf-8"); // 输出到编码为utf-8的文本文件中
pw.println("测试文字");
pw.flush(); // 刷新
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} finally {
pw.close(); // 关闭流
}
}
}
23、标准输入输出设备
具体分类
System.in
public final static InputStream in = null;
标准输入设备。其类型为InputStream。默认输入设备是键盘。
System.out
public final static PrintStream out = null;
标准输出设备。其类型为PrintStream。默认输出设备是显示器。特点是：黑色字输出。
System.err
public final static PrintStream err = null;
标准错误输出。其类型为PrintStream。默认输出设备是显示器。特点是：红色字输出。
重定向
标准输入输出设备可以重定向，需要通过调用方法对默认设备进行改变。
重定向输入设备
public static void setIn(InputStream in) {}
通过System.setIn(InputStream in); 来调用。
重定向输出设备
public static void setOut(PrintStream out) {}
通过System.setOut(PrintStream out); 来调用。
重定向错误输出设备
public static void setErr(PrintStream err) {}
通过System.setErr(PrintStream err); 来调用。
使用示例
输出错误的信息
System.err.println("错误的文字信息!"); // 红色字体（Eclipse中可以显示输出文字的颜色）
将从键盘输入的内容保存到文本文件中
import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.util.Scanner;
public class Test {
public static void main(String[] args) throws FileNotFoundException {
Scanner input = new Scanner(System.in);
System.out.print("请输入：");
String str = input.nextLine(); // 获取从键盘输入的内容
System.setOut(new PrintStream("a.txt")); // 重定向标准输出流到文件
// 将输入的内容输出到文件中 【这时System.out代表的标准输出就是a.txt】
System.out.println(str);
input.close();
}
}
将从文本文件中读取到的内容输出到控制台中
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.NoSuchElementException;
import java.util.Scanner;
public class Test {
public static void main(String[] args) throws FileNotFoundException {
System.setIn(new FileInputStream("Test.java")); // 重定向标准输入流到文件
Scanner input = new Scanner(System.in); // 这时System.in代表的标准输入就是Test.java
String str; // 获取到的文件的每一行内容
try {
for (;;) { // 循环获取文本内容
str = input.nextLine();
System.out.println(str);
}
} catch (NoSuchElementException e) { // 到达文本末端，抛出此异常
} finally {
input.close();
}
}
}
带提示的循环输入，将用户输入的内容保存到文件中，输入指定字符结束
import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.util.Scanner;
public class Test {
public static void main(String[] args) throws FileNotFoundException{
Scanner input = new Scanner(System.in);
PrintStream showTip = System.out; // 保存默认的标准输出流【显示器】
PrintStream out = new PrintStream("a.txt"); // 创建PrintStream，指向a.txt
String str; // 获取用户输入的内容
for (;;) {
System.setOut(showTip); // 每次循环需要重置标准输出流
System.out.print("请输入(输入Q退出)：");
str = input.nextLine();
if ("Q".equals(str)) { // 输入大写的Q字符退出
input.close();
break;
}
System.setOut(out); // 将标准输出流重定向到PrintStream对象
System.out.println(str);
}
}
}
24、转换流
功能
用于将字节流转换为字符流。目的是提高效率。
应用场景
当读写的数据都是字符时，且当前接收到的是字节流。这时就可以用转换流。因为用字节流传输字符的效率，低于用字符流传输字符的效率。
分类
InputStreamReader
OutputStreamWriter
25、InputStreamReader（Reader的子类）【转换流之一】
构造方法
⑴ public InputStreamReader(InputStream in) {}
构造一个InputStreamReader对象，需要传入一个InputStream。其采用默认字符编码。
⑵ public InputStreamReader(InputStream in, String charsetName) throws UnsupportedEncodingException {}
构造一个InputStreamReader对象，需要传入一个InputStream。其采用指定的字符编码【第二个参数】。
用GBK解码从键盘输入的内容，并显示到控制台中
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
public class Test {
public static void main(String[] args) {
InputStreamReader isr = null;
BufferedReader br = null;
try {
isr = new InputStreamReader(System.in, "GBK");
br = new BufferedReader(isr);
System.out.println("请输入：");
System.out.println(br.readLine());
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != br) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
26、OutputStreamWriter（Writer的子类）【转换流之一】
构造方法
⑴ public OutputStreamWriter(OutputStream out) {}
构造一个OutputStreamWriter对象，需要传入一个OutputStream。其采用默认字符编码。
⑵public OutputStreamWriter(OutputStream out, String charsetName) throws UnsupportedEncodingException {}
构造一个OutputStreamWriter对象，需要传入一个OutputStream。其采用指定的字符编码【第二个参数】。
将从键盘输入的内容，用utf-8编码输出到文本文件中
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
OutputStreamWriter osw = null;
Scanner input = new Scanner(System.in);
try {
osw = new OutputStreamWriter(new FileOutputStream("???.txt"), "utf-8");
System.out.println("请输入：");
String str = input.nextLine();
osw.write(str);
input.close();
osw.flush();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != osw) {
try {
osw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
27、随机访问流
特点
只有一个类：RandomAccessFile。既可以读取又可以写入。其可以自由移动指针，来随机访问文件的读取和写入。注意读写的顺序要一致。
构造方法
⑴ public RandomAccessFile(String name, String mode) throws FileNotFoundException {}
构造一个RandomAccessFile对象，其指向一个路径字符串对应的具体文件。可以指定打开文件的访问模式【第二个参数】。
mode值 含义
r 只读
rw 可读可写
⑵ public RandomAccessFile(File file, String mode) throws FileNotFoundException {}
构造一个RandomAccessFile对象，其指向一个File对象对应的具体文件。可以指定打开文件的访问模式【第二个参数】。
方法列举
writeInt
public final void writeInt(int v) throws IOException {}
写入一个int值。占4个字节。
writeDouble
public final void writeDouble(double v) throws IOException {}
写入一个double值。占8个字节。
writeChar
public final void writeChar(int v) throws IOException {}
写入一个char值。占2个字节。
writeBoolean
public final void writeBoolean(boolean v) throws IOException {}
写入一个boolean值。占1个字节。
writeUTF
public final void writeUTF(String str) throws IOException {}
写入一个字符串（String）。字节占位不一定。
writeChars
public final void writeChars(String s) throws IOException {}
以 char 序列形式写入一个 String。
readInt
public final int readInt() throws IOException {}
读取一个int值。每次读4个字节。
readDouble
public final double readDouble() throws IOException {}
读取一个double值。每次读8个字节。
readChar
public final char readChar() throws IOException {}
读取一个char值。每次读2个字节。
readBoolean
public final boolean readBoolean() throws IOException {}
读取一个boolean值。每次读1个字节。
readUTF
public final String readUTF() throws IOException {}
读取一个字符串（String）。
getFilePointer
public native long getFilePointer() throws IOException;
获取指针位置。
seek
public native void seek(long pos) throws IOException;
指定指针位置（从0开始）。
使用示例
import java.io.EOFException;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
public class Test {
public static void main(String[] args) {
RandomAccessFile raf = null;
try {
raf = new RandomAccessFile("a.txt", "rw");
raf.writeInt(14);
raf.writeDouble(3.6);
raf.writeChar('好');
raf.writeChar(66);
raf.writeBoolean(true);
raf.writeUTF("字符串");
raf.writeChars("看到我了？");
raf.seek(0); // 输出完所有的内容后，其指针位置在末位，这时就需要将指针移动到首位【0处】
System.out.println(raf.getFilePointer()); // 获取指针位置
/*
* 注意读写顺序要一致
*/
System.out.println(raf.readInt());
System.out.println(raf.getFilePointer());
System.out.println(raf.readDouble());
System.out.println(raf.getFilePointer());
System.out.println(raf.readChar());
System.out.println(raf.getFilePointer());
System.out.println(raf.readChar());
System.out.println(raf.getFilePointer());
System.out.println(raf.readBoolean());
System.out.println(raf.getFilePointer());
System.out.println(raf.readUTF());
try {
for (;;) {
System.out.println(raf.getFilePointer());
System.out.println(raf.readChar());
}
} catch (EOFException e) { // 到达文件末位时，会抛出此异常【End Of File Exception】
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != raf) {
try {
raf.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
28、Properties类【Map的实现类】
概念
其表示了一个持久化的属性集。它是Hashtable的子类，位于java.util包下。本身是一个集合类。
Map
Hashtable
Properties
功能
主要用于读写配置信息文件。
配置信息文件
里面存储的是键值对格式。
其格式：
⑴ 后缀名为properties
⑵ 必须是键值对形式
key=value
key=value
⑶ key和value的默认类型都是String类型。
构造方法
public Properties() {}
构造一个Properties对象。
方法列举
load
public synchronized void load(InputStream inStream) throws IOException {}
将文件中的数据加载到properties中（内存中）。
list
public void list(PrintStream out) {}
将Properties的数据列出到指定的输出流（输出设备）。
getProperty
public String getProperty(String key) {}
根据键获取值，返回值类型为String。
setProperty
public synchronized Object setProperty(String key, String value) {}
设置键值对。
注意：因为Properties本质上是一个集合，所以设置同一个键，新设置的值会覆盖旧设置的值。
store
public void store(OutputStream out, String comments) throws IOException {}
将Properties的数据存储到配置文件中。第二个参数为属性列表的描述（可以为null）。
注意：
⑴该方法使用 ISO 8859-1 字符编码写入该流。
⑵属性键或值中小于 \u0020 的字符和大于 \u007E 的字符针对适当的十六进制值 xxxx 以 \uxxxx 的形式写入。【汉字可能是这种形式】
⑶ 因为Properties本质上是一个集合，所以输出的文件的排序顺序是按照键在哈希表中的顺序进行排序的。
使用示例
【info.properties配置文件】
user=root
pwd=1234
【方法示例代码】
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;
public class Test {
public static void main(String[] args) throws IOException {
Properties properties = new Properties();
properties.load(new FileInputStream("info.properties")); // 加载配置文件
// 获取值
String user = properties.getProperty("user");
String pwd = properties.getProperty("pwd");
System.out.println(user + ":" + pwd);
properties.list(System.out); // 将配置文件中的数据输出到默认的标准输出【控制台】中
properties.setProperty("new", "john"); // 设置键值对
properties.setProperty("new", "tom"); // 设置键值对【会覆盖旧值】
properties.store(new FileOutputStream("new.properties"), "hello java!"); // 保存到配置文件中
}
}
【new.properties配置文件（输出的配置文件）】
/#hello java!
这里是保存时的时间
user=root
new=tom
pwd=1234
相关文章
- 暂无相关文章
用户点评