android对象序列化

关于序列化和对象流

分类： JAVA 2013-05-23 21:13 465人阅读 评论(2) 收藏 举报

流 对象流 序列化

一、对象序列化：
1.在做对象数据传输时，由于对象中的数据很庞大。在传输之前，需要将对象打散成字节序列，以利于传输。这个过程叫序列化过程。

2.达到目的地后，又需要将字节序列还原成对象，这叫反序列化过程。

 

二、对象流使用示例：

[java] view plain copy print ?

1. package com;  
2.   
3. import java.io.FileInputStream;  
4. import java.io.FileOutputStream;  
5. import java.io.IOException;  
6. import java.io.InputStream;  
7. import java.io.ObjectInputStream;  
8. import java.io.ObjectOutputStream;  
9. import java.io.OutputStream;  
10.   
11. public class ObjectStreamTest {  
12.     /** 
13.      * 写入对象 
14.      *  
15.      * @param obj 
16.      *            要写入文件的对象 
17.      */  
18.     public void writerObj(Object obj) {  
19.         OutputStream out = null;// 写入流  
20.         ObjectOutputStream objOut = null;// 对象写入流  
21.         try {  
22.             out = new FileOutputStream("2.txt");  
23.             objOut = new ObjectOutputStream(out);  
24.             objOut.writeObject(obj); // 写入对象  
25.         } catch (Exception e) {  
26.             e.printStackTrace();  
27.         } finally {  
28.             try {  
29.                 // 关闭流  
30.                 objOut.close();  
31.                 out.close();  
32.             } catch (IOException e) {  
33.                 e.printStackTrace();  
34.             }  
35.         }  
36.     }  
37.   
38.     /** 
39.      * 读取文件，返回文件中写入的对象 
40.      *  
41.      * @return 
42.      * @throws 
43.      */  
44.     public Student read() {  
45.         InputStream in = null;// 读取流  
46.         ObjectInputStream objIn = null;// 对象读取流  
47.         try {  
48.             in = new FileInputStream("2.txt");  
49.             objIn = new ObjectInputStream(in);  
50.             // 读取对象  
51.             Object obj = objIn.readObject();// 读取对象  
52.             return (Student) obj;  
53.         } catch (Exception e) {  
54.             e.printStackTrace();  
55.         } finally {  
56.             try {  
57.                 // 关闭流  
58.                 objIn.close();  
59.                 in.close();  
60.             } catch (IOException e) {  
61.                 e.printStackTrace();  
62.             }  
63.   
64.         }  
65.         return null;  
66.     }  
67.   
68.     public static void main(String[] args) {  
69.         ObjectStreamTest t = new ObjectStreamTest();  
70.         t.writerObj(new Student(1, "张三", "男"));  
71.         Student s = t.read();  
72.         System.out.println(s.getId() + "  " + s.getName() + "  " + s.getSex());  
73.     }  
74.   
75. }  

package com;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;

public class ObjectStreamTest {
	/**
	 * 写入对象
	 * 
	 * @param obj
	 *            要写入文件的对象
	 */
	public void writerObj(Object obj) {
		OutputStream out = null;// 写入流
		ObjectOutputStream objOut = null;// 对象写入流
		try {
			out = new FileOutputStream("2.txt");
			objOut = new ObjectOutputStream(out);
			objOut.writeObject(obj); // 写入对象
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				// 关闭流
				objOut.close();
				out.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 读取文件，返回文件中写入的对象
	 * 
	 * @return
	 * @throws
	 */
	public Student read() {
		InputStream in = null;// 读取流
		ObjectInputStream objIn = null;// 对象读取流
		try {
			in = new FileInputStream("2.txt");
			objIn = new ObjectInputStream(in);
			// 读取对象
			Object obj = objIn.readObject();// 读取对象
			return (Student) obj;
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				// 关闭流
				objIn.close();
				in.close();
			} catch (IOException e) {
				e.printStackTrace();
			}

		}
		return null;
	}

	public static void main(String[] args) {
		ObjectStreamTest t = new ObjectStreamTest();
		t.writerObj(new Student(1, "张三", "男"));
		Student s = t.read();
		System.out.println(s.getId() + "  " + s.getName() + "  " + s.getSex());
	}

}

 

[java] view plain copy print ?

1. package com;  
2.   
3. import java.io.Serializable;  
4.   
5. public class Student implements Serializable {  
6.     private int id;  
7.     private String name;  
8.     private transient String sex;// transient修饰属性的关键字,对象序列化时，该属性的值不作传输  
9.   
10.     public Student() {  
11.         super();  
12.     }  
13.   
14.     public Student(int id, String name, String sex) {  
15.         super();  
16.         this.id = id;  
17.         this.name = name;  
18.         this.sex = sex;  
19.     }  
20.   
21.     public int getId() {  
22.         return id;  
23.     }  
24.   
25.     public void setId(int id) {  
26.         this.id = id;  
27.     }  
28.   
29.     public String getName() {  
30.         return name;  
31.     }  
32.   
33.     public void setName(String name) {  
34.         this.name = name;  
35.     }  
36.   
37.     public String getSex() {  
38.         return sex;  
39.     }  
40.   
41.     public void setSex(String sex) {  
42.         this.sex = sex;  
43.     }  
44.   
45. }  

package com;

import java.io.Serializable;

public class Student implements Serializable {
	private int id;
	private String name;
	private transient String sex;// transient修饰属性的关键字,对象序列化时，该属性的值不作传输

	public Student() {
		super();
	}

	public Student(int id, String name, String sex) {
		super();
		this.id = id;
		this.name = name;
		this.sex = sex;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

}

 

 

更多 0

• 上一篇BufferedReader、BufferedWriter、Reader和Writer的综合运用
• 下一篇XML的一些概念和原理