黑马程序员技术交流社区

标题: 小程序活动 [打印本页]

作者: 古银平 时间: 2012-11-5 09:56
标题: 小程序活动
编程实现对象的序列化和反序列化。（写出自己的思路，一定要有注释，必须是以自己理解写出来的）

作者: 罗宝 时间: 2012-11-5 10:04
赞一个！{:soso_e179:}

作者: 李亚飞 时间: 2012-11-5 10:10
暂时还没学到这……先围观一下……

作者: 黑马贾林栋 时间: 2012-11-5 10:19
先占个楼

作者: 陈云展 时间: 2012-11-5 10:24

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:33
本帖最后由罗宝于 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;
}
}

复制代码

作者: 小灰灰 时间: 2012-11-5 10:53

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;
}
}

复制代码

作者: 赵云柯 时间: 2012-11-5 11:39

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 12:38
本帖最后由朱宏青于 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;
}
}
}

复制代码

绝对给力有木有！

求分~

作者: 静等花开 时间: 2012-11-5 19:28
对象序列化包括如下步骤：

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！ 时间: 2012-11-6 21:18
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;
}

}

作者: 吕鹏飞 时间: 2012-11-8 00:26
我还不会，加快脚步了

作者: _王涛 时间: 2013-3-17 10:40
我还不会呢，马上赶上...

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2