1. File 类
1.1 File 类概述和构造方法
File:它是文件和目录路径名的抽象表示
- 文件和目录是可以通过 File 封装成对象的
- 对于 File 而言,其封装的并不是一个真正存在的文件,仅仅是一个路径名而已。它可以是存在的,也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的。
构造方法如下:
方法名 | 说明 |
---|---|
File(String pathname) | 通过将给定的路径名字符串转换为抽象路径名来创建新的 File 实例 |
File(String parent, String child) | 从父路径名字符串和子路径名字符串创建新的 File 实例 |
File(File parent, String child) | 从父抽象路径名和子路径名字符串创建新的 File 实例 |
实例如下:
// File(String pathname)
File file1 = new File("D:\\file_test\\file.txt");
// File(String parent, String child)
File file2 = new File("D:\\file_test", "file.txt");
// File(File parent, String child)
File file3 = new File("D:\\file_test");
File file4 = new File(file3, "file.txt");
1.2 File 类创建功能
方法名 | 说明 |
---|---|
public boolean createNewFile() | 当具有该名称的文件不存在时,创建一个由该抽象路径名命名的新空文件 |
public boolean mkdir() | 创建由此抽象路径名命名的目录 |
public boolean mkdirs() | 创建由此抽象路径名命名的目录,包括任何必需但不存在的父目录 |
实例如下:
// 需求 1:在 D:\file_test 目录下创建文件 file.txt
File file1 = new File("D:\\file_test\\file.txt");
System.out.println(file1.createNewFile());
// 需求 2:在 D:\file_test 目录下创建目录 demo1
File file2 = new File("D:\\file_test\\demo1");
System.out.println(file2.mkdir());
// 需求 3:在 D:\file_test 目录下创建多级目录 demo2\test
File file3 = new File("D:\\file_test\\demo2\\test");
System.out.println(file3.mkdirs());
1.3 File 类删除功能
方法名 | 说明 |
---|---|
public boolean delete() | 删除由此抽象路径名表示的文件或目录 |
绝对路径和相对路径的区别
- 绝对路径:完整的路径名,不需要任何其他信息就可以定位它所表示的文件。例如:E:\itcast\java.txt
- 相对路径:必须使用取自其他路径名的信息进行解释。例如:myFile\java.txt
删除目录时的注意事项:
- 如果一个目录中有内容(目录,文件),不能直接删除。应该先删除目录中的内容,最后才能删除目录。
实例如下:
// 需求 1:在当前模块目录下创建 file1.txt 文件,然后删除该文件
File file1 = new File("file1.txt");
file1.createNewFile();
System.out.println(file1.delete());
// 需求 2:在当前模块目录下创建 demo 目录,然后删除该目录
File file2 = new File("demo");
file2.mkdir();
System.out.println(file2.delete());
// 需求 3:在当前模块目录下创建 demo\file1.txt 文件,然后删除该目录及文件
File file3 = new File("demo");
file3.mkdirs();
File file4 = new File(file3, "file1.txt");
file4.createNewFile();
System.out.println(file4.delete());
System.out.println(file3.delete());
1.4 File 类判断和获取功能
方法名 | 说明 |
---|---|
public boolean isDirectory() | 测试此抽象路径名表示的 File 是否为目录 |
public boolean isFile() | 测试此抽象路径名表示的 File 是否为文件 |
public boolean exists() | 测试此抽象路径名表示的 File 是否存在 |
public String getAbsolutePath() | 返回此抽象路径名的绝对路径名字符串 |
public String getPath() | 将此抽象路径名转换为路径名字符串 |
public String getName() | 返回由此抽象路径名表示的文件或目录的名称 |
public String[] list() | 返回此抽象路径名表示的目录中的文件和目录的名称字符串数组 |
public File[] listFiles() | 返回此抽象路径名表示的目录中的文件和目录的File对象数组 |
实例如下:
File file1 = new File("file.txt");
file1.createNewFile();
System.out.println(file1.isDirectory()); // flase
System.out.println(file1.isFile()); // true
System.out.println(file1.exists()); // true
System.out.println(file1.getAbsolutePath()); // D:\idea_workspace\io\filetest\file.txt
System.out.println(file1.getPath()); // file.txt
System.out.println(file1.getName()); // file.txt
System.out.println("----------");
File file2 = new File("src");
String[] list = file2.list();
Arrays.stream(list).forEach(System.out::println); // 打印 src 目录下的目录名和文件名
System.out.println("----------");
File[] files = file2.listFiles();
Arrays.stream(files)
.filter(file -> file.isFile())
.forEach(file -> System.out.println(file.getName())); // 只打印 src 目录下的文件名
1.5 案例:遍历目录
需求
给定一个路径(C:\Users\admin\Desktop\毕业设计),请通过递归完成遍历该目录下的所有内容,并把所有文件的文件名输出在控制台。
思路
- 根据给定的路径创建一个 File 对象
- 定义一个方法,用于获取给定目录下的所有内容,参数为第 1 步创建的 File 对象
- 获取给定的 File 目录下所有的文件或者目录的 File 数组
- 遍历该 File 数组,得到每一个 File 对象
- 判断该 File 对象是否是目录
- 是:递归调用
- 不是:获取文件名输出在控制台
- 调用方法
代码实现
public class FileTest5 {
public static void printFileName(File file) {
Arrays.stream(file.listFiles()).forEach(file1 -> {
if (file1.isFile()) {
System.out.println(file1.getName());
} else {
printFileName(file1);
}
});
}
public static void main(String[] args) {
File file = new File("C:\\Users\\admin\\Desktop\\毕业设计");
printFileName(file);
}
}
2. 字节流
2.1 IO 流概述和分类
IO 流概述
- IO:输入/输出(Input/Output)
- 流:是一种抽象概念,是对数据传输的总称。也就是说数据在设备间的传输称为流,流的本质是数据传输。
- IO 流就是用来处理设备间数据传输问题的,常见的应用:文件复制;文件上传;文件下载。
IO 流分类
按照数据的流向分类:
- 输入流:从硬盘读数据到内存
- 输出流:从内存写数据到硬盘
按照数据类型分类:
- 字节流
- 字符流
那么这两种流都在什么情况下使用呢?
- 如果数据通过 Window 自带的记事本软件打开,我们还可以读懂里面的内容,就使用字符流
- 否则使用字节流。如果你不知道该使用哪种类型的流,就使用字节流
2.2 字节流写数据
字节流抽象基类
- InputStream:这个抽象类是表示字节输入流的所有类的超类
- OutputStream:这个抽象类是表示字节输出流的所有类的超类
子类名特点:子类名称都是以其父类名作为子类名的后缀
字节流输出子类
-
FileOutputStream:文件输出流用于将数据写入 File
构造方法:FileOutputStream(String name):创建文件输出流以指定的名称写入文件
需求
向 file1.txt 文件中写入 97
使用字节输出流写数据的步骤:
- 创建字节输出流对象(调用系统功能创建了文件,创建字节输出流对象,让字节输出流对象指向文件)
- 调用字节输出流对象的写数据方法
- 释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源)
实例如下:
/* 创建字节输出流对象,完成以下三件事:
1. 调用系统功能创建文件
2. 创建字节输出流对象
3. 将字节输出流对象指向创建好的文件
*/
FileOutputStream ops = new FileOutputStream("file1.txt");
// 向文件写入 97
ops.write(97);
// 最后释放资源
ops.close();
2.3 字节流写数据的 3 种方式
方法名 | 说明 |
---|---|
void write(int b) | 将指定的字节写入此文件输出流一次写一个字节数据 |
void write(byte[] b) | 将 b.length 字节从指定的字节数组写入此文件输出流一次写一个字节数组数据 |
void write(byte[] b, int off, int len) | 将 len 字节从指定的字节数组开始,从偏移量 off 开始写入此文件输出流一次写一个字节数组的部分数据 |
2.4 字节流写数据的两个小问题
-
字节流写数据如何实现换行呢?
写完数据后,加换行符
windows:\r\n
linux:\n
mac:\r
实例如下:
FileOutputStream ops = new FileOutputStream("file.txt"); for (int i = 0; i < 5; i++) { // 写入 5 行 hello,并实现换行 ops.write("hello\r\n".getBytes()); } ops.close();
-
字节流写数据如何实现追加写入呢?
- public FileOutputStream(String name,boolean append)
- 创建文件输出流以指定的名称写入文件。如果第二个参数为 true ,则字节将写入文件的末尾而不是开头
实例如下:
FileOutputStream ops = new FileOutputStream("file.txt", true); for (int i = 0; i < 5; i++) { // 追加 5 行 world,并实现换行 ops.write("world\r\n".getBytes()); } ops.close();
2.5 字节流写数据加异常处理
之前采取的都是抛出异常的方式,接下来演示一下捕获异常的处理方式:
FileOutputStream ops = null;
try {
ops = new FileOutputStream("file.txt");
ops.write("hello".getBytes());
} catch (IOException e) {
e.printStackTrace();
} finally {
if (ops != null) {
try {
ops.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
从 Java 7 开始支持 try-with-resources 语句,称为 ARM 块(Automatic Resource Management) ,自动资源管理。也就是说,数据流会在 try 执行完毕后自动被关闭。
上面的程序可以简化如下:
try(FileOutputStream osp = new FileOutputStream("file.txt")) {
osp.write("hello".getBytes());
} catch (IOException e) {
e.printStackTrace();
}
2.6 字节流读数据(一次读一个字节数据)
字节输入流
- FileInputStream:从文件系统中的文件获取输入字节
字节输入流子类
- FileInputStream(String name):通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的路径名 name 命名
一次读一个字节数组的方法
- public int read():从输入流读取数据的下一个字节。
- 返回的是读取到的数据,如果没有字节可用,因为已经到达流的末尾,则返回值 -1。
需求
把文件 file.txt 中的内容读取出来在控制台输出
使用字节输入流读数据的步骤:
- 创建字节输入流对象
- 调用字节输入流对象的读数据方法
- 释放资源
实例如下:
FileInputStream ips = new FileInputStream("file.txt");
int by;
while ((by = ips.read()) != -1) {
System.out.print((char) by);
}
ips.close();
2.7 案例:复制文本文件
需求
把 “file.txt” 复制到模块目录下的 “newfile.txt”
思路
复制文本文件,其实就把文本文件的内容从一个文件中读取出来(数据源),然后写入到另一个文件中(目的地)
代码实现
FileOutputStream ops = new FileOutputStream("newfile.txt");
FileInputStream ips = new FileInputStream("file.txt");
int by;
while ((by = ips.read()) != -1) {
ops.write(by);
}
ips.close();
ops.close();
2.8 字节流读数据(一次读一个字节数组数据)
一次读一个字节数组的方法:
- public int read(byte[] b):从输入流读取最多 b.length 个字节的数据
- 返回的是读入缓冲区的总字节数,也就是实际的读取字节个数
将上面的案例改造为一次读一个字节数组数据,实例如下:
FileOutputStream ops = new FileOutputStream("newfile.txt");
FileInputStream ips = new FileInputStream("file.txt");
byte[] bys = new byte[1024];
int i;
while ((i = ips.read(bys)) != -1) {
// 注意:写入的为实际读取的长度,而不是整个数组的长度
ops.write(bys, 0, i);
}
ips.close();
ops.close();
2.9 字节缓冲流
读取数据量大的文件时,读取的速度会很慢,很影响我们程序的效率,Java 中提高了一套字节缓冲流,它可以提高 IO 流的读写速度。
创建 BufferedInputStream 和 BufferedOutputStream 两个缓冲流对象,这两个流都对应了一个大小为 8192 的字节数组,当调用 read() 或者 write() 方法读写数据时,首先将读写的数据存入定义好的字节流数组,然后将字节数组的数据一次性的读写到文件中。
从内存写数据到文件,相当于将一缸水倒入另外一个缸中:
- FileOutputStream 的 write 方法:相当于一滴一滴地把水转移过去。
- BufferOutputStream 的 write 方法:相当于一瓢一瓢先把水放入的桶中,再将桶中的水倒入缸中,性能提高了。
字节缓冲流:
- BufferOutputStream:该类实现缓冲输出流。 通过设置这样的输出流,应用程序可以向底层输出流写入字节,而不必为写入的每个字节导致底层系统的调用
- BufferedInputStream:创建 BufferedInputStream 将创建一个内部缓冲区数组。 当从流中读取或跳过字节时,内部缓冲区将根据需要从所包含的输入流中重新填充,一次很多字节
构造方法:
- 字节缓冲输出流:BufferedOutputStream(OutputStream out)
- 字节缓冲输入流:BufferedInputStream(InputStream in)
为什么构造方法需要的是字节流,而不是具体的文件或者路径呢?
- 字节缓冲流仅仅提供缓冲区,而真正的读写数据还得依靠基本的字节流对象进行操作
2.10 案例:复制视频
需求
把 “C:\Users\admin\Downloads\Video\老大.mp4” 复制到模块目录下的 “video.mp4”,分别采用基本的字节流和字节缓冲流实现,并测试它们的耗时。
代码实现
public class BufferedInputStreamTest {
public static void main(String[] args) {
long start = System.currentTimeMillis();
String ips = "C:\\Users\\admin\\Downloads\\Video\\老大.mp4";
String ops = "video.mp4";
// method1(ips, ops); // 12296
// method2(ips, ops); // 19
// method3(ips, ops); // 6277
// method4(ips, ops); // 13
long end = System.currentTimeMillis();
System.out.println(end - start);
}
// 普通字节流,一次读一个字节数据
public static void method1(String ips, String ops) {
try (InputStream inputStream = new FileInputStream(ips);
OutputStream outputStream = new FileOutputStream(ops)) {
int by;
while ((by = inputStream.read()) != -1) {
outputStream.write(by);
outputStream.flush();
}
} catch (IOException e) {
e.printStackTrace();
}
}
// 普通字节流,一次读一个字节数组数据
public static void method2(String ips, String ops) {
try (InputStream inputStream = new FileInputStream(ips);
OutputStream outputStream = new FileOutputStream(ops)) {
byte[] bytes = new byte[1024];
int i;
while ((i = inputStream.read(bytes)) != -1) {
outputStream.write(bytes, 0, i);
outputStream.flush();
}
} catch (IOException e) {
e.printStackTrace();
}
}
// 字节缓冲流,一次读一个字节数据
public static void method3(String ips, String ops) {
try (BufferedInputStream inputStream = new BufferedInputStream(new FileInputStream(ips));
BufferedOutputStream outputStream = new BufferedOutputStream(new FileOutputStream(ops))) {
int by;
while ((by = inputStream.read()) != -1) {
outputStream.write(by);
outputStream.flush();
}
} catch (IOException e) {
e.printStackTrace();
}
}
// 字节缓冲流,一次读一个字节数组数据
public static void method4(String ips, String ops) {
try (BufferedInputStream inputStream = new BufferedInputStream(new FileInputStream(ips));
BufferedOutputStream outputStream = new BufferedOutputStream(new FileOutputStream(ops))) {
byte[] bytes = new byte[1024];
int i;
while ((i = inputStream.read(bytes)) != -1) {
outputStream.write(bytes, 0, i);
outputStream.flush();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
分析:从耗时上来看,字节缓冲流提高 IO 流的读写速度。
2.11 案例:复制多级目录
需求
把 “C:\Users\admin\Desktop\毕业设计” 这个文件夹复制到 “D:” 下
思路
- 创建数据源 File 对象,路径是 C:\Users\admin\Desktop\毕业设计
- 创建目的地 File 对象,路径是 D:\
- 写方法实现文件夹的复制,参数为数据源 File 对象和目的地 File 对象,判断数据源 File 是否是文件
- 是文件:用字节流直接复制
- 不是文件:
- 在目的地下创建该目录
- 遍历获取该目录下的所有文件的 File 数组,得到每一个 File 对象
- 继续递归
代码实现
public class CopyFolder {
public static void main(String[] args) {
// 源文件
File sourceFile = new File("C:\\Users\\admin\\Desktop\\毕业设计");
// 目标文件
File targetFile = new File("D:\\");
// 复制多级目录
copyFolder(sourceFile, targetFile);
}
private static void copyFolder(File sourceFile, File targetFile) {
// 是文件,用字节流直接复制
if (sourceFile.isFile()) {
try (BufferedInputStream inputStream = new BufferedInputStream(new FileInputStream(sourceFile));
BufferedOutputStream outputStream = new BufferedOutputStream(new FileOutputStream(new File(targetFile, sourceFile.getName())))
) {
byte[] bytes = new byte[1024];
int i;
while ((i = inputStream.read(bytes)) != -1) {
outputStream.write(bytes, 0, i);
outputStream.flush();
}
} catch (IOException e) {
e.printStackTrace();
}
} else {
// 不是文件,新建目录
File newFolder = new File(targetFile, sourceFile.getName());
if (!newFolder.exists()) {
newFolder.mkdir();
}
// 继续递归
Arrays.stream(sourceFile.listFiles()).forEach(file -> copyFolder(file, newFolder));
}
}
}
3. 字符流
3.1 为什么会出现字符流
由于字节流操作中文不是特别的方便,所以 Java 就提供字符流。
- 字符流 = 字节流 + 编码表
用字节流复制文本文件时,文本文件也会有中文,但是没有问题,原因是最终底层操作会自动进行字节拼接成中文,如何识别是中文的呢?
- 汉字在存储的时候,无论选择哪种编码存储,第一个字节都是负数。
3.2 编码和解码
- 计算机中储存的信息都是用二进制数表示的;我们在屏幕上看到的英文、汉字等字符是二进制数转换之后的结果。
- 按照某种规则,将字符存储到计算机中,称为编码。反之,将存储在计算机中的二进制数按照某种规则解析显示出来,称为解码 。
- 这里强调一下:按照 A 编码存储,必须按照 A 编码解析,这样才能显示正确的文本符号。否则就会导致乱码现象。
3.3 字符串中的编码解码
编码:
- byte[] getBytes():使用平台的默认字符集将该 String 编码为一系列字节,将结果存储到新的字节数组中
- byte[] getBytes(String charsetName):使用指定的字符集将该 String 编码为一系列字节,将结果存储到新的字节数组中
解码:
- String(byte[] bytes):通过使用平台的默认字符集解码指定的字节数组来构造新的 String
- String(byte[] bytes, String charsetName):通过指定的字符集解码指定的字节数组来构造新的 String
实例如下:
String str = "中国";
byte[] bytes1 = str.getBytes("UTF-8");
byte[] bytes2 = str.getBytes("GBK");
System.out.println("以 UTF-8 方式编码:" + Arrays.toString(bytes1));
System.out.println("以 GBK 方式编码:" + Arrays.toString(bytes2));
//
System.out.println("以 UTF-8 方式解码:" + new String(bytes1, "UTF-8"));
// 以 GBK 方式解码
System.out.println("以 GBK 方式解码:" + new String(bytes2, "GBK"));
运行结果:
以 UTF-8 方式编码:[-28, -72, -83, -27, -101, -67]
以 GBK 方式编码:[-42, -48, -71, -6]
以 UTF-8 方式解码:中国
以 GBK 方式解码:中国
3.4 字符流中的编码解码
字符流抽象基类:
- Reader:字符输入流的抽象类
- Writer:字符输出流的抽象类
字符流中和编码解码问题相关的两个类:
- InputStreamReader:是从字节流到字符流的桥:它读取字节,并使用指定的 charset 将其解码为字符 。它使用的字符集可以由名称指定,也可以被明确指定,或者可以接受平台的默认字符集。
- OutputStreamWriter:是字符的桥梁流以字节流:向其写入的字符编码成使用指定的字节 charset。它使用的字符集可以由名称指定,也可以被明确指定,或者可以接受平台的默认字符集。
实例如下:
OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream("text.txt"), "GBK");
writer.write("中国");
writer.close();
InputStreamReader reader = new InputStreamReader(new FileInputStream("text.txt"), "GBK");
// 一次读取一个字符数据
int ch;
while ((ch = reader.read()) != -1) {
System.out.print((char) ch);
}
// 一次读取一个字符数组数据
// char[] chars = new char[1024];
// int i;
// while ((i = reader.read(chars)) != -1) {
// System.out.print(new String(chars, 0, i));
// }
reader.close();
运行结果:
中国
3.5 字符流写数据的 5 种方式
方法名 | 说明 |
---|---|
void write(int c) | 写一个字符 |
void write(char[] cbuf) | 写入一个字符数组 |
void write(char[] cbuf, int off, int len) | 写入字符数组的一部分 |
void write(String str) | 写一个字符串 |
void write(String str, int off, int len) | 写一个字符串的一部分 |
flush() | 刷新流,还可以继续写数据 |
close() | 关闭流,释放资源,但是在关闭之前会先刷新流。一旦关闭,就不能再写数据 |
3.6 字符流读数据的 2 种方式
方法名 | 说明 |
---|---|
int read() | 一次读一个字符数据 |
int read(char[] cbuf) | 一次读一个字符数组数据 |
3.7 案例:复制文本文件
需求
把 scr 下的 “InputStreamReaderTest1.java” 复制到当前模块目录下的 “Copy.java”
思路
转换流的名字比较长,而我们常见的操作都是按照本地默认编码实现的,所以,为了简化书写,转换流提供了对应的子类:
- FileReader(String fileName):用于读取字符文件的便捷类
- FileWriter(String fileName):用于写入字符文件的便捷类
代码实现
FileReader reader = new FileReader("src\\InputStreamReaderTest1.java");
FileWriter writer = new FileWriter("Copy.java");
char[] chars = new char[1024];
int i;
while ((i = reader.read(chars)) != -1) {
writer.write(chars, 0, i);
writer.flush();
}
reader.close();
writer.close();
3.8 字符缓冲流
字符缓冲流:
- BufferedWriter:将文本写入字符输出流,缓冲字符,以提供单个字符,数组和字符串的高效写入,可以指定缓冲区大小,或者可以接受默认大小。默认值足够大,可用于大多数用途
- BufferedReader:从字符输入流读取文本,缓冲字符,以提供字符,数组和行的高效读取,可以指定缓冲区大小,或者可以使用默认大小。 默认值足够大,可用于大多数用途
构造方法:
- BufferedWriter(Writer out)
- BufferedReader(Reader in)
3.9 字符缓冲流特有功能
BufferedWriter:
- void newLine():写一行行分隔符,行分隔符字符串由系统属性定义
BufferedReader:
- public String readLine() :读一行文字。 结果包含行的内容的字符串,不包括任何行终止字符,如果流的结尾已经到达,则为 null
3.10 案例:复制文本文件(字符缓冲流特有功能改进版)
需求
把 scr 下的 “InputStreamReaderTest1.java” 复制到当前模块目录下的 “Copy.java”
代码实现
BufferedReader reader = new BufferedReader(new FileReader("src\\InputStreamReaderTest1.java"));
BufferedWriter writer = new BufferedWriter(new FileWriter("Copy.java"));
String line;
while ((line = reader.readLine()) != null) {
writer.write(line);
writer.newLine();
writer.flush();
}
reader.close();
writer.close();
4. IO 流总结
5. 对象序列化
5.1 对象序列化流
- 序列化:就是将对象保存到磁盘中,或者在网络中传输对象
- 反序列化:该字节序列还可以从文件中读取回来,重构对象
要实现序列化和反序列化就要使用对象序列化流和对象反序列化流。
对象序列化流:ObjectOutputStream
- 构造方法:
ObjectOutputStream(OutputStream out):创建一个写入指定的 OutputStream 的 ObjectOutputStream - 序列化对象的方法:
void writeObject(Object obj):将指定的对象写入 ObjectOutputStream
注意:
- 一个对象要想被序列化,该对象所属的类必须必须实现 Serializable 接口
- Serializable 是一个标记接口,实现该接口,不需要重写任何方法
对象反序列化流:ObjectInputStream
- 构造方法:
ObjectInputStream(InputStream in):创建从指定的 InputStream 读取的 ObjectInputStream - 反序列化对象的方法:
Object readObject():从 ObjectInputStream 读取一个对象
实例如下:
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("file.txt"));
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("file.txt"));
outputStream.writeObject(new Student("jack", 18));
Object object = inputStream.readObject();
Student student = (Student) object;
System.out.println(student.getName() + " " + student.getAge());
outputStream.close();
inputStream.close();
运行结果:
jack 18
5.2 对象序列化的问题
-
用对象序列化流序列化了一个对象后,假如我们修改了对象所属的类文件,读取数据会不会出问题呢?
会出问题,会抛出 InvalidClassException 异常
-
如果出问题了,如何解决呢?
重新序列化,给对象所属的类加一个 serialVersionUID 属性
private static final long serialVersionUID = 42L;
-
如果一个对象中的某个成员变量的值不想被序列化,又该如何实现呢?
给该成员变量加 transient 关键字修饰,该关键字标记的成员变量不参与序列化过程