java利用对象流和集合实现对象的序列化与反序列化

对象的序列化是指将对象写入到文件（硬盘到内存）,反序列化是将文件内容读取到控制台上面（内存到硬盘）！

代码解释、

package com.java.cq.IO.test;
import java.io.FileInputStream;
/*参与序列化的对象必须实现Serializable接口
   实现接口为了给虚拟机辨识
   实现多个对象
     创建一个集合
     序列化集合
   transient 游离的不参与序列化
*序列号版本的作用:区分类 ，缺点是代码不能改
*建议序号化编号自己写
 */
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

public class ObjectInputStreamtest {

	public static void main(String [] agrs) {
		
		//创建集合
		List<Student> student=new ArrayList<>();
		//集合存放对象
		student.add(new Student("zhangsan",123555));
		student.add(new Student("san",1255));
		student.add(new Student("jakcgsan",10005));
		student.add(new Student("zjan",1255));
		//序列化
		try {
			ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("d:\\学习笔记\\java\\ws.txt",true));
			//序列化集合
			oos.writeObject(student);
			//反序列化
			ObjectInputStream ois=new ObjectInputStream(new FileInputStream("d:\\学习笔记\\java\\ws.txt"));
	        Object obj=ois.readObject();
	        List<Student>date=(List<Student>)obj;
		   for(Student students:date)
		   {
			   System.out.println(students);
		   }
			//刷新
			oos.flush();
			//关闭
			oos.close();
			
			//NotSerializableException 不支持序列化
		} catch (FileNotFoundException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
	}

	@Override
	public String toString() {
		return "ObjectInputStreamtest []";
	}
}
class Student implements Serializable{
	private static final long serialversionUID=1l;//序列化号
	 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 Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	} 
}

练习代码（小编在练习代码中自定义的类指重写了equals,toString,hashCode,ComparTo等方法

还有许多方法是没有重写的，并且要实现自定义的列可序列化必须实现Serialziable接口，小编加了一个Comparable接口是为了让对象可以存放在可排序的集合（treeset,TreeMap等））

package com.java.everdattest;
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;
import java.util.ArrayList;
import java.util.List;
/*创建顾客类
 * 类中有name ,id两个属性
 * 重写类的各种方法
 * 使用集合存放顾客类用户对象
 * 将集合序列号存放到文集中
 * 利用File属性判断文件是否存在，若不就创建
 * 反序列化输出对象
 */
public class Todaystest12 {
	public static void main(String [] agrs) {
		// 创建对象
		Coustmer a = new Coustmer(18, "张三");
		Coustmer b = new Coustmer(19, "李四");
		Coustmer c = new Coustmer(25, "王宝强");
		Coustmer d = new Coustmer(20, "马化腾");
		//创建集合
		List<Coustmer>list =new ArrayList<>();
		//放入元素
		list.add(a);
		list.add(b);
		list.add(c);
		list.add(d);
		//创建文集
		File file=new File("D:\\学习笔记\\java\\Todays.txt");
		if(!file.exists()) {
			try {
				file.createNewFile();
			} catch (IOException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
		}
		//序列化
		try {
			//如果上面没有创建文件，FileOutputStream也会自动创建文件
			//只是为了练习一下File类
			ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("D:\\学习笔记\\java\\Todays.txt"));
			oos.writeObject(list);
			oos.flush();
			oos.close();
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
		//反序列化
		try {
			ObjectInputStream ois =new ObjectInputStream(new FileInputStream("D:\\学习笔记\\java\\Todays.txt"));
			Object cc=ois.readObject();
			  //转化一下
			List<Coustmer>CoustmerDates=(List<Coustmer>)cc;
			for(Coustmer coustmerdates:CoustmerDates) {
				System.out.println(coustmerdates);
			}	
			ois.close();
		} catch (FileNotFoundException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
	}
}

class  Coustmer implements Serializable ,Comparable<Coustmer>{
	 int id ;
	 String name;
	//构造方法
	 Coustmer(int id ,String name){
		 this.id=id;
		 this.name=name;
	 }
	//toString
	 public String toString(){
		 return "顾客姓名:"+name
				 +" "+"顾客编号"+id;
	 }
	//equals
	 public boolean equals(Object o) {
		 if(this==o)return true;
		 if(null==o||!(o instanceof Coustmer)) return false;
		 Coustmer cc=(Coustmer)o;
		 if(this.id==cc.id&&this.name.equals(cc.name)) return true;
		 return false;
	 }
	//hashCode
	 public int hashCode() {
		 final int pr=31;
		 int re=1;
		 re=pr*re+this.id;
		 re=pr*re+((this.name==null)?0:this.name.hashCode());
		 
		 return 0;
	 }
	@Override//实现可以放入排序集合中 TreeMap TreeSet
	public int compareTo(Coustmer o) {
	
		if(this.name==o.name) {
			return this.name.compareTo(o.name);
		}else {
			return this.id=o.id;
		}
	}

}