Java 序列化ArrayList<；ArrayList<；对象>&燃气轮机；

我有一个由ArrayList组成的疯狂结构，其中的每一项都包含一个对象的ArrayList。这些对象可以是长数组或字符串。我需要序列化这个疯狂的结构，但无法实现我的目标。以后反序列化怎么样？ 我了解序列化和反序列化的基础知识，但不确定这种结构。非常感谢你的帮助

我的工作：

private void writeObject(ObjectOutputStream oos) throws IOException
{   oos.defaultWriteObject();

    // Write out all elements in the proper order.
    for (Object ohs : openingHours.getAllOpeningHours())
    {
        oos.writeObject(ohs);
//            ArrayList<Object> times = (ArrayList<Object>)ohs;
//            for(Object oh:times)
//            if (oh instanceof String)
//            {
//                oos.writeChars((String) oh);
//            } else if (oh instanceof long[])
//            {
//                long[] time = (long[])oh;
//                oos.writeLong(time[0]);
//                oos.writeLong(time[1]);
//            }
    }
}

private void writeObject（ObjectOutputStream oos）引发IOException
{oos.defaultWriteObject（）；
//按正确的顺序写出所有元素。
对于（对象ohs:openingHours.getAllOpeningHours（））
{
oos.writeObject（ohs）；
//ArrayList时间=（ArrayList）ohs；
//对于（对象oh:次）
//如果（字符串的oh实例）
//            {
//oos.writeChars（（字符串）oh）；
//}else if（oh instanceof long[]
//            {
//长[]时间=（长[]）哦；
//oos.writeLong（时间[0]）；
//oos.writeLong（时间[1]）；
//            }
}
}

---

Object类型的“ohs”应该始终是ArrayList，我发现它应该已经可以序列化了，但我想它并没有那么简单，所以，正如经常发生的那样，在发布问题后，我马上意识到了问题的症结所在。如果有人有类似的问题，这里有一个解决方案

我有一个对象的数组列表，其中一个属性叫做OpeningHours。 OpeningHours是一个POJO，有一个类型为ArrayList>的属性，对象可以是长[2]或字符串。 我得到一个错误，说OpeningHours是不可序列化的…嗯，它不是。 因此，我将其编辑为以下形式： 我用ArrayList>扩展了OpeningHours类，因为ArrayList本身已经可以序列化，所以它可以使用默认的序列化

FileOutputStream fosp = mContext.openFileOutput(FILENAME, Context.MODE_PRIVATE);
ObjectOutputStream oosp = new ObjectOutputStream(fosp);
oosp.writeObject(mBusinessSet); //mBusiness set is ArrayList or Business. 
                                //Business contains OpeningHours attribute

---

我看到了您的代码正在运行的注释，但下面是您的代码片段中的两个观察结果

首先，您将instanceof运算符与long[]数据类型一起使用，这是一种基本类型。运算符的实例不能与基元数据类型一起使用

其次，尝试在arraylist中存储Long[]值，而不是Long[]，因为Long已经实现了serializable类。

我建议将您的“疯狂结构”更改为您更喜欢的形式。在另一个对象列表中包含一个对象列表，其中第二个列表可以包含长[2]或字符串，看起来您的设计可能需要一些检查

我不知道为什么需要用一个字符串和一个长[]来表示开放时间，但我想如果将它们移动到实现Serializable的单独类中，也不会有什么坏处

大概是这样的：

public class OpeningHours implements Serializable{
private interface OpeningHour{
    public long[] getOpeningHourLongs();
    public String getOpeningHourString();
}

public static final class LongArrayOpeningHour implements OpeningHour, Serializable{
    private final long[] openingHour;

    public LongArrayOpeningHour(long[] openingHour) {
        super();
        assert openingHour.length == 2;
        this.openingHour = openingHour;
    }

    @Override
    public long[] getOpeningHourLongs() {
        return openingHour;
    }

    @Override
    public String getOpeningHourString() {
        return null; // ??
    }

    @Override
    public String toString() {
        return Arrays.toString(openingHour);
    }

}
public static final class StringOpeningHour implements OpeningHour, Serializable{

    private static final long serialVersionUID = -8424663833219027462L;
    private final String openingHour;

    public StringOpeningHour(String openingHour) {
        super();
        this.openingHour = openingHour;
    }

    @Override
    public long[] getOpeningHourLongs() {
        return null; // ??
    }

    @Override
    public String getOpeningHourString() {
        return openingHour;
    }

