java序列化对象的存储
‘壹’ java中对象的序列化
好像没有什么关系把，某个对象需要序列化，这个对象的类实现java.io.Serializable即可，此接口中没有任何需要覆盖的方法。如果硬说跟哪个流有关系，应该是这两个吧java.io.ObjectOutputStream，java.io.ObjectInputStream，这两个流可以直接操作对象（比如Person对象），像你上面说的流只能操作数据，而不能是对象的，这两个对象是对应的，一个是写对象，一个是读对象。
什么时候用序列化？
一般我们的对象是在堆内存中的，不是持久化存储，而你需要持久化存储（即存到硬盘上），等待下次继续来读取这个对象来操作，这时候就需要把这个Person类实现序列化接口java.io.Serializable，java.io.ObjectOutputStream，java.io.ObjectInputStream来读写，用你用你说的那些流是无法做到的。另外，如果你的对象需要在网络上传来传去的，也需要序列化。
纯手工打，本人也是初学，解释的不好还请见谅！
‘贰’ java定制序列化存储（求助）
//你可以把所有的User存到一个ArrayList里再把list序列存储
import java.io.Externalizable;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
public class UserSer {
private static FileOutputStream fos = null;
private static ObjectOutputStream oos = null;
private static FileInputStream fis = null;
private static ObjectInputStream ois = null;
public static boolean writeObj(String path, Object obj) {
boolean sec = false;
try {
fos = new FileOutputStream(path);
oos = new ObjectOutputStream(fos);
oos.writeObject(obj);
oos.flush();
oos.close();
fos.close();
sec = true;
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return sec;
}
public static Object readObj(String path) {
Object obj = null;
try {
fis = new FileInputStream(path);
ois = new ObjectInputStream(fis);
obj = ois.readObject();
ois.close();
fis.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return obj;
}
@SuppressWarnings("unchecked")
public static void main(String[] args) {
ArrayList<User>list = new ArrayList<User>();
User u1 = new User("tiger", 25);
User u2 = new User("aaron", 32);
list.add(u1);
list.add(u2);
String path = "Ser.tmp";
UserSer.writeObj(path, list);
list = null;
list = (ArrayList<User>)UserSer.readObj(path);
for(int i = 0; i < list.size(); i ++) {
System.out.println(list.get(i));
}
}
}
class User implements Externalizable {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public User() {
}
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String toString() {
return "我叫" + this.getName() + "," + this.getAge() + "岁";
}
private static final long serialVersionUID = 1L;
public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException {
String name = (String)in.readObject();
this.setName(name);
int age = in.readInt();
this.setAge(age);
}
public void writeExternal(ObjectOutput out) throws IOException {
out.writeObject(this.getName());
out.writeInt(this.getAge());
}
}
‘叁’ java 对象序列化 可以保存static成员，为什么
对象
序列化
后会保存所有的对象的类型和数据域，static修饰应该理解为为该类所有对象共享的一块内存空间，序列化结果我理解是，在b被改变后会出现不同的版本，如果不想将其序列化，应该像c一样标示为
transient
！
‘肆’ java序列化问题以及怎么存储一个类对象
这不是乱码，这是正常现象，只要重新加载到java程序中（反序列化），对象才能用。
‘伍’ java中如何实现序列化，有什么意义
首先我们要把准备要序列化类，实现 Serializabel接口
例如：我们要Person类里的name和age都序列化
import java.io.Serializable;
public 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 "姓名：" + this.name + "，年龄" + this.age ;
}
}
然后：我们将name和age序列化（也就是把这2个对象转为二进制，统族理解为“打碎”）
package org.lxh.SerDemo;
import java.io.File;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream ;
public class ObjectOutputStreamDemo { //序列化
public static void main(String[] args) throws Exception {
//序列化后生成指定文件路径
File file = new File("D:" + File.separator + "person.ser") ; ObjectOutputStream oos = null ;
//装饰流（流）
oos = new ObjectOutputStream(new FileOutputStream(file)) ;
//实例化类
Person per = new Person("张三",30) ; oos.writeObject(per) ;//把类对象序列化
oos.close() ;
}
}
‘陆’ java 可序列化保存问题
可以参看一下sun的demo里面的styledpad，里面用的方法跟你用的大同小异，别听那些刷分的刷子，什么也不懂就吹大牛，包含了组件、图片等内容的对象，最好的方法就是直接存对象了，每次存的时候把不可序列化的东西移除再存，存完再加回来就好了。
‘柒’ java笔试题：序列化是什么：Java 序列化如何实现
序列化
(Serialization)将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象
实现就直接实现Serializable接口
‘捌’ 什么是java序列化，如何实现java序列化
序 列 化: 指把堆内存中的Java对象数据,通过某种方式把对象存储到磁盘文件中或者传递给其他网络的节点(在网络上传输).我们把这个过程称之为序列化.
反序列化:把磁盘文件中的对象数据或者把网络节点上的对象数据,恢复成Java对象的过程.
为什么要做序列化:
1):在分布式系统中,需要共享的数据的JavaBean对象,都得做序列化,此时需要把对象再网络上传输,此时就得把对象数据转换为二进制形式.以后存储在HttpSession中的对象,都应该实现序列化接口(只有实现序列化接口的类,才能做序列化操作).
2):服务钝化:如果服务发现某些对象好久都没有活动了,此时服务器就会把这些内存中的对象,持久化在本地磁盘文件中(Java对象-->二进制文件).如果某些对象需要活动的时候,现在内存中去寻找,找到就使用,找不到再去磁盘文件中,反序列化我们得对象数据,恢复成Java对象.
需要做序列化的对象的类,必须实现序列化接口:java.io.Serializable接口(标志接口[没有抽象方法]).
底层会判断,如果当前对象是Serializable的实例,才允许做序列化. boolean ret = Java对象 instanceof Serializable;
在Java中大多数类都已经实现Serializable接口.
‘玖’ java中为什么要进行对象序列化
序列化就是将一个对象的状态（各个属性量）保存起来，然后在适当的时候再获得。
序列化分为两大部分：序列化和反序列化。序列化是这个过程的第一部分，将数据分解成字节流，以便存储在文件中或在网络上传输。反序列化就是打开字节流并重构对象。对象序列化不仅要将基本数据类型转换成字节表示，有时还要恢复数据。恢复数据要求有恢复数据的对象实例
序列化的什么特点：
如果某个类能够被序列化，其子类也可以被序列化。声明为static和transient类型的成员数据不能被序列化。因为static代表类的状态， transient代表对象的临时数据。
什么时候使用序列化：
一：对象序列化可以实现分布式对象。主要应用例如：RMI要利用对象序列化运行远程主机上的服务，就像在本地机上运行对象时一样。
二：java对象序列化不仅保留一个对象的数据，而且递归保存对象引用的每个对象的数据。可以将整个对象层次写入字节流中，可以保存在文件中或在网络连接上传递。利用对象序列化可以进行对象的"深复制"，即复制对象本身及引用的对象本身。序列化一个对象可能得到整个对象序列。
‘拾’ 如何理解Java对象的序列化
Java平台允许我们在内存中创建可复用的Java对象，但一般情况下，只有当JVM处于运行时，这些对象才可能存在，即，这些对象的生命周期不会比JVM的生命周期更长。但在现实应用中，就可能要求在JVM停止运行之后能够保存(持久化)指定的对象，并在将来重新读取被保存的对象。Java对象序列化就能够帮助我们实现该功能。
使用Java对象序列化，在保存对象时，会把其状态保存为一组字节，在未来，再将这些字节组装成对象。必须注意地是，对象序列化保存的是对象的"状态"，即它的成员变量。由此可知，对象序列化不会关注类中的静态变量。