CGB2108-Day16-序列化与反序列化-集合-泛型-Collection-测试报错NotSerializableException-测试报错InvalidClassException

序列化与反序列化

1. 序列化：

将程序中的对象，序列化输出到文件中
方向是Out,使用的流是ObjectOutputStream
使用的方法是out.writeObject(目标对象)；
注意：如果一个类的对象想要被序列化，那么这个类必须实现Serializable接口

2. 反序列化：

将之前输出到文件中的数据，读取回程序中，并把读到的数据恢复成对象
方向是in,使用的流是ObjectInputStream
使用的方法是in.readObject();
注意：反序列化指定的文件路径，必须与序列化输出的文件路径一样
注意：一次序列化操作对应一次反序列化操作，或者UID必须保持一致，如果不一致，会报错
 

3. 集合
3.1 泛型

泛型，不是指一种具体的类型，而是说，这里有个类型需要设置，那么具体设置成什么类型，得看具体的使用
泛型通常与集合一起使用，用来限制集合中元素的类型
泛型设置了什么类型，那么这个集合只能存这个泛型类型的数据
泛型是一颗“语法糖”：
1）泛型可以把报错的时机提前，用于在编译期检查集合的数据类型，只要不是规定的类型，就报错，通不过编译
2）泛型只在编译时生效，编译通过以后，说明符合语法，泛型就会被抛弃，字节码文件中没有泛型
泛型的类型必须使用引用类型，比如Student、Integer
泛型方法：如果在方法上使用泛型，必须两处同时出现：
1）一个是方法的参数列表中的参数类型
2）一个是返回值前的泛型类型，表示这是一个泛型方法

 3.2 Collection

1.Collection是集合层次中的根接口
2.集合的继承关系

3.是集合层次的根接口，学习抽象父级的公共方法

3.3 Collection集合方法总结

 单个集合的操作：

boolean add(E e) 将指定元素添加到集合中
void clear() 清空集合
boolean contains(Object o) 判断本集合是否包含指定的元素
boolean equals(Object o) 比较集合对象与参数对象o是否相等
int hashCode() 返回本集合的哈希码值。
boolean isEmpty() 判断本集合是否为空
boolean remove(Object o) 从本集合中移除指定元素o
int size() 返回本集合中元素的个数
Object[] toArray() 将本集合转为数组

集合间的操作：

boolean addAll(Collection<> c) 将c集合中的所有元素添加到本集合中
boolean containsAll(Collection<> c) 判断本集合是否包含c集合的所有元素
boolean removeAll(Collection<> c) 移除本集合中属于参数集合c的所有元素
boolean retainAll(Collection<> c) 保留本集合与参数集合c的公共元素

集合的迭代：

Iterator iterator() 返回本集合的迭代器
 

测试常用方法

package cn.tedu.review;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;

/*本类用于复习Collection*/
public class TestCollection {
    public static void main(String[] args) {
        //1.创建集合对象
        Collection<Integer> c = new ArrayList();
        Collection<Integer> c2 = new ArrayList<>();
        //2.1向c集合中添加元素
        c.add(100);
        c.add(200);
        c.add(300);
        c.add(400);
        c.add(500);
        //2.2向c2集合添加元素
        c2.add(2);
        c2.add(4);
        c2.add(6);
        c2.add(8);

        //3.按照API手册练习方法
        c.addAll(c2);//将参数集合c2的所有元素添加到本集合c中
        System.out.println(c);//[100, 200, 300, 400, 500, 2, 4, 6, 8]
        //c.clear();//清空本集合
        //System.out.println(c);//[]
        System.out.println(c.contains(300));//true,判断本集合是否包含指定元素300
        System.out.println(c.remove(4));//移除本集合中的指定元素4
        System.out.println(c);//[100, 200, 300, 400, 500, 2, 6, 8]
        System.out.println(c.containsAll(c2));//false,判断本集合c是否包含参数集合c2的所有元素
        System.out.println(c.equals(100));//false,集合对象c与100不等
        System.out.println(c.hashCode());//返回集合对象的哈希码值
        System.out.println(c.isEmpty());//false,判断本集合是否为空
        System.out.println(c);//[100, 200, 300, 400, 500, 2, 6, 8]
        System.out.println(c.removeAll(c2));//移除本集合c中属于c2集合的所有元素
        System.out.println(c);//[100, 200, 300, 400, 500]
        System.out.println(c.retainAll(c2));//保留本集合c中也属于c2集合的公共元素
        System.out.println(c);//[]，因为没有公共元素，所以c集合被清空
        System.out.println(c.size());//0,获取本集合中元素的个数
        Object[] array = c2.toArray();//将集合转为数组类型
        System.out.println(Arrays.toString(array));//[2, 4, 6, 8]

        //4.集合的迭代/遍历
        /* 迭代：
           1. 获取集合的迭代器 c2.iterator();
           2. 利用迭代器进行判断当前集合中是否有下一个可迭代的元素 it.hasNext()
           3. 利用迭代器获取当前迭代到的元素 it.next() */
        Iterator<Integer> it = c2.iterator();//获取迭代器
        while(it.hasNext()){//循环，判断是否有元素可迭代
            Integer num = it.next();//根据迭代器获取本轮迭代到的元素
            System.out.println(num);//打印获取到的本轮迭代到的集合中的元素
        }
    }
}

4. 测试报错NotSerializableException:

报错原因:要序列化对象所在的类并没有实现序列化接口

解决方案:实现序列化接口

5. 测试报错InvalidClassException:

报错原因:本次反序列化时使用的UID与序列化时的UID不匹配

解决方案:反序列化时的UID与序列化时的UID要保持一致，或者测试时一次序列操作对应一次反序列化操作,否则不匹配就报错

注：IDEA中设置自动生成serialVersionUID的提示：