7️⃣对象流
ObjectInputStream和OjbectOutputSteam
用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。
序列化：用ObjectOutputStream类保存基本类型数据或对象的机制
反序列化：用ObjectInputStream类读取基本类型数据或对象的机制
ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量
对象的序列化
1.对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。//当其它程序获取了这种二进制流，就可以恢复成原来的Java对象
2.序列化的好处在于可将任何实现了Serializable接口的对象转化为字节数据，使其在保存和传输时可被还原
3.序列化是 RMI（Remote Method Invoke – 远程方法调用）过程的参数和返回值都必须实现的机制，而 RMI 是 JavaEE 的基础。因此序列化机制是JavaEE 平台的基础
4.如果需要让某个对象支持序列化机制，则必须让对象所属的类及其属性是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一。否则，会抛出NotSerializableException异常
-
Serializable
-
Externalizable
5.凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量：
private static final long serialVersionUID;
6.简单来说，Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。(InvalidCastException)
使用对象流序列化对象
若某个类实现了 Serializable 接口，该类的对象就是可序列化的：
序列化
- 创建一个 ObjectOutputStream
- 调用 ObjectOutputStream 对象的writeObject(对象) 方法输出可序列化对象
- 注意写出一次，操作flush()一次
反序列化
-
创建一个 ObjectInputStream
-
调用 readObject() 方法读取流中的对象
**强调：**如果某个类的属性不是基本数据类型或 String 类型，而是另一个引用类型，那么这个引用类型必须是可序列化的，否则拥有该类型的Field 的类也不能序列化
可序列化的条件
1
2
3
4
5
| * keypoint
* Person类需要满足如下的要求才可以序列化
* 1.实现Serializable 接口
* 2.提供serialVersionUID (Long型)
* 3.除了当前Person类需要实现实现Serializable接口之外,Person内的其他类型也必须是可序列化的（可能有别的类型的对象没有实现序列化）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
| package pers.dhx_.Java0622;
import org.junit.jupiter.api.Test;
import pers.dhx_.java0608.Person;
import java.io.*;
public class ObjectInputOutputTEst {
@Test
void t1() {
ObjectOutputStream oos = null;
try {
oos = new ObjectOutputStream(new FileOutputStream("Object.dat"));
oos.writeObject(new String("I love China"));
oos.flush();
oos.writeObject(new Person(18, "Tom"));
oos.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (oos != null) {
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
@Test
void t2() {
ObjectInputStream ois = null;
try {
ois = new ObjectInputStream(new FileInputStream("Object.dat"));
Object obj = ois.readObject();
String str = (String) obj;
System.out.println(str);
Person p1 = (Person) ois.readObject();
System.out.println(p1);
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
if (ois != null) {
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
|
对java.io.Serializable接口的理解
1.实现了Serializable接口的对象，可将它们转换成一系列字节，并可在以后完全恢复回原来的样子。这一过程亦可通过网络进行。这意味着序列化机制能自动补偿操作系统间的差异。换句话说，可以先在Windows机器上建一个对象，对其序列化，然后通过网络发给一台Unix机器，然后在那里准确无误地重新“装配”。不必关心数据在不同机器上如何表示，也不必关心字节的顺序或者其他任何细节。
2.由于大部分作为参数的类如String、Integer等都实现了java.io.Serializable的接口，也可以利用多态的性质，作为参数使接口更灵活。
8️⃣ 随机存取文件流
RandomAccessFile 类
1.RandomAccessFile 声明在java.io包下，但直接继承于java.lang.Object类。并且它实现了DataInput、DataOutput这两个接口，也就意味着这个类既可以读也可以写。
2.RandomAccessFile 类支持 “随机访问” 的方式，程序可以直接跳到文件的任意地方来读、写文件
支持只访问文件的部分内容
可以向已存在的文件后追加内容
3.RandomAccessFile 对象包含一个记录指针，用以标示当前读写处的位置。RandomAccessFile 类对象可以自由移动记录指针：
long getFilePointer()：获取文件记录指针的当前位置
void seek(long pos)：将文件记录指针定位到 pos 位置
构造器
public RandomAccessFile(File file, String mode)
public RandomAccessFile(String name, String mode)
- 创建 RandomAccessFile 类实例需要指定一个 mode 参数，该参数指定 RandomAccessFile 的访问模式：
-
r: 以只读方式打开
-
rw：打开以便读取和写入
-
**rwd:**打开以便读取和写入；同步文件内容的更新
-
**rws:**打开以便读取和写入；同步文件内容和元数据的更新
如果模式为只读r。则不会创建文件，而是会去读取一个已经存在的文件，如果读取的文件不存在则会出现异常。 如果模式为rw读写。如果文件不存在则会去创建文件，如果存在则不会创建
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
| package pers.dhx_.Java0622;
import org.junit.jupiter.api.Test;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
public class RandomAccessFileTest {
@Test
void t1() {
RandomAccessFile raf1 = null;
RandomAccessFile raf2 = null;
try {
raf1 = new RandomAccessFile(new File("Picture\\$picture.jpg"), "r");
raf2 = new RandomAccessFile(new File("decrypt_Secret_picture.jpg"), "rw");
byte[] buffer = new byte[23];
int len;
while ((len = raf1.read(buffer)) != -1) {
raf2.write(buffer, 0, len);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (raf1 != null) {
raf1.close();
}
if (raf2 != null) {
raf2.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
@Test
void t2() throws IOException {
RandomAccessFile raf = new RandomAccessFile("hello.txt", "rw");
raf.seek(3);
byte[] buffer = new byte[256];
StringBuilder builder = new StringBuilder((int) new File("hello.txt").length());
int len;
while ((len = raf.read(buffer)) != -1) {
builder.append(new String(buffer, 0, len));
}
raf.seek(3);
raf.write("hdty".getBytes());
raf.write(builder.toString().getBytes());
raf.close();
}
@Test
void t3() throws Exception {
RandomAccessFile raf = new RandomAccessFile("hello.txt", "rw");
raf.seek(3);
raf.write("hdty".getBytes());
raf.close();
}
}
|
9️⃣NIO.2中Path、Paths、Files类的使用
Java NIO 概述
Java NIO (New IO，Non-Blocking IO)是从Java 1.4版本开始引入的一套新的IO API，可以替代标准的Java IO API。NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区的(IO是面向流的)、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。
Java API中提供了两套NIO，一套是针对标准输入输出NIO，另一套就是网络编程NIO。
- –>java.nio.channels.Channel
- –>FileChannel:处理本地文件
- –>SocketChannel：TCP网络编程的客户端的Channel
- –>ServerSocketChannel:TCP网络编程的服务器端的Channel
- –>DatagramChannel：UDP网络编程中发送端和接收端的Channel
Path、Paths和Files核心API
Path可以看成是File类的升级版本
1
2
3
4
5
6
7
8
| import java.io.File;
File file = new File("index.html");
等同于：
import java.nio.file.Path;
import java.nio.file.Paths;
Path path = Paths.get("index.html");
1234567
|
同时，NIO.2在java.nio.file包下还提供了Files、Paths工具类，Files包含了大量静态的工具方法来操作文件；Paths则包含了两个返回Path的静态工厂方法。
Paths 类提供的静态 get() 方法用来获取 Path 对象：
- static Path get(String first, String … more) : 用于将多个字符串串连成路径
- static Path get(URI uri): 返回指定uri对应的Path路径
Path接口
Path 常用方法：
- String toString() ： 返回调用 Path 对象的字符串表示形式
- boolean startsWith(String path) : 判断是否以 path 路径开始
- boolean endsWith(String path) : 判断是否以 path 路径结束
- boolean isAbsolute() : 判断是否是绝对路径
- Path getParent() ：返回Path对象包含整个路径，不包含 Path 对象指定的文件路径
- Path getRoot() ：返回调用 Path 对象的根路径
- Path getFileName() : 返回与调用 Path 对象关联的文件名
- int getNameCount() : 返回Path 根目录后面元素的数量
- Path getName(int idx) : 返回指定索引位置 idx 的路径名称
- Path toAbsolutePath() : 作为绝对路径返回调用 Path 对象
- Path resolve(Path p) :合并两个路径，返回合并后的路径对应的Path对象
- File toFile(): 将Path转化为File类的对象
测试：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
| import java.io.File;
import java.nio.file.Path;
import java.nio.file.Paths;
import org.junit.Test;
public class PathTest {
@Test
public void test1() {
Path path1 = Paths.get("d:\\nio\\hello.txt");
Path path2 = Paths.get("d:\\", "nio\\hello.txt");
System.out.println(path1);
System.out.println(path2);
Path path3 = Paths.get("d:\\", "nio");
System.out.println(path3);
}
@Test
public void test2() {
Path path1 = Paths.get("d:\\", "nio\\nio1\\nio2\\hello.txt");
Path path2 = Paths.get("hello.txt");
System.out.println(path1);
System.out.println(path1.startsWith("d:\\nio"));
System.out.println(path1.endsWith("hello.txt"));
System.out.println(path1.isAbsolute() + "~");
System.out.println(path2.isAbsolute() + "~");
System.out.println(path1.getParent());
System.out.println(path2.getParent());
System.out.println(path1.getRoot());
System.out.println(path2.getRoot());
System.out.println(path1.getFileName() + "~");
System.out.println(path2.getFileName() + "~");
for (int i = 0; i < path1.getNameCount(); i++) {
System.out.println(path1.getName(i) + "*****");
}
System.out.println(path1.toAbsolutePath());
System.out.println(path2.toAbsolutePath());
Path path3 = Paths.get("d:\\", "nio");
Path path4 = Paths.get("nioo\\hi.txt");
path3 = path3.resolve(path4);
System.out.println(path3);
File file = path1.toFile();
Path newPath = file.toPath();
}
}
|
Files类
java.nio.file.Files 用于操作文件或目录的工具类。
Files常用方法：
- Path copy(Path src, Path dest, CopyOption … how) : 文件的复制
- Path createDirectory(Path path, FileAttribute<?> … attr) : 创建一个目录
- Path createFile(Path path, FileAttribute<?> … arr) : 创建一个文件
- void delete(Path path) : 删除一个文件/目录，如果不存在，执行报错
- void deleteIfExists(Path path) : Path对应的文件/目录如果存在，执行删除
- Path move(Path src, Path dest, CopyOption…how) : 将 src 移动到 dest 位置
- long size(Path path) : 返回 path 指定文件的大小
Files常用方法：用于判断
- boolean exists(Path path, LinkOption … opts) : 判断文件是否存在
- boolean isDirectory(Path path, LinkOption … opts) : 判断是否是目录
- boolean isRegularFile(Path path, LinkOption … opts) : 判断是否是文件
- boolean isHidden(Path path) : 判断是否是隐藏文件
- boolean isReadable(Path path) : 判断文件是否可读
- boolean isWritable(Path path) : 判断文件是否可写
- boolean notExists(Path path, LinkOption … opts) : 判断文件是否不存在
Files常用方法：用于操作内容
- SeekableByteChannel newByteChannel(Path path, OpenOption…how) : 获取与指定文件的连接，how 指定打开方式。
- DirectoryStream newDirectoryStream(Path path) : 打开 path 指定的目录
- InputStream newInputStream(Path path, OpenOption…how):获取 InputStream 对象
- OutputStream newOutputStream(Path path, OpenOption…how) : 获取 OutputStream 对象
测试：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
| import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.channels.SeekableByteChannel;
import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.nio.file.StandardOpenOption;
import java.util.Iterator;
import org.junit.Test;
public class FilesTest {
@Test
public void test1() throws IOException{
Path path1 = Paths.get("d:\\nio", "hello.txt");
Path path2 = Paths.get("atguigu.txt");
Path path3 = Paths.get("d:\\nio\\nio1");
Path path4 = Paths.get("d:\\nio\\hi.txt");
Files.deleteIfExists(path3);
long size = Files.size(path2);
System.out.println(size);
}
@Test
public void test2() throws IOException{
Path path1 = Paths.get("d:\\nio", "hello.txt");
Path path2 = Paths.get("atguigu.txt");
System.out.println(Files.exists(path2, LinkOption.NOFOLLOW_LINKS));
System.out.println(Files.isDirectory(path1, LinkOption.NOFOLLOW_LINKS));
System.out.println(Files.isReadable(path1));
System.out.println(Files.isWritable(path1));
System.out.println(Files.notExists(path1, LinkOption.NOFOLLOW_LINKS));
}
@Test
public void test3() throws IOException{
Path path1 = Paths.get("d:\\nio", "hello.txt");
InputStream inputStream = Files.newInputStream(path1, StandardOpenOption.READ);
OutputStream outputStream = Files.newOutputStream(path1, StandardOpenOption.WRITE,StandardOpenOption.CREATE);
SeekableByteChannel channel = Files.newByteChannel(path1, StandardOpenOption.READ,StandardOpenOption.WRITE,StandardOpenOption.CREATE);
Path path2 = Paths.get("e:\\teach");
DirectoryStream<Path> directoryStream = Files.newDirectoryStream(path2);
Iterator<Path> iterator = directoryStream.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
|
