集合序列化

集合的序列化（代码实现）

关于序列化略述几点：

1. 序列化是序列化对象的属性。
2. 序列化的对象需要实现Serializable默认序列化或者Externalizable指定序列化。本文实现的是Serializable。
3. transient和static修饰的属性都不参与序列化。

想要了解序列化请另行搜索相关文档，本文只限于序列化的代码实现（集合）。

主函数实现类

package xuliehuatest;

import IOTest.Serializable;

import java.io.IOException;
import java.util.Iterator;
import java.util.LinkedHashMap;

public class Main {
    public static void main(String[] args) {
        //定义文件路径
        String pathFile = "stu.txt";
        //使用map集合实现序列化
        LinkedHashMap<String, Student> map = new LinkedHashMap<>();
        map.put("10001",new Student("10001","张三",21));
        map.put("10002",new Student("10002","李四",20));
        map.put("10003",new Student("10003","王二",28));
        try {
            //调用自定义的序列化函数
            SerializableTest.serializable(map,pathFile);
            System.out.println("序列化成功！ok!");
            System.out.println("-------------");

            /**
             * 删除指定数据后序列化
             */
            //强转返回值
            map = (LinkedHashMap<String, Student>) SerializableTest.deSerializable(pathFile);
            System.out.println("反序列化成功！ok!");

            //定义迭代器
            Iterator<String> iterator = map.keySet().iterator();
            //输出反序列化成功后的集合元素
            while (iterator.hasNext()){
                String key = iterator.next();
                //使用键的Set集合得到value值
                Student stu = map.get(key);
                System.out.println(stu);
            }
            //删除指定集合里指定元素
            Iterator<String> iterator1 = map.keySet().iterator();
            while(iterator1.hasNext()){
                String key = iterator1.next();
                if(key.equals("10003")){
                    iterator1.remove();
                    System.out.println("删除成功！ok!");
                    break;
                }
            }
            //将新的集合重新序列化
            SerializableTest.serializable(map,pathFile);
            //再次反序列化得到新的集合
            map = (LinkedHashMap<String, Student>) SerializableTest.deSerializable(pathFile);
            Iterator<String> iterator2 = map.keySet().iterator();
            //若集合内已无对象，则打印输出后结束方法
            if(!iterator2.hasNext()){
                System.out.println("无对象输出！");
                return;
            }
            //若集合内仍有对象，打印输出
            while (iterator2.hasNext()){
                String key = iterator2.next();
                Student stu = map.get(key);
                System.out.println(stu);
            }
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

序列化与反序列化自定义类

package xuliehuatest;

import java.io.*;

public class SerializableTest {
    /**
     * 序列化操作
     * @param obj 序列化对象
     * @param filePath 序列化到目标文件的文件路径
     * @throws IOException
     */
    public static void serializable(Object obj,String filePath) throws IOException {
        //创建文件输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
        //将对象写入文件
        oos.writeObject(obj);
        //关闭输出流
        oos.close();
    }

    /**
     * 反序列化操作
     * @param filePath 从指定文件反序列化
     * @return  反序列化的对象
     * @throws IOException
     * @throws ClassNotFoundException
     */
    public static Object deSerializable(String filePath) throws IOException, ClassNotFoundException {
        //创建对象输入流
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));
        //接收输入的对象
        Object map = ois.readObject();
        //关闭流
        ois.close();
        //返回反序列化后的对象
        return map;
    }
}

学生对象类

package xuliehuatest;

import java.io.Serializable;

public class Student implements Serializable {
    private String number;
    private String name;
    private int age;

    public Student() {
        super();
    }

    public Student(String number, String name, int age) {
        this.number = number;
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "number='" + number + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

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

注意：

1. 关于这里的迭代器，不能只定义一次，因为每次迭代后指针位置会发生变化，建议用一次定义一次。
2. 序列化与反序列化的顺序与队列操作的顺序有些相似，先进行序列化的，反序列化时也必须先进行。
3. 删除操作时不能使用map集合进行指定键的删除，要使用迭代器自带的删除方法。因为LinkedHashMap是线程不安全的，不能在遍历的同时进行删除。

希望这篇学习笔记能对你有所帮助，本人目前也只不过学习到IO这里，菜鸟一枚，如果文章或代码有不严谨的地方或错误，请指正！！！避免误导他人！！！