完成序列化和反序列化的一个集合操作，集合对象中要求保存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.printStackTrace();
    } 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+")";
}

}