Java 包含另一个arraylist的arraylist的序列化

我对谷歌搜索和stackoverflow的研究并没有解决这个问题

我想向您展示我的数据结构的一个片段：

有一个类，叫做“SequenceHolder”=>这个类带有：

ArrayList<SequenceData> data;

SequenceObject类有以下字段：（此字段位于顶部，我从这里开始序列化）

sequenceRawdata对象基本上是另外两个类（仅包含字符串）

这个“trail”的每个类都实现了接口“Serializable”

这是反序列化：

public void writeSequenceList() throws FileNotFoundException, IOException {        
    FileOutputStream fout = new FileOutputStream(path);
    ObjectOutputStream oout = new ObjectOutputStream(fout);
    oout.writeObject(data);
    oout.close();
    fout.close();        
}

  public ArrayList<SequenceData> loadSequenceList() throws FileNotFoundException, IOException, ClassNotFoundException {
        FileInputStream fileIn = new FileInputStream(path);
        ObjectInputStream in = new ObjectInputStream(fileIn);
        this.data = (ArrayList<SequenceData>) in.readObject();
        in.close();
        fileIn.close();
        return data; // load from de-serialization
    }

public ArrayList loadSequenceList（）抛出FileNotFoundException、IOException、ClassNotFoundException{
FileInputStream fileIn=新的FileInputStream（路径）；
ObjectInputStream in=新的ObjectInputStream（fileIn）；
.readObject（）中的this.data=（ArrayList）；
in.close（）；
fileIn.close（）；
返回数据；//从反序列化加载
}

在对SequenceObject进行反序列化之后，我将只检索“sequenceUrl”，而不检索recordedSequenceData。 这有什么诀窍吗

---

我突然想到，用ObjectOutputStream扩展一些类，并在每个类中显式地用“this”调用writingprocess——但是，是的，我不确定这是否是一个好主意。

你说的是什么意思“sequenceRawdata对象基本上是另外两个类（只包含字符串）！”因为当我尝试运行相同的程序时：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;


class SequenceModel implements Serializable
{
    public SequenceModel(Object a, boolean b)
    {
        sequenceRawData = a;
        isProcessedByRequest = b;
    }

    public String toString()
    {
        return (String)sequenceRawData + isProcessedByRequest + " SeqModel ";
    }

    private Object sequenceRawData;    
    private boolean isProcessedByRequest;
}

class SequenceData implements Serializable
{
    public SequenceData(ArrayList<SequenceModel> a, String b)
    {
        recordedSequenceData = a;
        sequenceUrl = b;
    }

    public String toString()
    {
        return recordedSequenceData + sequenceUrl + " SeqData ";
    }

    private ArrayList<SequenceModel> recordedSequenceData;
    private String sequenceUrl;
}

class SequenceHolder implements Serializable
{
    ArrayList<SequenceData> data;

    public String toString()
    {
        return data + " SeqHol ";
    }

    public SequenceHolder(ArrayList<SequenceData> a)
    {
        data = a;
    }


    public void writeSequenceList() throws FileNotFoundException, IOException {        
        FileOutputStream fout = new FileOutputStream(Test.file);
        ObjectOutputStream oout = new ObjectOutputStream(fout);
        oout.writeObject(data);
        oout.close();
        fout.close();        
    }

    public ArrayList<SequenceData> loadSequenceList() throws FileNotFoundException, IOException, ClassNotFoundException {
        FileInputStream fileIn = new FileInputStream(Test.file);
        ObjectInputStream in = new ObjectInputStream(fileIn);
        this.data = (ArrayList<SequenceData>) in.readObject();
        in.close();
        fileIn.close();
        return data; // load from de-serialization
    }
}

public class Test 
{
    public static File file = new File("abc.txt");

