在Java中反序列化ArrayList

我有自己的小serialiser类

package mypackage.shared;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Serializer {

    static final String HEXES = "0123456789ABCDEF";

    public static String serialize(Object o) throws IOException {
        ByteArrayOutputStream stream = new ByteArrayOutputStream(); 
        ObjectOutputStream os = new ObjectOutputStream(stream);

        os.writeObject(o);
        os.close();
        return toHex(stream.toByteArray());
    }

    public static Object deserialize(String hexString)  throws IOException, ClassNotFoundException {
        byte[] serializedBytes = toByteArray(hexString);
        ByteArrayInputStream bis = new ByteArrayInputStream(serializedBytes);
        ObjectInputStream ois = new ObjectInputStream(bis); 

        Object o = null;
        o = ois.readObject();
        ois.close(); 
        return o;
    }

    public static String toHex( byte [] raw ) {
        if ( raw == null ) {
            return null;
        }
        final StringBuilder hex = new StringBuilder( 2 * raw.length );
        for ( final byte b : raw ) {
            hex.append(HEXES.charAt((b & 0xF0) >> 4))
            .append(HEXES.charAt((b & 0x0F)));
        }
        return hex.toString();
    }

    private static byte[] toByteArray(String s) {
        int len = s.length();
        byte[] data = new byte[len / 2];
        for (int i = 0; i < len; i += 2) {
            data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4)
                    + Character.digit(s.charAt(i+1), 16));
        }
        return data;
    }

}

package mypackage.shared；
导入java.io.ByteArrayInputStream；
导入java.io.ByteArrayOutputStream；
导入java.io.IOException；
导入java.io.ObjectInputStream；
导入java.io.ObjectOutputStream；
公共类序列化程序{
静态最终字符串HEXES=“0123456789ABCDEF”；
公共静态字符串序列化（对象o）引发IOException{
ByteArrayOutputStream=新建ByteArrayOutputStream（）；
ObjectOutputStream os=新的ObjectOutputStream（流）；
写对象（o）；
os.close（）；
返回到hex（stream.toByteArray（））；
}
公共静态对象反序列化（字符串hexString）引发IOException、ClassNotFoundException{
字节[]serializedBytes=toByteArray（十六进制字符串）；
ByteArrayInputStream bis=新的ByteArrayInputStream（序列化字节）；
ObjectInputStream ois=新ObjectInputStream（bis）；
对象o=null；
o=ois.readObject（）；
ois.close（）；
返回o；
}
公共静态字符串toHex（字节[]原始）{
如果（原始==null）{
返回null；
}
最终StringBuilder十六进制=新StringBuilder（2*原始长度）；
for（最终字节b:raw）{
十六进制追加（十六进制字符（（b&0xF0）>>4））
.append（十六进制字符（（b&0x0F））；
}
返回hex.toString（）；
}
专用静态字节[]toByteArray（字符串s）{
int len=s.length（）；
字节[]数据=新字节[len/2]；
对于（int i=0；i数据[i/2]=（字节）（（Character.digit（s.charAt（i），16）如果序列化不起作用，则表示某些对象不可序列化

尝试反序列化仅包含一个主对象的arraylist，并对所有主对象执行此操作
此操作是否仅适用于自制对象，或常规java对象，如
字符串
等？是否仅对对象的
列表
失败，还是对
列表
也失败？