序列化与JSON

序列化与反序列化

public class Person {
    private int age;
    private int id;

    public Person() {

    }

    public Person(int age, int id) {
        this.age = age;
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public int getId() {
        return id;
    }

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

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

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("Person{");
        sb.append("age=").append(age);
        sb.append(", id=").append(id);
        sb.append('}');
        return sb.toString();
    }
}



public class User extends Person implements Serializable {

    private static final long serialVersionUID = -5584877508890698288L;
    private String name;

    private int a;

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

    private void writeObject(ObjectOutputStream out) throws IOException {
        System.out.println("writeObject>>>>>");
        out.defaultWriteObject();
        out.writeInt(getId());
        out.writeInt(getAge());
    }

    private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
        System.out.println("readObject>>>>>");
        ois.defaultReadObject();
        setId(ois.readInt());
        setAge(ois.readInt());
    }

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("User{");
        sb.append("name='").append(name).append('\'');
        sb.append('}');
        return sb.toString() + super.toString();
    }
}


public class Test {
    public static void main(String[] args) {
        try {
            test2();
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("has error:" + e);
        }

    }

    public static void test() throws IOException, ClassNotFoundException {
        User user = new User(1, 2, "a1");
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(byteArrayOutputStream);
        oos.writeObject(user);
        System.out.println("write:" + user);
        byte[] bytes = byteArrayOutputStream.toByteArray();
        oos.close();

        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
        ObjectInputStream ois = new ObjectInputStream(byteArrayInputStream);
        Object o = ois.readObject();
        if (o != null) {
            User user1 = (User) o;
            System.out.println("read:" + user1);
        }
        ois.close();
    }

    public static void test2() throws IOException, ClassNotFoundException {
        User user = new User(1, 2, "a1");
        String path = "C:\\Users\\86150\\Desktop\\111\\a.bat";
        FileOutputStream fileOutputStream = new FileOutputStream(path);
        ObjectOutputStream oos = new ObjectOutputStream(fileOutputStream);
        oos.writeObject(user);
        oos.close();
        System.out.println("write:" + user);

        FileInputStream inputStream = new FileInputStream(path);
        ObjectInputStream ois = new ObjectInputStream(inputStream);
        Object o = ois.readObject();
        if (o != null) {
            User user1 = (User) o;
            ois.close();
            System.out.println("read:" + user1);
        }


    }
}

深浅拷贝

如果在拷贝这个对象的时候，只对基本数据类型进行了拷贝，而对引用数据类型只是进行了引用的传递，而没有真实的创建一个新的对象，则认为是浅拷贝。反之，在对引用数据类型进行拷贝的时候，创建了一个新的对象，并且复制其内的成员变量，则认为是深拷贝。

浅拷贝和深拷贝只是相对的，如果一个对象内部只有基本数据类型，那用 clone() 方法获取到的就是这个对象的深拷贝，而如果其内部还有引用数据类型，那用 clone() 方法就是一次浅拷贝的操作。

JSON

解析方式
. org.json解析

解析原理：基于文档驱动，需要把全部文件督导内存中去，然后遍历所有数据，根据
需要检索想要的数据。
具体使用： JSONObject JSONArray

. Gson解析

解析原理：基于事件驱动
解析流程：根据所需取的数据，建立1个对应JSON数据的JavaBean类，即可通过简单操作解析出所需数据。
Gson不要求JavaBean类里面的属性一定全部喝JSON数据里的所有key相同，可以按需取数据。

• Fastjson
• 常见问题

Caused by: java.lang.1llegalstateException: ExpectedBEGIN_ARRAY but
was STRING at line 3 column 17 path$.authors
解决方案：
自定义TypeAdapter
自定义JsonDeserializer