## 一、概述
在变量、数组、对象和集合中存储的数据是暂时存在的，一旦程序结束它们就会丢失。为了能够永久地保存程序创建的数据，需要将其保存到磁盘文件中，这样就可以在其他程序中使用它们。Java 的 I/O（输入/输出）技术可以将数据保存到文本文件和二进制文件中， 以达到永久保存数据的要求。
## 二、File 类的应用
在 Java 中，File 类是`java.io`包中唯一代表磁盘文件本身的对象。File 类主要用来获取或处理与磁盘文件相关的信息，像文件名、 文件路径、访问权限和修改日期等，还可以浏览子目录层次结构。但是，File 类不具有从文件读取信息和向文件写入信息的功能，它仅描述文件本身的属性。
### 2.1 构造方法
* `File(String pathname)`通过将给定路径名字符串转换成抽象路径名来创建一个新 File 实例。
* `File(String parent, String child)`根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
* `File(File parent, String child)`根据 parent 抽象路径名和 child 路径名字符串创建一个新的 File 实例。
### 2.2 常用方法
* `exists(): boolean`测试当前 file 对象表示的文件是否存在
* `isFile(): boolean`测试当前 File 对象表示的文件是否为一个普通文件
* `isDirectory(): boolean` 测试当前 File 对象表示的文件是否为一个路径
* `canRead(): boolean` 测试当前 File 对象表示的文件是否可读
* `canWrite(): boolean` 测试当前 File 对象表示的文件是否可写
* `getName(): String` 返回当前 File 对象表示的文件名
* `getPath(): String` 返回当前 File 对象表示的文件的相对路径
* `getParent(): String` 返回当前 File 对象表示的文件的父级目录路径
* `getParentFile(): File` 返回当前 File 对象表示的文件的父级目录文件对象
* `getAbsolutePath(): String` 返回当前 File 对象表示的文件的绝对路径
* `getAbsoluteFile(): File` 返回当前 File 对象表示的文件的绝对目录文件对象
* `createNewFile(): boolean` 创建当前 File 对象表示的文件（父级目录需存在）
* `mkdir(): boolean` 创建当前 File 对象表示的文件目录（父级目录需存在）
* `mkdirs(): boolean` 创建当前 File 对象表示的文件目录
* `list(): String[]` 返回当前 File 对象表示的文件目录下的文件名列表
* `listFiles(): File[]` 返回当前 File 对象表示的文件目录下的文件列表
```
String path = "d:/hello/"; // 指定文件所在的目录
File f = new File(path, "test.txt"); // 建立File变量, 并设定由 f 变量引用
System.out.println("文件名称：" + f.getName());
System.out.println("文件路径：" + f.getPath());
System.out.println("绝对路径：" + f.getAbsolutePath());
System.out.println("当前对象：" + f.isFile() ? "是文件" : "不是文件");
System.out.println("当前对象：" + f.isDirectory() ? "是目录" : "不是目录");
System.out.println("是否可读：" + f.canRead() ? "可读取" : "不可读取");
System.out.println("是否可写：" + f.canWrite() ? "可写入" : "不可写入");
System.out.println("文件长度：" + f.length() + "字节");
System.out.println("最后修改日期：" + new Date(f.lastModified()));
```
```
String path = "d:/hello/"; // 指定文件目录
String filename = "demo.txt"; // 指定文件名称
File f = new File(path, filename); // 创建指向文件的 File 对象
// 判断文件是否存在
if(!f.exists()) {
f.createNewFile();
}
```
```
File f = new File("d:/"); // 建立File变量, 并设定由 f 变量变数引用
File[] files = f.listFiles(); // 调用不带参数的 list() 方法
for (File file : files) { // 遍历返回的字符数组
System.out.println("文件名称: " + file);
System.out.println("文件类型: " + file.isFile() ? "文件" : "文件夹");
System.out.println("文件大小: " + file.length() + "字节");
}
```
【选择】关于 java.io.File 类的方法 mkdir() 和 mkdirs()，说法错误的是（）（选择一项）
```
A 这两个方法都用于创建目录
B mkdir() 方法用于创建单级目录
C mkdirs() 方法用于创建多级目录
D 如果这两个方法的返回值为 false，表示目录创建成功
```
【选择】File 类中，返回文件所在文件夹的路径常用方法的是（）（选择一项）
```
A getName() B getParent() C getPath() D getParentFile()
```
【选择】下列程序的功能是在文件夹 College 下创建 Department 文件夹，再在 Department 文件夹下创建 Class 文件夹，请选择正确的语句。
```
public static void main(String[] args) {
// (1)
if (!f2.exist()) {
// (2)
System.out.println("目录创建成功！！！");
// 返回完整路径名
// (3)
}
}
```
```
d:/.../College/Department/Class
```
```
I. File f2 = new File("College/Department/Class");
II. File f2 = new File("College", "Department", "Class");
III. f2.mkdirs();
IV. f2.mkdir();
V. System.out.println(f2.getAbsolutePath());
VI. System.out.println(f2.getParent());
```
```
A. I III V B. I II V C. II III VI D II III V
```
【选择】请阅读下列代码，选择正确的语句（）。其中 d:/animal/pets 和 c:/fruits 目录默认已存在。（选择一项）
```
File c = new File("d:/animal/pets", "cat");
if (1) {
c.mkdir();
}
File animal = new File("d:/pets/pig");
if (!animal.exists) {
// (2)
}
File fruit = new File("c:/fruits/banana.doc");
if(!fruit.exists()) {
try {
// (3)
} catch (IOException e) {
e.printStackTrace();
}
}
```
```
A !c.exist(); aniaml.mkdir(); fruit.mkdir();
B c.exist(); aniaml.mkdir(); fruit.mkdirs();
C !c.exist(); animal.mkdirs(); fruit.createNewFile();
D c.exist(); animal.mkdirs(); fruit.mkdirs();
```
【编程】创建一个 File 类对象，判断指定文件或目录是否存在，若存在判断其是文件还是目录，是否可读、可写。
```
创建文件成功
文件名称：Monday.doc
文件上一级目录：File
文件/目录：这是一个文件
读写性：这个文件既可以读还可以写
```
## 三、输入输出流
Java 程序通过流来完成输入/输出，所有的输入/输出以流的形式处理。流是一组有序的数据序列，将数据从一个地方带到另一个地方。
* 按照流的方向主要分为输入流和输出流两大类。
* 数据流按照数据单位的不同分为字节流和字符流。
> 在 Java 中所有输入流类都是 InputStream 抽象类（字节输入流）和 Reader 抽象类（字符输入流）的子类。
> 在 Java 中所有输出流类都是 OutputStream 抽象类（字节输出流）和 Writer 抽象类（字符输出流）的子类。
【选择】关于字节流和字符流的说法错误的是（）（选择一项）
```
A InputStream 是字节输入流的父类
B OutputStream 是字输出流的父类
C FileInputStream 是文件输出流
D BufferedOutputStream 是缓冲输出流
```
## 四、字节流
### 4.1 字节输入流 InputStream
InputStream 类是字节输入流的抽象类，是所有字节输入流的父类。
* `ByteArrayInputStream`类：将字节数组转换为字节输入流，从中读取字节。
* `FileInputStream`类：从文件中读取数据。
* `PipedInputStream`类：连接到一个 PipedOutputStream（管道输出流）。
* `SequenceInputStream`类：将多个字节输入流串联成一个字节输入流。
* `ObjectInputStream`类：将对象反序列化。
*****
* `int read()`从输入流中读取一个 8 位的字节，并把它转换为 0～255 的整数，最后返回整数。如果返回 -1，则表示已经到了输入流的末尾。
* `int read(byte b[])`从输入流中读取若干字节，并把它们保存到参数 b 指定的字节数组中。 该方法返回读取的字节数。如果返回 -1，则表示已经到了输入流的末尾。
* `int read(byte b[], int off, int len)`从输入流中读取若干字节，并把它们保存到参数b指定的字节数组中。该方法返回实际读取的字节数。如果返回 -1，则表示已经到了输入流的末尾。
* `long skip(long n)`从输入流中跳过参数n指定数目的字节。该方法返回跳过的字节数。
* `int available()`返回可以从输入流中读取的字节数。
* `void close()`关闭输入流。在读操作完成后，应该关闭输入流，系统将会释放与这个输入流相关的资源。
* `void mark(int readlimit)`在输入流的当前位置开始设置标记，参数 readLimit 则指定了最多被设置标记的字节数。
* `void reset()`将输入流的指针返回到设置标记的起始处。
* `boolean markSupported()`判断当前输入流是否允许设置标记，是则返回 true，否则返回 false。
### 4.2 字节输出流 OutputStream
OutputStream 类是字节输出流的抽象类，是所有字节输出流的父类。
* `ByteArrayOutputStream`类：向内存缓冲区的字节数组中写数据。
* `FileOutputStream`类：向文件中写数据。
* `PipedOutputStream`类：连接到一个 PipedlntputStream（管道输入流）。
* `ObjectOutputStream`类：将对象序列化。
*****
* `void write(int b)`向输出流写入一个字节。这里的参数是 int 类型，但是它允许使用表达式，而不用强制转换成 byte 类型。为了提高 I/O 操作的效率，建议尽量使用write() 方法的另外两种形式
* `void write(byte[] b)`把参数 b 指定的字节数组中的所有字节写到输出流中
* `void write(byte[] b, int off, int len)`把参数 b 指定的字节数组中的若干字节写到输出流中。其中，off 指定字节数组中的起始下标，len 表示元素个数
* `void close()`关闭输出流。写操作完成后，应该关闭输出流。系统将会释放与这个输出流相关的资源。注意，OutputStream 类本身的 close() 方法不执行任何操作，但是它的许多子类重写了 close() 方法
* `void flush()`为了提高效率，在向输出流中写入数据时，数据一般会先保存到内存缓冲区中，只有当缓冲区中的数据达到一定程度时，缓冲区中的数据才会被写入输出流中。使用 flush() 方法则可以强制将缓冲区中的数据写入输 出流，并清空缓冲区
### 4.3 文件输入流 FileInputStream
FileInputStream 可以从文件系统的某个文件中获取输入字节。通过使用 FileInputStream 可以访问文件中的一个字节、一批字节或整个文件。
在创建 FileInputStream 类的对象时，如果找不到指定的文件将拋出 FileNotFoundException 异常，该异常必须捕获或声明拋出。
* `FileInputStream(File file)`通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
* `FileInputStream(String name)`通过打开一个到实际文件的链接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。
```
try {
// 以File对象作为参数创建FileInputStream对象
FileInputStream fis1 = new FileInputStream(new File("d:/hello.txt"));
// 以字符串值作为参数创建FilelnputStream对象
FileInputStream fis2 = new FileInputStream("d:/hello.txt");
} catch (FileNotFoundException e) {
e.printStackTrace();
}
```
```
public static void main(String[] args){
File file = new File("d:/java/Hello.java");
FileInputStream fis = null;
try {
//因为 File 没有读写的能力,所以需要有个 InputStream
fis = new FileInputStream(file);
// 定义一个字节数组
byte[] bytes = new byte[1024];
int n = 0; // 得到实际读取到的字节数
System.out.println("d:/java/Hello.java文件内容如下：");
// 循环读取
while((n = fis.read(bytes)) != -1) {
// 将数组中从下标0到n的内容给 s
String s = new String(bytes, 0, n);
System.out.println(s);
}
} catch(Exception e){
e.printStackTrace();
} finally {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
```
【选择】给定下列代码，填写合适的代码输出文本全部内容（）（选择一项）
```
FileInputStream fis = new FileInputStream("hello.txt");
int t = 0;
while (1) {
System.out.println(2);
}
// (3)
```
```
A. t.read != 0 t 不填
B. (t = p2.read()) != 0 (char) t 不填
C. t.read != -1 (char) t p2.close();
D. (t = p2.read()) != -1 (char) t p2.close();
```
【选择】关于 Java 输入输出流的说法正确的是（）（选择两项）
```
A 调用 createNewFile() 方法会抛出 FileNotFoundException 异常
B 创建 FileInputStream 对象时，会抛出 FileNotFoundException 异常
C 如果同时需要抛出 FileNotFoundException 和 IOException
则 IOException 必须先抛出
D FileNotFoundException 是 IOException 异常的子类
```
【编程】统计英文演讲稿 speech.txt 文件中共有多少个字节，并显示所有内容。
```
文本内容：abcdefghijklmnopqrstuvwxyz
统计结果：speech.txt 文件中共有26个字节。
```
### 4.4 FileOutputStream 文件输出流
FileOutputStream 类继承自 OutputStream 类，重写和实现了父类中的所有方法。FileOutputStream 类的对象表示一个文件字节输出流，可以向流中写入一个字节或一批字节。
在创建 FileOutputStream 类的对象时，如果指定的文件不存在，则创建一个新文件；如果文件已存在，则清除原文件的内容重新写入。
* `FileOutputStream(File file)`创建一个文件输出流，参数 file 指定目标文件。
* `FileOutputStream(File file, boolean append)`创建一个文件输出流，参数 file 指定目标文件，append 指定是否将数据添加到目标文件的内容末尾，如果为 true，则在末尾添加；如果为 false，则覆盖原有内容；其默认值为 false。
* `FileOutputStream(String name)`创建一个文件输出流，参数 name 指定目标文件的文件路径信息。
* `FileOutputStream(String name, boolean append)`创建一个文件输出流，参数 name 和 append 的含义同上。
```
public static void main(String[] args){
FileInputStream fis = null; // 声明 FileInputStream 对象 fis
FileOutputStream fos = null; // 声明 FileOutputStream 对象 fos
try{
// 实例化 FileInputStream 对象
fis = new FileInputStream("d:/java/Hello.java");
// 创建目标文件对象，该文件不存在
File target = new File("d:/java/Hello.txt");
// 实例化 FileOutputStream 对象
fos = new FileOutputStream(target);
byte[] bytes = new byte[1024]; // 每次读取1024字节
int i = fis.read(bytes);
while(i != -1){
fos.write(bytes, 0, i);
i = fis.read(bytes);
}
System.out.println("写入结束！");
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
fis.close(); // 关闭 FileInputStream 对象
fos.close(); // 关闭 FileOutputStream 对象
} catch (IOException e) {
e.printStackTrace();
}
}
}
```
【选择】关于 FileOutputStream 的说法错误的是（）（选择一项）
```
A 可以调用 write 方法将 int 类型数据写入文件
B 可以调用 write 方法将字符型数据写入文件
C 构造方法 FileOutputStream(String name, boolean append)，
当第二个参数为 false 时，表示可以在原文件后面继续写入数据
D close() 方法用于关闭流， 并释放资源
```
【阅读】请阅读下列程序，要实现图片的拷贝并且拷贝前后文件大小不变，（1）应该填写的语句是（）（选择一项）
```
public static void main(String[] args) throws IOException {
FileInputStream in = new FileInputStream("d:\\turtle.gif");
FileOutputStream out = new FileOutputStream("d:\\turtleos.gif");
int p = 0;
byte[] b = ne byte[2048];
while((p = in.read(b)) != -1) {
// (1)
}
System.out.println("拷贝成功");
in.close();
out.close();
}
```
### 4.3 BufferedInputStream 缓冲输入流
* `BufferedInputStream(InputStream in)`创建一个 BufferedInputStream 来修饰参数 in 指定的字节输入流。
* `BufferedInputStream(InputStream in,int size)`创建一个 BufferedInputStream 来修饰参数 in 指定的字节输入流，参数 size 则用于指定缓冲区的大小，单位为字符。
【选择】下列关于字节输入输出缓冲流的说法正确的是（）（选择一项）
```
A FileInputStream 是 BufferedInputStream 的父类
B BufferedInputStream 和 BufferedOutputStream 都有一个字节数组来存储缓冲的数据
这个数组是可见的
C BufferedInputStream 的方法 flush() 是用来清空缓冲区的
D flush() 方法主要用来清空缓冲区。
当缓冲区被填满时就会自动执行写操作，但是当缓冲区不满时，就不会执行写操作。
所以，当缓冲区未被填满但是执行写操作时就要强制清空缓冲区。
```
### 4.4 BufferedOutputStream 缓冲输出流
* `BufferedOutputStream(OutputStream out)`创建一个 BufferedOutputStream 来修饰参数 out 指定的字节输出流。
* `BufferedOutputStream(OutputStream out, int size)`创建一个 BufferedOutputStream 来修饰参数 out 指定的字节输出流，参数 size 则用于指定缓冲区的大小，单位为字符。
【选择】下列缓冲流的使用方法正确的是（）（选择三项）
```
A String filename = "cat.txt";
FileOutputStream fos = new FileOutputStream(filename);
BufferedOutputStream bos = new BufferedOutputStream(filename);
B String filename = "cat.txt";
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filename));
C FileOutputStream fos = new FileOutputStream("cat.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
D BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("cat.txt"));
```
【编程】编写一个 Java 程序，将 100000 个字符分别写入文件 one.txt 和文件 two.txt，one 用不加缓冲的文件输出流来写，two 用缓冲文件输出流来写，比较用时的多少。效果图如下：
```
one.txt 不使用缓冲流来写
用时为：98
two.txt 使用缓冲流来写
用时为：2
节省时间：96ms
```
## 五、字符流
### 5.1 字符输入流
Reader 类是字符输入流的抽象类，是所有字符输入流的父类。
* `CharArrayReader`将字符数组转换为字符输入流，从中读取字符。
* `StringReader`将字符串转换为字符输入流，从中读取字符。
* `BufferedReader`为其他字符输入流提供读缓冲区。
* `PipedReader`连接到一个 PipedWriter。
* `InputStreamReader`将字节输入流转换为字符输入流，可以指定字符编码。
*****
* `int read()`从输入流中读取一个字符，并把它转换为 0~65535 的整数。如果返回 -1， 则表示已经到了输入流的末尾。
* `int read(char[] cbuf)`从输入流中读取若干个字符，并把它们保存到参数 cbuf 指定的字符数组中。 该方法返回读取的字符数，如果返回 -1，则表示已经到了输入流的末尾。
* `int read(char[] cbuf, int off, int len)`从输入流中读取若干个字符，并把它们保存到参数 cbuf 指定的字符数组中。其中，off 指定在字符数组中开始保存数据的起始下标，len 指定读取的字符数。该方法返回实际读取的字符数，如果返回 -1，则表示已经到了输入流的末尾。
### 5.2 字符输出流
Writer 类是字符输出流的抽象类，是所有字符输出流的父类。
* `CharArrayWriter`向内存缓冲区的字符数组写数据。
* `StringWriter`向内存缓冲区的字符串（StringBuffer）写数据。
* `BufferedWriter`为其他字符输出流提供写缓冲区。
* `PipedWriter`连接到一个 PipedReader。
* `OutputStreamReader`将字节输出流转换为字符输出流，可以指定字符编码。
*****
* `void write(int c)`向输出流中写入一个字符
* `void write(char[] cbuf)`把参数 cbuf 指定的字符数组中的所有字符写到输出流中
* `void write(char[] cbuf,int off,int len)`把参数 cbuf 指定的字符数组中的若干字符写到输出流中。其中，off 指定字符数组中的起始下标，len 表示元素个数
* `void write(String str)`向输出流中写入一个字符串
* `void write(String str, int off,int len)`向输出流中写入一个字符串中的部分字符。其中，off 指定字符串中的起始偏移量，len 表示字符个数
* `append(char c)`将参数 c 指定的字符添加到输出流中
* `append(charSequence esq)`将参数 esq 指定的字符序列添加到输出流中
* `append(charSequence esq,int start,int end)`将参数 esq 指定的字符序列的子序列添加到输出流中。其中，start 指定子序列的第一个字符的索引，end 指定子序列中最后一个字符后面的字符的索引，也就是说子序列的内容包含 start 索引处的字符，但不包括 end索引处的字符
### 5.3 字符文件输入流
* `FileReader(File file)`在给定要读取数据的文件的情况下创建一个新的 FileReader 对象。
* `FileReader(String fileName)`在给定从中读取数据的文件名的情况下创建一个新 FileReader 对象。
```
public static void main(String[] args) {
FileReader fr = null;
try {
fr = new FileReader("d:/java/Hello.java"); // 创建FileReader对象
int i = 0;
while ((i = fr.read()) != -1) {
System.out.print((char) i); // 将读取的内容强制转换为char类型
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
```
### 5.4 字符文件输出流
* `FileWriter(File file)`在指定 File 对象的情况下构造一个 FileWriter 对象。
* `FileWriter(File file,boolean append)`在指定 File 对象的情况下构造一个 FileWriter 对象，如果 append 的值为 true，则将字节写入文件末尾，而不是写入文件开始处。
* `FileWriter(String fileName)`在指定文件名的情况下构造一个 FileWriter 对象。
* `FileWriter(String fileName,boolean append)`在指定文件名以及要写入文件的位置的情况下构造 FileWriter 对象。其中，append 是一个 boolean 值，如果为 true，则将数据写入文件末尾，而不是文件开始处。
```
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
FileWriter fw = null;
try {
fw = new FileWriter("d:/java/book.txt"); // 创建FileWriter对象
for (int i = 0; i < 4; i++) {
System.out.println("请输入第" + (i + 1) + "个字符串：");
String name = input.next(); // 读取输入的名称
fw.write(name + "\r\n"); // 循环写入文件
}
System.out.println("录入完成！");
} catch (Exception e) {
System.out.println(e.getMessage());
} finally {
try {
fw.close(); // 关闭对象
} catch (IOException e) {
e.printStackTrace();
}
}
}
```
【选择】关于字符流的说法错误的是（）（选择一项）
```
A Reader 是字符输入流的父类
B Writer 是字符输出流的父类
C InputStreamReader 是 InputStream 的子类
D BufferedReader 是 Reader 的子类
```
【编程】应用转换流向文件写入文本，并将文本读取出来输出到控制台上。
```
你好吗？
我很好！
```
### 5.5 字符缓冲区输入流
BufferedReader 类主要用于辅助其他字符输入流，它带有缓冲区，可以先将一批数据读到内存缓冲区。接下来的读操作就可以直接从缓冲区中获取数据，而不需要每次都从数据源读取数据并进行字符编码转换，这样就可以提高数据的读取效率。
* `BufferedReader(Reader in)`创建一个 BufferedReader 来修饰参数 in 指定的字符输入流。
* `BufferedReader(Reader in,int size)`创建一个 BufferedReader 来修饰参数 in 指定的字符输入流，参数 size 则用于指定缓冲区的大小，单位为字符。
```
public static void main(String[] args) {
FileReader fr = null;
BufferedReader br = null;
try {
fr = new FileReader("d:/java/book.txt");
br = new BufferedReader(fr);
String line = "";
while ((line = br.readLine()) != null) {
System.out.println(line);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
br.close();
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
```
### 5.6 字符缓冲区输出流
BufferedWriter 类主要用于辅助其他字符输出流，它同样带有缓冲区，可以先将一批数据写入缓冲区，当缓冲区满了以后，再将缓冲区的数据一次性写到字符输出流，其目的是为了提高数据的写效率。
* `BufferedWriter(Writer out)`创建一个 BufferedWriter 来修饰参数 out 指定的字符输出流。
* `BufferedWriter(Writer out,int size)`创建一个 BufferedWriter 来修饰参数 out 指定的字符输出流，参数 size 则用于指定缓冲区的大小，单位为字符。
## 五、对象序列化与反序列化
Java 提供了一种对象序列化的机制，该机制中，一个对象可以被表示为一个字节序列，该字节序列包括该对象的数据、有关对象的类型的信息和存储在对象中数据的类型。
将序列化对象写入文件之后，可以从文件中读取出来，并且对它进行反序列化，也就是说，对象的类型信息、对象的数据，还有对象中的数据类型可以用来在内存中新建对象。
```
public class Student implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private transient int age;
public Student (String name, int age) {
this.name = name;
this.age = age;
}
}
public class StudentTest {
public static void main (String[] args) {
Student stu = new Student("xiaoming", 20);
ObjectOutputStream oos = null;
ObjectInputStream ois = null;
try {
oos = new ObjectOutputStream(new FileOutputStream("d:/student.txt"));
oos.writeObject(stu);
ois = new ObjectInputStream(new FileInputStream("d:/student.txt"));
Student s = (Student) ois.readObject();
System.out.println(s);
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (oos != null) oos.close();
if (ois != null) ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
```
【阅读】请阅读下列程序，按顺序填写正确的语句
```
import java.io.*;
// (1) {
String name;
int age;
double weight;
String country;
public Dog(String name, int age, double weight, String country) {
this.name = name;
this.age = age;
this.weight = weight;
this.country = country;
}
public (2) {
return "中文名：" + name + "\n" + "年龄：" + age + "岁\n"
+ "体重：" + weight + "kg\n" + "国籍：" + country + "\n";
}
public static void main(String[] args)
throws IOException, ClassNotFoundException {
Dog xiaobai = new Dog("小白", 2, 35, "中国");
FileOutputStream fos = new FileOutputStream("dog.txt");
// (3)
// (4)
// (5)
oos.flush();
// (6)
System.out.println(dog);
fos.close();
oos.close();
ois.close();
}
}
```
```
中文名：小白
年龄：2岁
体重：35.0kg
国籍：中国
```
【编程】应用对象序列化和对象反序列化向文件写入对象，并将对象读取出来输入到控制台上。效果图如下：
```
apple 系列产品信息：
产品ID：123
产品名称：iphone
产品属性：telephone
产品价格：4888.0
产品ID：234
产品名称：ipad
产品属性：computer
产品价格：5088.0
产品ID：345
产品名称：macbook
产品属性：computer
产品价格：10688.0
产品ID：256
产品名称：iwatch
产品属性：watch
产品价格：4799.0
```
- 阶段一 Java 零基础入门
- 步骤1：基础语法
- 第01课 初识
- 第02课 常量与变量
- 第03课 运算符
- 第04课 选择结构
- 第05课 循环结构
- 第06课 一维数组
- 第08课 方法
- 第09课 数组移位与统计
- 第10课 基础语法测试
- 第09课 基础语法测试（含答案）
- 步骤2：面向对象
- 第01课 类和对象
- 第02课 封装
- 第03课 学生信息管理
- 第04课 继承
- 第05课 单例模式
- 第06课 多态
- 第07课 抽象类
- 第08课 接口
- 第09课 内部类
- 第10课 面向对象测试
- 第10课 面向对象测试（含答案）
- 步骤3：常用工具类
- 第01课 异常
- 第02课 包装类
- 第03课 字符串
- 第04课 集合
- 第05课 集合排序
- 第06课 泛型
- 第07课 多线程
- 第08课 输入输出流
- 第09课 案例：播放器
- 第10课 常用工具测试（一）
- 第10课 常用工具测试（一）（答案）
- 第10课 常用工具测试（二）
- 第10课 常用工具测试（二）（答案）
- 阶段二 从网页搭建入门 JavaWeb
- 步骤1：HTML 与 CSS
- 第01课 HTML 入门
- 第01课 HTML 入门（作业）
- 第02课 CSS 入门
- 第02课 CSS 入门（作业）
- 第03课 CSS 布局
- 第03课 CSS 布局（作业）
- 步骤2：JavaScript 与前端案例
- 第01课 JavaScript 入门
- 第01课 JavaScript 入门（作业）
- 第02课 仿计算器
- 第03课 前端油画商城案例
- 第04课 轮播图
- 第05课 网页搭建测试
- 第05课 网页搭建测试（含答案）
- 步骤3：JavaScript 教程
- 入门
- 概述
- 基本语法
- 数据类型
- 概述
- 数值
- 字符串
- undefined, null 和布尔值
- 对象
- 函数
- 数组
- 运算符
- 算术运算符
- 比较运算符
- 布尔运算符
- 位运算符
- 运算顺序
- 语法专题
- 数据类型的转换
- 错误处理机制
- 标准库
- String
- Date
- Math
- DOM
- 概述
- Document 节点
- 事件
- EventTarget 接口
- 事件模型
- 常见事件
- 阶段三 数据库开发与实战
- 步骤1：初始数据库操作
- 第01课 数据类型
- 第02课 表的管理
- 第03课 数据管理
- 第04课 常用函数
- 第05课 JDBC 入门
- 第06课 Java 反射
- 第07课 油画商城
- 第08课 数据库基础测试
- 步骤2：MyBatis 从入门到进阶
- 第01课 IntelliJ IDEA 开发工具入门
- 第02课 Maven 入门
- 第03课 工厂模式
- 第04课 MyBatis 入门
- 第05课 MyBatis 进阶
- 第06课 商品信息管理
- 第07课 MyBatis 基础测试
- 步骤3：Redis 数据库与 Linux 下项目部署
- 第01课 Linux 基础
- 第02课 Linux 下 JDK 环境搭建及项目部署
- 第03课 Redis 入门
- 阶段四 SSM 到 Spring Boot 入门与综合实战
- 步骤1：Spring 从入门到进阶
- 第01课 Spring 入门
- 第02课 Spring Bean 管理
- 第03课 Spring AOP
- 第04课 基于 AspectJ 的 AOP 开发
- 第05课 JDBC Template
- 第06课 Spring 事务管理
- 第07课 人员管理系统开发
- 第08课 Spring 从入门到进阶测试
- 步骤2：Spring MVC 入门与 SSM 整合开发
- 第01课 Spring MVC 入门与数据绑定
- 第02课 Restful 风格的应用
- 第03课 SpringMVC 拦截器
- 第04课 办公系统核心模块
- 步骤3：Spring Boot 实战
- 第01课 Spring Boot 入门
- 第02课 校园商铺项目准备
- 第03课 校园商铺店铺管理
- 第04课 校园商铺商品管理及前台展示
- 第05课 校园商铺框架大换血
- 步骤4：Java 面试
- 第01课 面试准备
- 第02课 基础面试技巧
- 第03课 Web基础与数据处理
- 第04课 主流框架