    @Override
    public String toString() {
        return openingHour;
    }
}

private final List<OpeningHour> openingHours;

public OpeningHours() {
    this.openingHours = new ArrayList<>();
}

public void addOpeningHour(OpeningHour hour){
    this.openingHours.add(hour);
}

@Override
public String toString() {
    return openingHours.toString();
}

public static void main(String[] args) {
    OpeningHours openingHours = new OpeningHours();

    openingHours.addOpeningHour(new StringOpeningHour("I am an opening hour based on a String value"));
    openingHours.addOpeningHour(new LongArrayOpeningHour(new long[]{1,2}));

    System.out.println("openingHours before serialization: " + openingHours );

    // write OpeningHours
    OutputStream fos = null;
    String filename = ... // insert filename here
    try {
        fos = new FileOutputStream( filename );
        ObjectOutputStream o = new ObjectOutputStream( fos );
        o.writeObject(openingHours);
    } catch (IOException e) { 
        System.err.println(e); 
    } finally { 
        if (fos != null) {
            try {fos.close();} catch (IOException e1) {}
        }
    }

    // read OpeningHours
    InputStream fis = null;
    try{
        fis = new FileInputStream( filename );
        ObjectInputStream o = new ObjectInputStream( fis );
        openingHours = (OpeningHours) o.readObject();
        System.out.println("openingHours after deserialization: " + openingHours );
    } catch (IOException e) { 
        System.err.println( e ); 
    } catch ( ClassNotFoundException e ) { 
        System.err.println( e ); 
    }finally { 
        if (fis != null) {
            try {fis.close();} catch (IOException e1) {}
        }
    }
}

}

public类OpeningHours实现可序列化{
专用接口开放小时{
公共长[]getOpeningHourLongs（）；
公共字符串getOpeningHourString（）；
}
公共静态最终类LongArrayOpeningHour实现了可序列化的OpeningHour{
私人最终长[]开放小时；
公共长时间开放小时（长[]开放小时）{
超级（）；
断言openingHour.length==2；
this.openingHour=openingHour；
}
@凌驾
公共长[]getOpeningHourLongs（）{
返回开放小时；
}
@凌驾
公共字符串getOpeningHourString（）{
返回null；/？？
}
@凌驾
公共字符串toString（）{
返回array.toString（openingHour）；
}
}
公共静态最终类StringOpeningHour实现OpeningHour，可序列化{
私有静态最终长serialVersionUID=-8424663833219027462L；
私人最终字符串打开小时；
公共字符串开放小时（字符串开放小时）{
超级（）；
this.openingHour=openingHour；
}
@凌驾
公共长[]getOpeningHourLongs（）{
返回null；/？？
}
@凌驾
公共字符串getOpeningHourString（）{
返回开放小时；
}
@凌驾
公共字符串toString（）{
返回开放小时；
}
}
私人最终名单开放小时；
公众开放时间（）{
this.openingHours=new ArrayList（）；
}
公共空间添加开放小时数（开放小时数）{
这个.openingHours.add（小时）；
}
@凌驾
公共字符串toString（）{
返回openingHours.toString（）；
}
公共静态void main（字符串[]args）{
OpeningHours OpeningHours=新OpeningHours（）；
addOpeningHours（newStringOpeningHours（“我是基于字符串值的开放时间”））；
openingHours.addopeninghours（新的longarayopeninghour（新的long[]{1,2}））；
System.out.println（“序列化之前的openingHours:+openingHours”）；
//写开放小时
OutputStream fos=null；
字符串文件名=…//在此处插入文件名
试一试{
fos=新文件输出流（文件名）；
ObjectOutputStream o=新的ObjectOutputStream（fos）；
o、 writeObject（开放小时）；
}捕获（IOE）{
系统错误println（e）；
}最后{
如果（fos！=null）{
尝试{fos.close（）；}捕获（IOException e1）{}
}
}
//阅读开放小时
InputStream fis=null；
试一试{
fis=新文件输入流（文件名）；
ObjectInputStream o=新的ObjectInputStream（fis）；
openingHours=（openingHours）o.readObject（）；
System.out.println（“反序列化后的openingHours:+openingHours”）；
}捕获（IOE）{
系统错误println（e）；
}catch（classnotfound异常）{
系统错误println（e）；
}最后{
如果（fis！=null）{
尝试{fis.close（）；}捕获（IOException e1）{}
}
}
}
}

---

我相信为这些结构提供单独的类肯定会提高代码的可读性，并从长远来看有助于更好地维护和理解代码

你自己努力了吗？如果是的话，展示出来。我已经把它添加到问题中了什么