    public static void main(String[] args) 
    {

        SequenceModel obj = new SequenceModel("abc", false);
        ArrayList list = new ArrayList(); list.add(obj);
        SequenceData obh = new SequenceData(list, "str");
        ArrayList l2 = new ArrayList();
        l2.add(obh);
        SequenceHolder obi = new SequenceHolder(l2);
        try {
        obi.writeSequenceList();

            System.out.println(obi.loadSequenceList());
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

导入java.io.File；
导入java.io.FileInputStream；
导入java.io.FileNotFoundException；
导入java.io.FileOutputStream；
导入java.io.IOException；
导入java.io.ObjectInputStream；
导入java.io.ObjectOutputStream；
导入java.io.Serializable；
导入java.util.ArrayList；
类SequenceModel实现可序列化
{
公共序列模型（对象a、布尔b）
{
sequenceRawData=a；
isProcessedByRequest=b；
}
公共字符串toString（）
{
返回（字符串）sequenceRawData+isProcessedByRequest+“SeqModel”；
}
私有对象数据；
私有布尔值isProcessedByRequest；
}
类SequenceData实现可序列化
{
公共SequenceData（ArrayList a，字符串b）
{
recordedSequenceData=a；
sequenceUrl=b；
}
公共字符串toString（）
{
返回recordedSequenceData+sequenceUrl+“SeqData”；
}
私有ArrayList recordedSequenceData；
私有字符串序列URL；
}
类SequenceHolder实现可序列化
{
阵列列表数据；
公共字符串toString（）
{
返回数据+“SeqHol”；
}
公共序列持有者（ArrayList a）
{
数据=a；
}
public void writeSequenceList（）引发FileNotFoundException，IOException{
FileOutputStream fout=新的FileOutputStream（Test.file）；
ObjectOutputStream oout=新的ObjectOutputStream（fout）；
oout.writeObject（数据）；
oout.close（）；
fout.close（）；
}
public ArrayList loadSequenceList（）抛出FileNotFoundException、IOException、ClassNotFoundException{
FileInputStream fileIn=新的FileInputStream（Test.file）；
ObjectInputStream in=新的ObjectInputStream（fileIn）；
.readObject（）中的this.data=（ArrayList）；
in.close（）；
fileIn.close（）；
返回数据；//从反序列化加载
}
}
公开课考试
{
公共静态文件File=新文件（“abc.txt”）；
公共静态void main（字符串[]args）
{
SequenceModel obj=新SequenceModel（“abc”，假）；
ArrayList list=new ArrayList（）；list.add（obj）；
SequenceData obh=新的SequenceData（列表，“str”）；
ArrayList l2=新的ArrayList（）；
l2.添加（obh）；
SequenceHolder obi=新的SequenceHolder（l2）；
试一试{
obi.writeSequenceList（）；
System.out.println（obi.loadSequenceList（））；
}catch（filenotfounde异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}catch（classnotfounde异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
}

它能够序列化和反序列化这两者，并且没有问题

它正在打印的输出是：[[abcfalse SeqModel]str SeqData]，其中包括所需的所有内容

---

如果我遗漏了什么，请告诉我。

我尝试将一个带有两个字符串的类分配给Object sequenceRawData，这也很有效！！嗨，Batty，引起我注意的第一件事是，在每个类中都有一个“toString（）”-方法-我会尝试一下，并给出反馈。我没有发现缺少任何东西-除了提到的toString（）方法外，它看起来完全相同。“sequenceRawdata对象基本上是另外两个类（仅包含字符串）！”后面是，这些sequenceRawdata对象只是另外两个类，仅包含字符串。（正如您自己所了解的，只是要明确这一点）toString（）在序列化中不起任何作用，它只是以可表示的方式打印对象值，否则对象将作为SequenceModel@3213a2所以只有在打印对象时才使用toString，否则不需要：）好的。。。嗯，对我来说仍然不起作用：（我注意到，有一个带参数的构造函数来设置值->是这样吗？我只有setter和getter作为函数，但在构造函数中没有….好的：现在我有点生气了。我添加了所有getter和setter方法，甚至是缺少的字段，然后我添加了所有变量的完全setter的构造函数。但现在还不是这样rking…问题是sequenceData的arraylist不会被序列化：/也许我应该发布代码？hmmmCurioly我检查了数据，这是

  public ArrayList<SequenceData> loadSequenceList() throws FileNotFoundException, IOException, ClassNotFoundException {
        FileInputStream fileIn = new FileInputStream(path);
        ObjectInputStream in = new ObjectInputStream(fileIn);
        this.data = (ArrayList<SequenceData>) in.readObject();
        in.close();
        fileIn.close();
        return data; // load from de-serialization
    }

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;


class SequenceModel implements Serializable
{
    public SequenceModel(Object a, boolean b)
    {
        sequenceRawData = a;
        isProcessedByRequest = b;
    }

    public String toString()
    {
        return (String)sequenceRawData + isProcessedByRequest + " SeqModel ";
    }

    private Object sequenceRawData;    
    private boolean isProcessedByRequest;
}

class SequenceData implements Serializable
{
    public SequenceData(ArrayList<SequenceModel> a, String b)
    {
        recordedSequenceData = a;
        sequenceUrl = b;
    }

    public String toString()
    {
        return recordedSequenceData + sequenceUrl + " SeqData ";
    }

    private ArrayList<SequenceModel> recordedSequenceData;
    private String sequenceUrl;
}

class SequenceHolder implements Serializable
{
    ArrayList<SequenceData> data;

    public String toString()
    {
        return data + " SeqHol ";
    }

    public SequenceHolder(ArrayList<SequenceData> a)
    {
        data = a;
    }


    public void writeSequenceList() throws FileNotFoundException, IOException {        
        FileOutputStream fout = new FileOutputStream(Test.file);
        ObjectOutputStream oout = new ObjectOutputStream(fout);
        oout.writeObject(data);
        oout.close();
        fout.close();        
    }

    public ArrayList<SequenceData> loadSequenceList() throws FileNotFoundException, IOException, ClassNotFoundException {
        FileInputStream fileIn = new FileInputStream(Test.file);
        ObjectInputStream in = new ObjectInputStream(fileIn);
        this.data = (ArrayList<SequenceData>) in.readObject();
        in.close();
        fileIn.close();
        return data; // load from de-serialization
    }
}

public class Test 
{
    public static File file = new File("abc.txt");

    public static void main(String[] args) 
    {

        SequenceModel obj = new SequenceModel("abc", false);
        ArrayList list = new ArrayList(); list.add(obj);
        SequenceData obh = new SequenceData(list, "str");
        ArrayList l2 = new ArrayList();
        l2.add(obh);
        SequenceHolder obi = new SequenceHolder(l2);
        try {
        obi.writeSequenceList();

            System.out.println(obi.loadSequenceList());
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}