具体的代码实现和技巧确实是从哪个不知名的站点找到的，内容是自己测试排版弄出来的，推广知识而已
对象的序列化是指对象实现接口java.io.Serializable
第一个示例
package com.serializable.test;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
class Student1 implements Serializable {
private static final long serialVersionUID = -2193347404055790145L;
public int studentid;
public static String studentName;
}
/**
* @author Administrator
*
*正常使用对象的系列化，对象用于对象流在文件中的输入输出
*/
public class ObjectIO1{
/**
* @param args
*/
public static void main(String[] args) {
ObjectIO1 io = new ObjectIO1();
try {
io.write();
io.read();
} catch (Exception e) {
e.printStackTrace();
}
}
public void write() throws Exception {
Student1 s = new Student1();
s.studentid = 10;
s.studentName = "JJOY";
FileOutputStream fileOutputStream = new FileOutputStream("xxxx");
ObjectOutputStream oos = new ObjectOutputStream(fileOutputStream);
oos.writeObject(s);
oos.close();
}
public void read() throws Exception {
FileInputStream fileInputStream = new FileInputStream("xxxx");
ObjectInputStream ois = new ObjectInputStream(fileInputStream);
Object o = ois.readObject();
if (o instanceof Student1) {
Student1 s = (Student1) o;
System.out.println(s.studentid);//返回10
System.out.println(s.studentName);//返回JJOY
}
ois.close();
}
}
输出结果是10
JJOY
第二个示例
package com.serializable.test;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/**
* @author Administrator
*
*对象的序列化时类的静态属性不和某个具体的的对象绑定在一起，
*后来通过类直接对属性重新复制，取出来得值是后面赋的新值
*
*/
public class ObjectIO2 {
/**
* @param args
*/
public static void main(String[] args) {
ObjectIO2 io = new ObjectIO2();
try {
io.write();
io.read();
} catch (Exception e) {
e.printStackTrace();
}
}
public void write() throws Exception {
Student2 s = new Student2();
s.studentid = 10;
s.studentName = "中文名";//某个具体对象属性的赋值，但这是类的静态属性
FileOutputStream fileOutputStream = new FileOutputStream("xxxx");
ObjectOutputStream oos = new ObjectOutputStream(fileOutputStream);
oos.writeObject(s);
oos.close();
}
public void read() throws Exception {
FileInputStream fileInputStream = new FileInputStream("xxxx");
ObjectInputStream ois = new ObjectInputStream(fileInputStream);
Object o = ois.readObject();
if (o instanceof Student2) {
Student2 s = (Student2) o;
Student2.studentName = "王小二";//后来通过类直接对属性重新复制
System.out.println(s.studentid);
System.out.println(s.studentName);//取出来得值是后面赋的新值
}
ois.close();
}
}
class Student2 implements Serializable {
private static final long serialVersionUID = -2193347404055790145L;
public int studentid;
public static String studentName;
}
运行结果
10
王小二
示例3
package com.serializable.test;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/**
*
* @author Administrator
* 理解transient关键字的作用，对类的属性加上transient关键字， transient是临时保持值（瞬间值），
* 对象序列化时不能对其中的属性进行序列化，对其中的属性重新赋值也是无效的，这样有利于数据在网路上的传输，
* 尤其是设计账号和密码之类的安全性问题，即使在初始化对studentid赋值为5之类的，最终输出仍然是0
*
*/
class Student3 implements Serializable {
private static final long serialVersionUID = -2193347404055790145L;
public transient int studentid=5;// 在对象序列化时不能对studentid属性进行序列化
public static String studentName;
}
public class ObjectIO3 {
/**
* @param args
*/
public static void main(String[] args) {
ObjectIO3 io = new ObjectIO3();
try {
io.write();
io.read();
} catch (Exception e) {
e.printStackTrace();
}
}
public void write() throws Exception {
Student3 s = new Student3();
s.studentid = 10;//对其中的属性重新赋值也是无效的
s.studentName = "中文名";
FileOutputStream fileOutputStream = new FileOutputStream("xxxx");
ObjectOutputStream oos = new ObjectOutputStream(fileOutputStream);
oos.writeObject(s);
oos.close();
}
public void read() throws Exception {
FileInputStream fileInputStream = new FileInputStream("xxxx");
ObjectInputStream ois = new ObjectInputStream(fileInputStream);
Object o = ois.readObject();
if (o instanceof Student3) {
Student3 s = (Student3) o;
Student3.studentName = "王小二";
System.out.println(s.studentid);//这里的运行结果是0
System.out.println(s.studentName);//王小二
}
ois.close();
}
}
运行结果
0
王小二
示例4
package com.serializable.test;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
class People {//这个类没有实现Serializable接口
public int age;
public People() {
System.out.println("People1");
}
}
class Student extends People implements Serializable {
public transient int studentId = 5;
public static String studentName;
public int marks ;//学生分数
public Student() {
System.out.println("Student2");
}
}
/**
* Peope类没有实现Serializable接口，故向文件写入对象时，没有完成people对象的序列化工作，再从文件中读取对象，需要对对象
* 的属性重新初始化工作，故后来打印再次打印people,打印出学生的年龄是0。
* @author Administrator
*
*/
public class ObjectIO4 {
public void write() throws Exception {
Student s = new Student();
s.studentId = 10;
s.age = 20;
s.studentName = "名字name";
s.marks =80;
FileOutputStream fos = new FileOutputStream("XXXX");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(s);
oos.close();
}
public void read() throws Exception {
FileInputStream fis = new FileInputStream("XXXX");
ObjectInputStream ois = new ObjectInputStream(fis);
Object o = ois.readObject();
Student.studentName = "王小二";
if (o instanceof Student) {
Student s = (Student) o;
System.out.println("学生的学号:" + s.studentId);//0
System.out.println("学生的姓名:" + s.studentName);//王小二
System.out.println("学生的成绩:" + s.marks);//80
System.out.println("学生的年龄:" + s.age);//0
}
ois.close();
}
public static void main(String[] args) {
try {
ObjectIO4 oo = new ObjectIO4();
oo.write();
oo.read();
} catch (Exception e) {
e.printStackTrace();
}
}
}
注意这次的输出结果
People1
Student2
People1
学生的学号：0
学生的姓名：王小二
学生的成绩：80
学生的年龄：0
示例5
package com.serializable.test;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/**
* Peope2类没有实现Serializable接口，向文件写入对象时，
* 没有完成该类对象的序列化工作，在从文件中读取对象，需要对对象的
* 属性重新初始化工作，故后来打印再次打印People,打印出学生的年龄是25。
* @author Administrator
*
*/
class People2 {
public int age;
public People2() {
age = 25;
System.out.println("People");
}
}
class Student4 extends People2 implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
public transient int studentId = 5;
public static String studentName;
public Student4() {
System.out.println("Student");
}
}
public class ObjectIO5 {
public void write() throws Exception {
Student4 s = new Student4();
s.studentId = 10;
s.age = 20;
s.studentName = "justName";
FileOutputStream fos = new FileOutputStream("XXXX");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(s);
oos.close();
}
public void read() throws Exception {
FileInputStream fis = new FileInputStream("XXXX");
ObjectInputStream ois = new ObjectInputStream(fis);
Object o = ois.readObject();
Student4.studentName = "王二小";
if (o instanceof Student4) {
Student4 s = (Student4) o;
System.out.println("学生的学号:" + s.studentId);//0
System.out.println("学生的姓名:" + s.studentName);
System.out.println("学生的年龄:" + s.age);//25
}
ois.close();
}
public static void main(String[] args) {
try {
ObjectIO5 oo = new ObjectIO5();
oo.write();
oo.read();
} catch (Exception e) {
e.printStackTrace();
}
}
}
输出结果
People
Student
People -- 再次初始化，构造方法里打印的字符串
学生的学号:0
学生的姓名:王二小
学生的年龄:25--使用构造方法里定义的属性初始化对象，然后打印25
示例6
package com.serializable.test;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/**
* Peope3类实现Serializable接口向文件写入对象时，
* 完成people3对象的序列化工作，在从文件中读取对象，无需要对对象的属性重新
* 初始化工作,打印出学生的年龄是20。即使在People类添加age=50这样的语句，
* 最终输出年龄的值任然是20，因为后来没有再次初始化People类
* @author Administrator
*
*/
class People3 implements Serializable {
public int age=50;//在People类添加age=50的赋值，但是在将对象写入文件前，修改了一次属性
public People3() {
System.out.println("People");
}
}
class Student5 extends People3 {
public transient int studentId = 5;
public static String studentName;
public Student5() {
System.out.println("Student");
}
}
public class ObjectIO6 {
public void write() throws Exception {
Student5 s = new Student5();
s.studentId = 10;
s.age = 20;//对象写入文件前先修改了值
s.studentName = "xxxx";
FileOutputStream fos = new FileOutputStream("XXXX");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(s);
oos.close();
}
public void read() throws Exception {
FileInputStream fis = new FileInputStream("XXXX");
ObjectInputStream ois = new ObjectInputStream(fis);
Object o = ois.readObject();
Student5.studentName = "王二小";
if (o instanceof Student5) {
Student5 s = (Student5) o;
System.out.println("学生的学号:" + s.studentId);
System.out.println("学生的姓名:" + s.studentName);
System.out.println("学生的年龄:" + s.age);//20，假如再次初始化对象，则输出为50
}
ois.close();
}
public static void main(String[] args) {
try {
ObjectIO6 oo = new ObjectIO6();
oo.write();
oo.read();
} catch (Exception e) {
e.printStackTrace();
}
}
}
输出结果
People
Student---这里没有再打印People 说明没有再次初始化
学生的学号:0
学生的姓名:王二小
学生的年龄:20
分享到：
相关推荐
实现 `Serializable` 接口后，可以通过 `java.io.ObjectOutputStream` 将对象写入文件或通过网络传输，也可以使用 `java.io.ObjectInputStream` 从文件读取对象或将对象从网络接收。 #### 三、序列化过程 序列化的...
这里有几个关键点需要注意： 1. **访问修饰符**：建议将`serialVersionUID`定义为`private`，因为此字段只适用于当前声明的类。 2. **final关键字**：`serialVersionUID`必须是`final`的，表示它是不可更改的。 3. ...
### Java JDK IO包类详解 #### 概述 Java平台提供的`io`包为开发者提供了访问文件系统、对象序列化等功能的基本输入输出能力。它主要包括字节流、字符流及对象流（字节流的包装类）。此外，还提供了一些基本的文件...
序列化的过程可以分为几个简单的步骤： 1. **创建文件输出流(FileOutputStream)**：首先需要创建一个指向序列化文件的输出流。 ```java FileOutputStream fs = new FileOutputStream("foo.ser"); ``` 2. **创建...
Java IO体系结构主要由以下几个核心部分组成： 1. **流(Streams)**：Java IO的核心概念是流，它们代表数据的源和目的地。流可以是字节流或字符流，分为输入流和输出流。字节流处理单个字节的数据，而字符流处理...
在Java中，如果一个类需要支持序列化，那么该类需要实现`java.io.Serializable`接口，虽然这个接口没有定义任何方法，但是它的存在作为一个标记，表明该类的对象可以被序列化。 序列化的优点主要有以下几点： 1. **...
### Java序列化(Serializable)与反序列化详解 #### 序列化概念与应用场景 序列化是指将程序中的对象转换为一系列字节序列的过程，主要用于保存对象的状态以便将来使用或者在网络之间传输对象。Java提供了内置的...
在Java中，如果一个类实现了`Serializable`接口，那么该类的对象就可以被序列化。序列化的目的是为了能够持久地保存对象的状态，或者在网络中传递对象。 序列化主要关注的是对象的状态（即其实例变量），而不是其...
2. 用 JAVA 实现一种排序，JAVA 类实现序列化的方法（二种）：可以使用 Arrays.sort() 方法或 Collections.sort() 方法来实现排序，实现序列化可以通过实现 java.io.Serializable 接口或 Externalizable 接口。...
Java序列化主要有以下几个应用场景： 1. 保存对象的状态：当需要将内存中的对象保存到文件或数据库中，以便后续恢复使用。 2. 网络传输：在网络通信中，可以通过序列化将对象转换为字节流，然后通过Socket进行传输。...
在实现过程中，我们需要注意几个关键点： 1. 类必须实现Serializable接口，否则Java不会允许序列化。 2. 需要谨慎处理静态字段，因为它们不会随着对象一起序列化。 3. 反序列化时，确保类的定义与序列化时的版本一致...
3.6.12 java.io .Serializable Permission 39 3.6.13 java.security.Security Permission 39 3.6.14 java.security.AllPermission 40 3.6.15 许可权隐含中的隐含 40 3.7 分配许可权 41 3.8 Protection Domain 42 ...
下面将详细介绍Java IO的几个关键知识点。 1. **流的概念**： - Java中的IO操作基于流的概念，流是数据传输的抽象表示，可以是字符流或字节流。字符流用于处理文本数据，而字节流则适用于所有类型的数据，包括图像...
3.6.12 java.io .Serializable Permission 39 3.6.13 java.security.Security Permission 39 3.6.14 java.security.AllPermission 40 3.6.15 许可权隐含中的隐含 40 3.7 分配许可权 41 3.8 Protection Domain 42 ...
### Java IO性能优化 #### 4.1 基本IO操作 在Java开发中，`java.io`包是处理输入输出操作的核心组件。虽然它旨在简化开发人员的工作流程，但初学者常常会因为不了解其内部机制而做出降低IO性能的选择。通过深入...
对象序列化主要有以下几个用途： 1. **持久化数据**：将对象的状态保存到文件或数据库中，以便在程序下次运行时可以恢复这些状态。 2. **跨网络传输**：在网络通信中，可以将对象序列化为字节流，然后在网络上传输，...
### Java IO概述 Java IO（Input/Output）是Java编程语言中用于处理输入输出操作的基础模块之一。IO操作是任何程序的重要组成部分，因为几乎所有应用程序都需要读取或写入数据。Java IO提供了丰富的类和接口来处理...
在这个总结中，我们将深入探讨Java I/O的几个关键知识点。 首先，我们要理解I/O的基本概念。I/O，即Input/Output，指的是计算机系统与外部设备之间交换数据的过程。在Java中，I/O操作主要涉及到java.io包中的类和...
Java是一种广泛使用的面向对象的编程语言，其面试题涵盖了众多的知识点，包括基础语法、面向对象特性、内存管理、集合框架、多线程、异常处理、IO流、网络编程等。以下是一些常见且重要的面试题及其解答： 1. **...