前面已经把java io的主要操作讲完了
这一节我们来说说关于java io的其他内容
Serializable序列化
实例1：对象的序列化
|
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
|
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;
@SuppressWarnings("serial")
//一个类要想实现序列化则必须实现Serializable接口class Person implements Serializable {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String toString() {
return "Name:" + this.name + ", Age:" + this.age;
}
}public class Demo {
public static void main(String[] args) {
String path = File.separator + "home" + File.separator + "siu" +
File.separator + "work" + File.separator + "demo.txt";
Person p1 = new Person("zhangsan",12);
Person p2 = new Person("lisi",14);
//此处创建文件写入流的引用是要给ObjectOutputStream的构造函数玩儿
FileOutputStream fos = null;
ObjectOutputStream oos = null;
try {
fos = new FileOutputStream(path);
oos = new ObjectOutputStream(fos);
//这里可以写入对象，也可以写入其他类型数据
oos.writeObject(p1);
oos.writeObject(p2);
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
} |
所谓对象序列化就是把一个对象进行持久化存储，方便保留其属性
通俗点说，等于把一个对象从堆内存里边揪出来放到硬盘上
当然，如果你开心，你可以序列化其他东西，包括数组，基本数据类型等等
来看看内容，神马玩意儿这是……
实例2：对象的反序列化
|
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
|
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class Demo {
public static void main(String[] args) {
String path = File.separator + "home" + File.separator + "siu" +
File.separator + "work" + File.separator + "demo.txt";
//好吧，这里代码写得着实有点长了，还要抛异常什么的
//如果你也看的烦，那就在主方法上抛吧，构造方法里用匿名对象就好了
//什么？别告诉我你不知道匿名对象
FileInputStream fis = null;
ObjectInputStream ois = null;
try {
fis = new FileInputStream(path);
ois = new ObjectInputStream(fis);
//这里返回的其实是一个Object类对象
//因为我们已知它是个Person类对象
//所以，就地把它给向下转型了
Person p = (Person)ois.readObject();
System.out.println(p);
//抛死你，烦烦烦～！！！
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
try {
//还是要记得关闭下流
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
} |
你看，我们把一个对象存放在硬盘上是为了方便日后使用
现在用得着它了，自然得拿出来
管道流
实例3：线程的通信
|
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
|
import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
//实现Runnable接口，实现一个读的线程class Read implements Runnable {
private PipedInputStream in;
//将需要读的管道流传入到构造函数中
public Read(PipedInputStream in) {
this.in = in;
}
//实现读这一线程
public void run() {
try {
byte[] buf = new byte[1024];
int temp = 0;
//循环读取
//read是一个阻塞方法，需要抛异常
//此处把打印流的代码也加入进来
//是因为如果没有读取到数据，那么打印的代码也无效
while((temp = in.read(buf)) != -1) {
String str = new String(buf,0,temp);
System.out.println(str);
}
} catch (IOException e) {
//其实这里应抛出一个自定义异常的
//暂时我还没弄清楚
e.printStackTrace();
} finally {
try {
//我已经抛火了，这只是为了提醒自己异常很重要
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}//这里实现一个写的类class Write implements Runnable {
private PipedOutputStream out;
//将管道输入流传进来
public Write(PipedOutputStream out) {
this.out = out;
}
public void run() {
try {
//这里开始写出数据
out.write("管道输出".getBytes());
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
//其实应该可以把这个关闭方法写到上面那个try里边
//但是这样感觉怪怪的，逻辑不大对
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}public class Demo {
public static void main(String[] args) {
PipedInputStream in = new PipedInputStream();
PipedOutputStream out = new PipedOutputStream();
try {
//连接管道
in.connect(out);
//创建对象，开启线程
//此处同样放进try...catch里面
//因为如果没有链接管道，下面操作无意义
Read r = new Read(in);
Write w = new Write(out);
//把已经实现好run方法的对象放入线程中执行
new Thread(r).start();
new Thread(w).start();
} catch (IOException e) {
e.printStackTrace();
}
}
} |
好吧，废了那么大劲儿，就打印了这么一句话，异常抛弃来很烦，为了注重细节……
管道流也许很难理解，其实非也
我们知道，字节流和字符流都需要数组来进行流的中转
而管道流则直接串联两条流，一边发送数据，一边接收
然而，同时通信的的两种状态，如何才能确定发送和接收的一致性呢
那么，就需要用到线程，无论是接收方还是发送方先执行
总会造成一个线程的阻塞状态，从而等待另一方的数据传过来
总体而言，管道流的目的，也就是为了线程通信
此外，还有PipedReader和PipedWriter类，操作原理都一样，这里就不再赘述了
DataOutputStream和DataInputStream类
实例4：基本数据类型的写入
|
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
|
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo {
public static void main(String[] args) {
String path = File.separator + "home" + File.separator + "siu" +
File.separator + "work" + File.separator + "demo.txt";
DataOutputStream d = null;
try {
//此处需要传入一个OutputStream类的对象
d = new DataOutputStream(new FileOutputStream(path));
//开始写入基本数据类型
d.writeInt(12);
d.writeBoolean(true);
d.writeDouble(12.2223);
d.writeChar(97);
//刷新流
d.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
d.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
} |
此处我们并不能直观看懂内容，因为它采用字节流的方式操作，而不是字符流
我们只需要知道，此程序已经将基本数据类型写入到硬盘即可
实例5：基本数据类型的读取
|
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
|
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class Demo {
public static void main(String[] args) {
String path = File.separator + "home" + File.separator + "siu" +
File.separator + "work" + File.separator + "demo.txt";
DataInputStream d = null;
try {
d = new DataInputStream(new FileInputStream(path));
//按存储顺序读取基本数据类型
System.out.println(d.readInt());
System.out.println(d.readBoolean());
System.out.println(d.readDouble());
System.out.println(d.readChar());
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
d.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
} |
这里要注意的是，一定要按照写入顺序读取，否则会发生数据的打印错误
相关推荐
Java IO系统是Java平台标准库中的一个重要组成部分，主要用于处理输入输出操作。Java IO系统主要包括两个包：`java.io`和`java.nio`（New IO），其中`java.io`提供了一系列基于流的I/O操作接口与实现类，而`java.nio...
Java IO操作是Java编程中非常重要的一个部分，它主要用于数据的输入输出，包括从文件、网络、内存等来源获取数据，以及向这些目的地发送数据。本文将对Java IO中的节点流和处理流进行详细的总结。 首先，我们来看...
java中的IO操作总结（一） 所谓IO，也就是Input与Output的缩写。在java中，IO涉及的范围比较大，这里主要讨论针对文件内容的读写 其他知识点将放置后续章节（我想，文章太长了，谁都没耐心翻到最后） 对于文件内容...
在这个总结中，我们将深入探讨Java I/O的几个关键知识点。 首先，我们要理解I/O的基本概念。I/O，即Input/Output，指的是计算机系统与外部设备之间交换数据的过程。在Java中，I/O操作主要涉及到java.io包中的类和...
### Java IO操作总结 Java IO（输入/输出）是Java编程语言中用于处理数据输入和输出的核心机制。本文档全面总结了Java IO的各种操作，旨在为开发者提供一个深入理解并熟练掌握Java IO技术的资源。 #### 一、临时...
Java IO完全总结的知识点: 一、历史背景： 1. IO系统设计的困难性：对于编程语言设计人员来说，设计一个功能完善的输入输出系统是非常有挑战性的。需要考虑各种不同的因素，如文件、控制台、网络、内存等的读取方式...
在这篇总结中，我们将探讨Java IO操作的各个方面，包括File类、RandomAccessFile类、字节流与字符流的基本操作，以及具体实现文件读写的技术细节。 首先，File类在Java IO操作中扮演着重要角色。它提供了关于文件和...
Java IO流总结 Java IO流是Java语言中最基本和最重要的输入/输出机制，负责将数据从外部世界输入到Java应用程序中或将数据从Java应用程序输出到外部世界。IO流可以分为两大类：字节流和字符流。 1. 节点流：离数据...
总结来说，Java IO流是一个庞大的体系，覆盖了从基础的文件操作到复杂的网络通信，理解并熟练掌握这一部分将极大地提升Java开发者的技能。通过学习和实践，开发者可以灵活地处理各种数据输入输出场景，为应用程序...
为了提高IO操作的效率，Java提供了缓冲流，如`BufferedInputStream`和`BufferedOutputStream`，以及`BufferedReader`和`BufferedWriter`。这些类在内部维护了一个缓冲区，可以减少实际的物理I/O次数。 五、转换流...
### JAVA IO操作总结——节点流和处理流 #### 一、概述 在Java中，输入/输出（Input/Output，简称IO）操作是一项非常重要的功能，它涉及到如何从不同的源读取数据以及如何向不同的目的地写入数据。Java IO体系主要...
在深入探讨`java.io.Reader`与`java.io.InputStream`的具体差异之前，我们首先需要理解这两者在Java I/O操作中的基础角色。`java.io.Reader`和`java.io.InputStream`是Java标准库中处理输入数据的核心类，它们分别...
### Java IO流详解 #### 一、概述 Java的I/O操作主要涉及使用Java语言进行输入和输出操作。Java的所有I/O机制都是基于数据流来进行输入输出，这些数据流表示了字符或字节数据的流动序列。理解Java的I/O模型对于...
下面是对Java IO流的详细总结： 1. 流的概念： 流是一种抽象的数据传输方式，可以将数据从一个地方传输到另一个地方。Java中的流分为输入流和输出流，分别用于读取和写入数据。流按照处理数据的不同类型，又可以...
传统的Java IO是阻塞的，即在进行IO操作时，程序会一直等待数据准备完成。而NIO引入了选择器（Selector）和通道（Channel）的概念，允许单线程同时处理多个连接，提高了服务器的并发能力。NIO的关键在于其非阻塞模式...
例如，javaio.bmp和javaio2.bmp可能是两张展示IO框架图的图片，其中详细描绘了不同类之间的继承关系和使用场景，帮助开发者更好地理解和掌握Java IO系统。 总结一下，Java IO框架是Java平台不可或缺的一部分，它为...