小程序活动

滔哥

编程实现对象的序列化和反序列化。（写出自己的思路，一定要有注释，必须是以自己理解写出来的）

罗宝 · 罗宝

赞一个！{:soso_e179:}

李亚飞 · 李亚飞

暂时还没学到这……先围观一下……

黑马贾林栋 · 黑马贾林栋

先占个楼

陈云展 · 陈云展

package com.snow;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
* 重点:
* 序列化：将对象转成二进制流存存入到磁盘、数据库等
* 1)对象(引用类型):内容+类型
* 2)不是所有的对象都可以序列化，需要序列化的对象必须有标识
* ：可序列标识空接口(Serializable)
* 反序列化：将对象的二进制流还原成对象前提:(已经序列化)
* @author Administrator
*
*/
public class ObjectOutputStreamDemo01 {
public static void main(String[] args) {
Student stu=new Student();
stu.setAge(20);
stu.setGender(true);
stu.setName("打不死的小强");
ser(stu);
Student stu1=(Student)deSer();
System.out.println(stu1.getAge());
}
/**
* 序列化对象保存到硬盘
*
* @param obj
*/
public static void ser(Object obj){
ObjectOutputStream oos=null;
try {
oos = new ObjectOutputStream(new BufferedOutputStream(
new FileOutputStream(new File("C:/ser.txt"))));
oos.writeObject(obj);
} catch (Exception e) {
}finally{
try {
if (null != oos) {
oos.close();
}
} catch (Exception e2) {
}
}
}
/**
* 反序列化:前提必须序列化
*/
public static Object deSer(){
ObjectInputStream ois=null;
try {
ois = new ObjectInputStream(new BufferedInputStream(
new FileInputStream(new File("C:/ser.txt"))));
return ois.readObject();
} catch (Exception e) {
}finally{
try {
if (null != ois) {
ois.close();
}
} catch (Exception e2) {
}
}
return null;
}
}

复制代码

package com.snow;
import java.io.Serializable;
/**
* 默认属性都是可序列化
* 如果部分属性不需要序列化: transient
* @author Administrator
*
*/
public class Student implements Serializable{
private String name;
//此属性不被序列
private transient int age;
private transient boolean gender;
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, int age, boolean gender) {
super();
this.name = name;
this.age = age;
this.gender = gender;
}
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 boolean isGender() {
return gender;
}
public void setGender(boolean gender) {
this.gender = gender;
}
}

复制代码

罗宝 · 罗宝

本帖最后由罗宝于 2012-11-5 10:39 编辑

试一下！

/**
* 功能：编程实现对象的序列化和反序列化
*/
package com.test1;
import java.io.*;
import java.util.Date;
public class Test {
public static void main(String[] args) throws Exception {
//创建一个文件输入流对象
FileOutputStream fos=new FileOutputStream("d:\\objFile.obj");
ObjectOutputStream oos = new ObjectOutputStream(fos);
//序列化对象
Customer customer = new Customer("小红", 22);
oos.writeObject("HelloWorld!");
oos.writeObject(new Date());
oos.writeObject(customer);
//写入基本类型数据
oos.writeInt(12345);
//关闭流
oos.close();
//反序列化对象
FileInputStream fis=new FileInputStream("d:\\objFile.obj");
ObjectInputStream ois = new ObjectInputStream(fis);
System.out.println("obj1：" + (String) ois.readObject());
System.out.println("obj2：" + (Date) ois.readObject());
Customer obj3 = (Customer) ois.readObject();
System.out.println("obj3：" + obj3);
int obj4 = ois.readInt();
System.out.println("obj4：" + obj4);
ois.close();
}
}
class Customer implements Serializable {
private String name;
private int age;
//构造方法，封装私有成员
public Customer(String name, int age) {
this.name = name;
this.age = age;
}
public String toString() {
return "名字是：" + name + ", 年龄是：" + age;
}
}

复制代码

小灰灰 · 小灰灰

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import org.junit.Test;
public class Demo {
// 序列化对象
@Test
public void write() throws IOException {
// 先创建一个student类
Student stu = new Student("xiaohuihui", 1);
ObjectOutputStream out = null;
//ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream。
//可以使用 ObjectInputStream 读取（重构）对象。通过在流中使用文件可以实现对象的持久存储
try {
out = new ObjectOutputStream(new FileOutputStream(
"testfile/test.txt"));
out.writeObject(stu);//writeObject 方法用于将对象写入流中
} finally {
if (out != null) {
out.close();
}
}
}
// 反序列化对象
@Test
public void read() throws IOException, ClassNotFoundException {
Student stu = null;
ObjectInputStream in = null;
//ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。
try {
in = new ObjectInputStream(new FileInputStream("testfile/test.txt"));
stu = (Student) in.readObject();
} finally {
if (in != null) {
in.close();
}
}
System.out.println(stu.getName()+" "+stu.getAge());
}
}
// studnent 类
/*
* 类通过实现 java.io.Serializable 接口以启用其序列化功能。
* 未实现此接口的类将无法使其任何状态序列化或反序列化。
*/
class Student implements Serializable {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = 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;
}
}

复制代码

赵云柯 · 赵云柯

package cn.itcast.heima2;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class Test {
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
//创建Person对象
Person p = new Person("zhangsan", 15);
//序列化，将对象保存到硬盘上
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("c:\\1.txt")));
oos.writeObject(p);
oos.close();
//清空对象
p = null;
//反序列化，将对象从硬盘上读出并打印
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("c:\\1.txt"));
p = (Person)ois.readObject();
p.getPerson();
}
}
//Person类实现Serializable接口，从而可以被序列化和反序列化
class Person implements Serializable{
public String name;
int age;
public Person(String name, int age){
this.name = name;
this.age = age;
}
public void getPerson(){
System.out.println("name: " + name);
System.out.println("age: " + age);
}
}

