完成序列化和反序列化的一个集合操作，集合对象中要求保存2个用户对象

package firstExam.fifth;

/**

* 完成序列化和反序列化的一个集合操作，集合对象中要求保存2个用户对象

*/

import java.io.Closeable;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.Flushable;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.ObjectStreamException;

import java.util.ArrayList;

import java.util.List;

/**

*可以写入输入流中的对象称为可序列化的，可序列化的对象的类必须实现Serializable接口，该接口是一种标记接口，

*因为它没有任何方法，实现这个接口可以启动Java的序列化机制，自动完成存储对象和数组的过程。

*Java提供一个内在机制自动完成写对象的过程，该过程称为对象序列化，它是在ObjectOutputStream中实现的；

*与此相反，读取对象的过程称为对象反序列化，它是在ObjectInputStream类中实现的。

*/

/**

* 并不是每一个对象都可以写入到输出流，试图存储一个不支持Serializable接口的对象会引起一个

* NotSerializableException，

* NotSerializableException extends ObjectStreamException,

* ObjectStreamException extends IOException

*

*/

public class Test {

public static void main(String[]args){

Flower f1=new Flower(1,”rose”,2);

Flower f2=new Flower(2,”flower”,3);

List flowerList=new ArrayList<>();

flowerList.add(f1);

flowerList.add(f2);

serializable(flowerList);

non_serializable(flowerList);

}

public static void serializable(List<Flower> list){
try {
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("serializable.txt"));
//此处为增强for循环，结果等同于②处的普通for循环
for(Flower f:list){//----①
oos.writeObject(f);
}
//OutputStream implements Closeable, Flushable
oos.flush();
oos.close();

} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}

}

public static void non_serializable(List<Flower> list){
try {
ObjectInputStream ois=new ObjectInputStream(new FileInputStream("serializable.txt"));
//此处为普通for循环，结果等同于①处的增强for循环
for(int i=0;i<list.size();i++){//----②
//从文件读取对象，并将其输出
Flower f=(Flower)ois.readObject();
System.out.println(f);
}
//InputStream implements Closeable
ois.close();
}catch (ClassNotFoundException e) {

e.print
4000
StackTrace();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}

}

}

package firstExam.fifth;

import java.io.Serializable;

public class Flower implements Serializable {

private int id;
private String name;
private int age;

public Flower(){

}
public Flower(int id,String name,int age){
this.id=id;
this.name=name;
this.age=age;
}

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

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

public int getAge(){
return this.age;
}
public void setAge(int age){
this.age=age;
}

@Override
public boolean equals(Object obj) {
if(obj instanceof Flower){
Flower flower=(Flower)obj;
return this.name.equals(flower.name);
}else
return false;

}

@Override
public String toString() {
return "Flower(id="+id+",name="+name+",age="+age+")";
}

}