经过核实后将会做出处理，感谢您为社区和谐做出贡献。
请选择删除原因
确定推荐该回答？
怎么从文件还原序列化对象
在Android开发的过程中，针对对象的序列化推荐使用Parcelable，而不是Seralizable，因为Parceable的效率比较高。这样，针对Android中大量的对象，手写实现Parcelable的代价，就比较高了。楼主github上发现一个针对Intelij和AndroidStudio的Parcelable的插件，只需集成，然后直接快捷键，实现Parcelable的接口，这样不是很爽么？。。。1. Parcelable插件地址：2.下载地址： /releases/tag/0.6.13. 按照文档说明，在IDE的Plugins中导入对应插件的Jar包，重启，就集成好了。4. 快捷键的问题，楼主在集成后，发现对应文档所说的 ALT + Insert 不起作用，这样就需要重新设定一下了。进入IDE中keymaps中，搜索Parcelable，设定快捷键，楼主设定Ctrl+cmd+P . 在对应的Model类中，敲一下快捷键，一切Ok。PS： 楼主发现这个插件，针对List的数据，支持的不是很完美，有两个问题：1）List&String&类型的数据: 在使用Parcelable读取数据的时候，可以直接调用Parcel的readStringList(Params) 来进行读取，其中的Params,是指你需要指定一个新的，初始化之后List&String& 的数据，2）List&Object&类型的数据：Object是指你自定义的数据，你可以先对Object实现Parcelable接口，这样它会针对这种生成readTypedList的方法，但你在使用这个方法时，需要对List数据进行初始化，如下所示：if(nodes == null)nodes = new ArrayList&PoiVO&();in.readTypedList(nodes, PoiVO.CREATOR);3） List&List&Object&&类型的数据： 使用下面的代码就可以了：this.route = new ArrayList&List&PoiVO&&();in.readList(this.route, null);原网址：序列化_百度百科
清除历史记录关闭
声明：百科词条人人可编辑，词条创建和修改均免费，绝不存在官方及代理商付费代编，请勿上当受骗。
序列化 (Serialization)将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。序列化使其他代码可以查看或修改，那些不序列化便无法访问的对象实例数据。确切地说，代码执行序列化需要特殊的权限：即指定了 SerializationFormatter 标志的 SecurityPermission。在默认策略下，通过 Internet 下载的代码或 Internet 代码不会授予该权限；只有本地计算机上的代码才被授予该权限。通常，对象实例的所有都会被序列化，这意味着数据会被表示为实例的序列化数据。这样，能够解释该格式的代码有可能能够确定这些数据的值，而不依赖于该成员的可访问性。类似地，反序列化从序列化的表示形式中提取数据，并直接设置对象状态，这也与可访问性规则无关。对于任何可能包含重要的安全性数据的对象，如果可能，应该使该对象不可序列化。如果它必须为可序列化的，请尝试生成特定字段来保存不可序列化的重要数据。如果无法实现这一点，则应注意该数据会被公开给任何拥有序列化权限的代码，并确保不让任何恶意代码获得该权限。
序列化目的
1、以某种存储形式使自定义；
2、将对象从一个地方传递到另一个地方。
3、使程序更具维护性。
序列化技术
* 二进制序列化保持类型保真度，这对于在应用程序的不同调用之间保留对象的状态很有用。例如，通过将对象序列化到剪贴板，可在不同的应用程序之间共享对象。您可以将对象序列化到流、磁盘、内存和网络等等。使用序列化“通过值”在计算机或之间传递对象。
* XML 序列化仅序列化公共属性和字段，且不保持类型保真度。当您要提供或使用数据而不限制使用该数据的应用程序时，这一点是很有用的。由于 XML 是一个开放式标准，因此，对于通过 Web 共享数据而言，这是一个很好的选择。SOAP 同样是一个开放式标准，这使它也成为一个颇具吸引力的选择。
注: 在 php 3 中，在序列化和解序列化的过程中对象会失去类的关联。结果的变量是对象类型，但是没有类和方法，因此就没什么用了（就好像一个用滑稽的语法定义的数组一样）。
serialize() 返回一个，包含着可以储存于 php 的任何值的表示。unserialize() 可以用此字符串来重建原始的。用序列化来保存对象可以保存对象中的所有变量。对象中的函数不会被保存，只有类的名称。
要能够 unserialize() 一个对象，需要定义该对象的类。也就是，如果序列化了 page1.php 中类 A 的对象 $a，将得到一个指向类 A 的字符串并包含有所有 $a 中变量的值。如果要在 page2.php 中将其解序列化，重建类 A 的对象 $a，则 page2.php 中必须要出现类 A 的定义。例如可以这样实现，将类 A 的定义放在一个包含文件中，并在 page1.php 和 page2.php 都包含此文件。
&?php// classa.inc: class A { var $one = 1; function show_one() { echo $this-& } }// page1.php: include(&classa.inc&); $a = new A; $s = serialize($a); // 将 $s 存放在某处使 page2.php 能够找到 $fp = fopen(&store&, &w&); fwrite($fp, $s); fclose($fp);// page2.php: // 为了正常解序列化需要这一行 include(&classa.inc&); $s = implode(&&, @file(&store&)); $a = unserialize($s); // 现在可以用 $a 对象的 show_one() 函数了 $a-&show_one();?&
如果在用会话并使用了 session_register() 来注册对象，这些对象会在每个 php 页面结束时被自动序列化，并在接下来的每个页面中自动解序列化。基本上是说这些对象一旦成为会话的一部分，就能在任何页面中出现。
强烈建议在所有的页面中都包括这些注册的对象的类的定义，即使并不是在所有的页面中都用到了这些类。如果没有这样做，一个对象被解序列化了但却没有其类的定义，它将失去与之关联的类并成为 stdClass 的一个对象而完全没有任何可用的函数，这样就很没有用处。
因此如果在以上的例子中 $a 通过运行 session_register(&a&) 成为了会话的一部分，应该在所有的页面中包含 classa.inc 文件，而不只是 page1.php 和 page2.php。
清除历史记录关闭CArchive类对文件进行读写操作《序列化》
CArchive类是一种新的对文件的读定操作方式.它没有基类。
我们知道，一个对象一旦被构造，它就存活于内存中了，当其生命周期结束之后，该对象就要被销毁。那么该如何永久保存该对象呢，即在程序再次打开后，程序能够重新构建相应的对象，还原该对象以前的动作(当然首先这个对象类要有动态创建的功能)。
CArchive类就是可以将对象永久保存在磁盘中，它的这种功能叫做串行化或序列化。
CArchive类不仅可以处理基本类型的数据，还可以处理CObject类的派生类对象。它重载了&&(插入)和&&（提取）操作符。
CArchive类的使用方法：
1、创建一个CFile类或者其派生类对象,且该文件的操作方式（读，写）要与CArchive对象的操作方式一致.
2、此时再构建一个CArchive对象,并将其与CFile对象关联起来.
3、此时就可以对CArchive对象进行读写操作了，数据类型可以不一样。
4、当进行读取数据时，要保持和写入数据时的顺序一致.
file("file.txt",CFile::modeCreate|CFile::modeWrite); //写入文件
ar(&file,CArchive::store);&
//关联文件，同时操作方式一致，都是存文件
&char ch='a';
&float f=1.3f;
&CString str("dfasdaf");
&ar&&i&&ch&&f&&&&
//将不同内容的数据写入文件file.txt中.
CFile file("file.txt",CFile::modeRead); //读出文件内容
ar(&file,CArchive::load);&
//关联文件，同时操作方式一致，都是读出文件内容
ar&&m&&l&&fl&&&&
//将不同内容的数据从文件file.txt中读取出来,但一定要保证读出与写入时数据类型
&&&&&&&&&&&&&&&&&&&&
//的数据顺序要一致,要不然读出的数据就会不正确,例如将字符串内容放入整型变量时
&&&&&&&&&&&&&&&&&&&&
//值是不一样的.
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。java源码：import java.io.*;
public class LoginUser { private S private S public String getUsername() { } public void setUsername(String username) {
this.username = } public String getPasswd() { } public void setPasswd(String passwd) {
this.passwd = }
public static void main(String[] args){
LoginUser loginUser = new LoginUser();
loginUser.setUsername("50");
loginUser.setPasswd("30");
FileOutputStream fs = new FileOutputStream("foo.ser");
ObjectOutputStream os =
new ObjectOutputStream(fs);
os.writeObject(loginUser);
os.close();
}catch(Exception ex){
ex.printStackTrace();
报错如下：
java.io.NotSerializableException: com.longshine.zwp.test.LoginUser at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1081) at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:302) at com.longshine.zwp.test.LoginUser.main(LoginUser.java:29)
类的定义改成如下：
public class LoginUser implements Serializable{
则可以保存下来内存中的java对象。
1、序列化是干什么的？
简单说就是为了保存在内存中的各种对象的状态（也就是实例变量，不是方法），并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保存object states，但是Java给你提供一种应该比你自己好的保存对象状态的机制，那就是序列化。2、什么情况下需要序列化
a）当你想把的内存中的对象状态保存到一个文件中或者数据库中时候；
b）当你想用套接字在网络上传送对象的时候；
c）当你想通过RMI传输对象的时候；3、当对一个对象实现序列化时，究竟发生了什么？
在没有序列化前，每个保存在堆（Heap）中的对象都有相应的状态（state），即实例变量（instance ariable）比如：
myFoo = new Foo();
myFoo .setWidth(37);
myFoo.setHeight(70);
当 通过下面的代码序列化之后，MyFoo对象中的width和Height实例变量的值（37，70）都被保存到foo.ser文件中，这样以后又可以把它 从文件中读出来，重新在堆中创建原来的对象。当然保存时候不仅仅是保存对象的实例变量的值，JVM还要保存一些小量信息，比如类的类型等以便恢复原来的对 象。
FileOutputStream fs = new FileOutputStream("foo.ser");
ObjectOutputStream os = new ObjectOutputStream(fs);
os.writeObject(myFoo);
4、实现序列化（保存到一个文件）的步骤
a）Make a FileOutputStream
b）Make a ObjectOutputStream
FileOutputStream fs = new FileOutputStream("foo.ser");
ObjectOutputStream os =
new ObjectOutputStream(fs);
c）write the object
os.writeObject(myObject1);
os.writeObject(myObject2);
os.writeObject(myObject3);
d) close the ObjectOutputStream
os.close();
5、举例说明6、相关注意事项
a）序列化时，只对对象的状态进行保存，而不管对象的方法；
b）当一个父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口；
c）当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化；
d）并非所有的对象都可以序列化，,至于为什么不可以，有很多原因了,比如：
1.安全方面的原因，比如一个对象拥有private，public等field，对于一个要传输的对象，比如写到文件，或者进行rmi传输
等等，在序列化进行传输的过程中，这个对象的private等域是不受保护的。
2. 资源分配方面的原因，比如socket，thread类，如果可以序列化，进行传输或者保存，也无法对他们进行重新的资源分
配，而且，也是没有必要这样实现。
import java.io.*;
public class LoginUser implements Serializable{ /**
*/ private static final long serialVersionUID = -7471820L; private S private S public String getUsername() { } public void setUsername(String username) {
this.username = } public String getPasswd() { } public void setPasswd(String passwd) {
this.passwd = }
public static void save() {
LoginUser loginUser = new LoginUser();
loginUser.setUsername("50");
loginUser.setPasswd("30");
FileOutputStream fs = new FileOutputStream("loginuser.txt");
ObjectOutputStream os = new ObjectOutputStream(fs);
os.writeObject(loginUser);
os.flush();
os.close();
} catch (Exception ex) {
ex.printStackTrace();
public static void read() {
FileInputStream fs = new FileInputStream("loginuser.txt");//("foo.ser");
ObjectInputStream ois = new ObjectInputStream(fs);
LoginUser loginUser = (LoginUser) ois.readObject();
System.out.println(loginUser.getUsername() + "----"
+ loginUser.getPasswd());
ois.close();
} catch (Exception ex) {
ex.printStackTrace();
public static void main(String[] args){
序列化、反序列化为XML文件，使用XStream来序列化，需要引入xstream-1.3.1.jar包的支持，http://xstream.codehaus.org/download.html
处可以下载jar，然后引入到Eclipse中的build path中。Serialize.java的代码如下：import java.io.FileInputSimport java.io.FileNotFoundEimport java.io.FileOutputSimport com.thoughtworks.xstream.*;public class Serialize {
public static void main(String[] args) {
Serialize ser = new Serialize();
ser.serializeToXml();
ser.deSerializeFromXml();
public void serializeToXml(){
Person[] myPerson = new Person[2];
myPerson[0] = new Person("Jay",24);
myPerson[1] = new Person("Tom",23);
XStream xstream = new XStream();
FileOutputStream fos = new FileOutputStream("E:\\workspace\\2010_03\\src\\myPerson.xml");
xstream.toXML(myPerson,fos);
} catch (FileNotFoundException ex) {
ex.printStackTrace();
System.out.println(xstream.toXML(myPerson));
public void deSerializeFromXml(){
XStream xs = new XStream();
Person[] myPerson =
FileInputStream fis = new FileInputStream("E:\\workspace\\2010_03\\src\\myPerson.xml");
myPerson=(Person[])xs.fromXML(fis);
if (myPerson != null)
int len = myPerson.
for (int i=0;i&i++)
System.out.println(myPerson[i].getName());
System.out.println(myPerson[i].getAge());
} catch (FileNotFoundException ex) {
ex.printStackTrace();
}}运行结果为（console输出），当然可以查看到myPerson.xml文件已经生成：Inside Person's ConstructorInside Person's Constructor&Person-array&
&name&Jay&/name&
&age&24&/age&
&name&Tom&/name&
&age&23&/age&
&/Person&&/Person-array&Jay24Tom23
浏览 13741
regedit_123
浏览: 248377 次
来自: 杭州
引用[u][/u]
[flash=200,200][flash=200,200][ ...
星水冰云 写道 帮了我大忙了 我这都五年前的文章了，能够帮上真 ...
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'博客分类：
这几天上班看了点java的基础知识点，看到介绍序列化的基本问题是都是以介绍序列化一个和反序列化一个对象为例的，依此就想到了要是序列化一次多个序列化对象，再或者不同时间多次序列化对象怎么做，于是动手试了下，发现了不少问题，由于是小菜搞了好久上网找，才得以解决问题，废话不多说了，下面直接进入正题。
&&&& （一）.java序列化的基本原理知识
&&&&&& 参考转自：http://yuyiming.iteye.com/blog/1277089
该博客里面基本的介绍，这里不过多废话了。
&&&&& （二）.一次序列化多个对象及多次序列化产生的问题
&&&&&& 对于一次序列化多个对象的话，就是多次调用writeObject()方法就可以了。然而要注意的一点就是在一次的序列化的过程中（写入文件到关闭文件的过程为一次序列化过程），ObjectOutputStream对象写对象的话，会写入一个header，也就是一次序列化的过程中会在文件开始的地方写入一个Header的信息到文件中，于此在多次序列化的过程中（如序列化一次关闭文件后，可能又需要往文件中序列化其他对象），此时就会继续在文件末尾（本次序列化的开头）写入Header的信息，如此如果进行反序列化的对象的时候会报如下错误java.io.StreamCorruptedException: invalid type code: AC，因为这是头的信息而不是对象的信息，为了解决这个办法，就必须在以后序列化的过程中不写入头文件即可：
解决方法：（详细见博客转自http://blog.sina.com.cn/s/blog_z143.html）
1.用同一个ObjectOutputStream写对象
2.但是大部分时候，要不断往某个文件记录对象，这样按照1的说法就要维护一个ObjectOutputStream，但是重启应用时候就会重新创建一个ObjectOutputStream对象，此时如果还是想往刚才那个文件里写对象的话，就会追加一个header。这样在读对象时读到这个位置就会报错。
解决方法是重写ObjectOutputStream的writeStreamHeader()方法
&&&& （三）.多次序列化多个对象时的解决方法
&&&& 上面解决了多次序列化的问题，为此我们发现他们在发序列化对象的时候，必须要知道序列化了多少 个对象，然后才能循环多少次把对象取出来，这样显然不是很方便，如果我文件和程序关闭了，我下次要是又想反的时候，怎么才知道以前序列化了多少个对象呢？为此我们通过如下的方法来解决，因为在readObject()的时候，每次都是反序列化一个对象，所以我们可以通过一个while(true)的循环来读取，当到文件最后的时候，会抛出EOFFileEnd的一个异常来解决。代码见下
public class SerializableTestListError {
private static List&Student& listStudentObject = new ArrayList&Student&();
private static List&Car& listCarObject = new ArrayList&Car&();
private static List&Object& listObject = new ArrayList&Object&();
public static void main(String[] args) throws IOException {
Student stu1 = new Student(, "yteng1", 204);
Student stu2 = new Student(, "yteng2", 421);
Car car1 = new Car("DazsAut44400o", "ShangHai", );
Car car3 = new Car("DazsAuto", "ShangHai", );
Car car2 = new Car("Ford", "JiangSu", );
listObject.add(car2);
listObject.add(car1);
listObject.add(car3);
listObject.add(stu1);
listObject.add(stu2);
writeObject2File(listObject, "D:\\new.txt");
readObjectFromFile("D:\\new.txt");
} catch (SerilizableException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
public static void writeObject2File(List&Object& o, String fileName)
throws IOException {
File file =
FileOutputStream fos =
ObjectOutputStream oos =
file = new File(fileName);
fos = new FileOutputStream(file, true);
if (file.length() & 1) {
oos = new ObjectOutputStream(fos);
oos = new MyObjectOutputStream(fos);
for (int i = 0; i & o.size(); i++)
oos.writeObject(o.get(i));
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fos != null)
fos.close();
if (oos != null)
oos.close();
} catch (IOException e) {
e.printStackTrace();
public static void readObjectFromFile(String fileName) throws Exception {
FileInputStream fis =
ObjectInputStream ois =
fis = new FileInputStream(fileName);
ois = new ObjectInputStream(fis);
while (true)
System.out.println(ois.readObject());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
System.out.println("文件终止!~");
e.printStackTrace(); //此处解决序列化完成后的异常
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
System.out.println("输出结束~");
} finally {
if (fis != null)
fis.close();
if (ois != null)
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
这里我一次序列化了多个对象。另外我们还可以用流机制来反序列化多个对象，代码如下：
public class SerializableTest {
private static List&Student& listStudentObject=new ArrayList&Student&();
private static List&Car& listCarObject=new ArrayList&Car&();
private static List&Object& listObject=new ArrayList&Object&();
public static void main(String[] args) throws IOException {
Student stu1=new Student(001, "yteng11", 20);
Student stu2=new Student(002,"yteng22",21);
Car car1=new Car("DazsAuto", "ShangHai", );
Car car2=new Car("Ford","JiangSu",30000.00);
writeObject2File(stu1,"D:\\date.txt");
writeObject2File(stu2,"D:\\date.txt");
writeObject2File(car1,"D:\\date.txt");
writeObject2File(car2,"D:\\date.txt");
readObjectFromFile("D:\\date.txt");
} catch (SerilizableException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
for(Iterator&Car& iterCar=listCarObject.iterator();iterCar.hasNext();){
System.out.println(iterCar.next());
for(Iterator&Student& iterStudent=listStudentObject.iterator();iterStudent.hasNext();){
System.out.println(iterStudent.next());
&&& public static void writeObject2File(Object o,String fileName) throws IOException{
FileOutputStream fout=new FileOutputStream(fileName,true);
ObjectOutputStream sout=new ObjectOutputStream(fout);
sout.writeObject(o);
sout.close();
System.out.println("写入对象成功!");
public static void readObjectFromFile(String fileName) throws Exception{
FileInputStream fin=new FileInputStream(fileName);
&&& BufferedInputStream bis=new BufferedInputStream(fin);
ObjectInputStream oip=
& while(true){
&&&&&&&& try{
&&&&&&&&&&& oip=new ObjectInputStream(bis);&& //每次重新构造对象输入流
&&&&&&&& }
&&&&&&&& catch(EOFException e)
&&&&&&&&&& e.printStackTrace();
&&&&&&&&& System.out.println("已达文件末尾");//如果到达文件末尾，则退出循环
&&&&&&&& Object object=new Object();&
&&&&&&&& object=oip.readObject();
&&&&&&&& if(object instanceof Student) {& //判断对象类型
listStudentObject.add((Student)object);
&&&&&&&& else if(object instanceof Car){
listCarObject.add((Car)object);
&&&& oip.close();
&&&& bis.close();
&&&& fin.close();
}
好了，第一次发帖也不知道怎么编辑，比较乱，有错误的话希望大侠指出。
tengyue5i5j
浏览: 2732 次
来自: 上海
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'