复制代码

朱宏青 · 朱宏青

本帖最后由朱宏青于 2012-11-5 21:11 编辑

占楼晚上贴程序.

搞定。我写的是单独一个类，功能需要调用才能实现。

利用了单例模式来使程序安全运行并且插入了视图方便使用。

具体代码如下：

import java.io.*;
import java.util.*;
import javax.swing.*;
//创建一个序列化的功能类利用单例模式实现序列化以及反序列化.
class SerIO {
private static SerIO serio = null;
private SerIO() {
}
public static SerIO getSerio() {
if (serio == null) {
serio = new SerIO();
}
return serio;
}
//需要一个object作为参数录入然后实现该object的序列化
private void setSer(Object ob) throws IOException {
Scanner input = new Scanner(System.in);
System.out.println("请输入存储序列化的文本名称:(注意不要与现有文件重名)");
FileOutputStream fos = new FileOutputStream(input.nextLine());
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(ob);
oos.flush();
}
//获取需要的文件实现反序列化
private Object getSer() throws ClassNotFoundException,IOException{
//利用swing组建来扩展,使用户视图化操作
JFileChooser jc = new JFileChooser();
jc.showDialog(null,"请选择需要反序列化的文件:(不要乱选哦~)");
File file = jc.getSelectedFile();
String str = file.getName();
String stemp = str.substring(str.lastIndexOf("."));
//判断后缀名是否规范
if(stemp.toLowerCase().equals(".txt")){
//实现反序列化
stemp = str.substring(0,str.lastIndexOf("."));
FileInputStream fis = new FileInputStream(stemp);
ObjectInputStream ois = new ObjectInputStream(fis);
Object ob = ois.readObject();
return ob;
}else{
System.out.println("反序列化失败!(请好好选择文件谢谢合作!)");
return null;
}
}
}

复制代码

绝对给力有木有！

求分~

静等花开 · 静等花开

对象序列化包括如下步骤：

1）创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流；

2）通过对象输出流的writeObject()方法写对象。

对象反序列化的步骤如下：

1）创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；

2）通过对象输入流的readObject()方法读取对象。

下面让我们来看一个对应的例子，类的内容如下：

import java.io.*;

import java.util.Date;

public class Object{

   public static void main(String[] args) throws Exception {

            ObjectOutputStream out = new ObjectOutputStream

                  (new FileOutputStream("D:""objectFile.obj"));

            //序列化对象

            Customer customer = new Customer("李冰",1);

            out.writeObject("你好!");

            out.writeObject(new Date());

            out.writeObject(customer);

            out.writeInt(123); //写入基本类型数据

            out.close();

            //反序列化对象

            ObjectInputStream in = new ObjectInputStream

                  (new FileInputStream("D:""objectFile.obj"));

            System.out.println("obj1=" + (String) in.readObject());

            System.out.println("obj2=" + (Date) in.readObject());

            Customer obj3 = (Customer) in.readObject();

            System.out.println("obj3=" + obj3);

            int obj4 = in.readInt();

            System.out.println("obj4=" + obj4);

            in.close();

   }

}

class Customer implements Serializable {

   private String name;

   private int age;

   public Customer(String name, int age) {

            this.name = name;

            this.age = age;

   }

   public String toString() {

            return "name=" + name + ", age=" + age;

   }

}

hello_world！ · hello_world！

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class SerializableDemo {

/**
   * 对象的序列化：就是指将对象从内存中存入到磁盘、数据库中等等
   * 对象的反序列化：就是将对象从磁盘、数据库读到内存中
   * @param args
   */
public static void main(String[] args) {
SerializableAttachment attachment = new SerializableAttachment("hello", 100);
SerializableDemo sd = new SerializableDemo();
sd.store(attachment, "F:\\1.txt");
SerializableAttachment sa = (SerializableAttachment) sd.getObject("F:\\1.txt");
System.out.println(sa);
}

//对象的序列化，存入磁盘的类必须实现了Serializable接口
public void store(Object obj, String path){
if (!(obj instanceof Serializable)) {
System.out.println(obj.getClass().getName() + " 这个类没有实现Serializable，不能被序列化");
return;
}
ObjectOutputStream oos = null;
try {
oos = new ObjectOutputStream(new FileOutputStream(path));
oos.writeObject(obj);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally{
if (null != oos) {
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

//对象的反序列化
public Object getObject(String path){
File src = new File(path);
Object obj = null;
if (!src.exists()) {
System.out.println(path + "不存在！");
}else {
ObjectInputStream ois = null;

try {
ois = new ObjectInputStream(new FileInputStream(src));
obj = ois.readObject();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}finally{
if (null != ois) {
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
return obj;
}

}

class SerializableAttachment implements Serializable{
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 SerializableAttachment() {
super();
}
public SerializableAttachment(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "name:" + name + ", age" + age;
}

}

吕鹏飞 · 吕鹏飞

我还不会，加快脚步了

_王涛 · _王涛

我还不会呢，马上赶上...

帐号		自动登录	找回密码
密码			加入黑马

小程序活动

评分

12 个回复

点评

评分

评分

评分

评分

评分

评分

评分

黑马骑士勋章

小程序 活动

评分

12 个回复

点评

评分

评分

评分

评分

评分

评分

评分

黑马骑士勋章

小程序活动