Java 如何序列化ObservableList

我正在从事一个javaFx项目，我们必须使用

observeList

添加列表器<代码>可观察列表包括人员模型。但是我想通过序列化将整个

ObservableList

对象存储在一个文件中。但是它给了我一个例外。 我也在对象模型上实现了序列化，但运气不好。是否有任何方法可以序列化可观察列表

员工模型 序列化

---

observativeList

实现是不可序列化的（本质上没有合理的方法来定义序列化侦听器的行为，根本不序列化侦听器就等同于用相同的数据序列化不可观察的列表，我认为这就是您在这里要做的。）假设您的

Person

类是

可序列化的

（并且实例实际上可以序列化），您可以执行以下操作：

 public void write(ObservableList<EmployeeEntity> personObservalble) {
    try {
        // write object to file
        FileOutputStream fos = new FileOutputStream("Objectsavefile.ser");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(new ArrayList<EmployeeEntity>(personsObservable));
        oos.close();


    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }

}

公共无效写入（ObservableList PersonObservable）{
试一试{
//将对象写入文件
FileOutputStream fos=新的FileOutputStream（“Objectsavefile.ser”）；
ObjectOutputStream oos=新的ObjectOutputStream（fos）；
oos.writeObject（新的ArrayList（personsObservable））；
oos.close（）；
}catch（filenotfounde异常）{
e、 printStackTrace（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}

要重新阅读，您可以执行以下操作：

ObjectInputStream ois = ... ;
List<EmployeeEntity> list = (List<EmployeeEntity>) ois.readObject();
personsObservable = FXCollections.observableList(list);

ObjectInputStream ois=；
List=（List）ois.readObject（）；
personsObservable=FXCollections.observableList（列表）；

这是一个完整的测试。我运行了这个程序，它成功了（我删除了持久性注释，因为在我的测试环境中的类路径上没有javax.persistence，但这应该没有什么区别）

import java.io.FileNotFoundException；
导入java.io.IOException；
导入java.io.InputStream；
导入java.io.ObjectInputStream；
导入java.io.ObjectOutputStream；
导入java.io.OutputStream；
导入java.nio.file.Files；
导入java.nio.file.Path；
导入java.util.ArrayList；
导入java.util.List；
导入javafx.collections.FXCollections；
导入javafx.collections.ObservableList；
公共类序列化可观察性测试{
公共静态void main（字符串[]args）引发IOException{
员工实体比尔=新员工实体（“1000”、“华盛顿州西雅图”、“1000”、“比尔”、“盖茨”）；
EmployeeEntity tim=新的EmployeeEntity（“2000”、“Mobile、AL”、“2000”、“tim”、“Cook”）；
ObservableList staff=FXCollections.observableArrayList（比尔，蒂姆）；
Path temp=Files.createTempFile（“员工”、“服务商”）；
写（职员、临时工）；
ObservableList listFromFile=读取（临时）；
System.out.println（“Lists equal？”+listFromFile.equals（staff））；
}
私有静态无效写入（ObservableList员工，路径文件）{
试一试{
//将对象写入文件
OutputStream fos=Files.newOutputStream（文件）；
ObjectOutputStream oos=新的ObjectOutputStream（fos）；
oos.writeObject（新ArrayList（员工））；
oos.close（）；
}catch（filenotfounde异常）{
e、 printStackTrace（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
私有静态可观察列表读取（路径文件）{
试一试{
InputStream in=Files.newInputStream（文件）；
ObjectInputStream ois=新ObjectInputStream（in）；
List=（List）ois.readObject（）；
返回FXCollections.observableList（列表）；
}catch（classnotfounde异常）{
e、 printStackTrace（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
返回FXCollections.emptyObservableList（）；
}
}

“我也在对象模型上实现了序列化，但运气不好”你是说你在那个类中添加了

实现了可序列化的

？你知道这并不能保证实例可以被序列化吗？事实上，我是编程新手。所以我对系列化的概念很弱。现在我明白了。系列化并不总是在仪表上有效。你是否可以尝试一下我在答案中发布的代码，看看它是否有效？但你可以看到我已经在EmployeeModel上实现了系列化。但我仍然不能进行系列化，它对我来说很好。请参阅更新的答案。如果使用此技术确实不起作用，请在问题中发布堆栈跟踪。该异常表示您仍在尝试序列化可观察列表。请按照我的建议尝试。说真的，用我发布的代码是不可能得到那个异常的。只需阅读错误消息：它表示您正在序列化一个可观察列表。

FileWriter

的第14行有

oos.writeObject（新的ArrayList（personsObservable））

？@James_D，如果一个类包含一个

可观察列表

，并且它实现了

可序列化

，那么当将该类的对象导出到文件时，它似乎不会引发任何异常。为什么以及

可观察列表的状态是什么？
java.io.NotSerializableException: com.sun.javafx.collections.ObservableListWrapper
    at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)
    at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)
    at FileWriter.write(FileWriter.java:14)
    at Main.main(Main.java:12)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:497)
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:144)

Process finished with exit code 0

 public void write(ObservableList<EmployeeEntity> personObservalble) {
    try {
        // write object to file
        FileOutputStream fos = new FileOutputStream("Objectsavefile.ser");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(new ArrayList<EmployeeEntity>(personsObservable));
        oos.close();


    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }

}

ObjectInputStream ois = ... ;
List<EmployeeEntity> list = (List<EmployeeEntity>) ois.readObject();
personsObservable = FXCollections.observableList(list);

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;

import javafx.collections.FXCollections;
import javafx.collections.ObservableList;

public class SerializeObservableListTest {

    public static void main(String[] args) throws IOException {
        EmployeeEntity bill = new EmployeeEntity("1000", "Seattle, WA", "1000", "Bill", "Gates");
        EmployeeEntity tim = new EmployeeEntity("2000", "Mobile, AL", "2000", "Tim", "Cook");

        ObservableList<EmployeeEntity> staff = FXCollections.observableArrayList(bill, tim);

        Path temp = Files.createTempFile("employees", "ser");
        write(staff, temp);

        ObservableList<EmployeeEntity> listFromFile = read(temp);
        System.out.println("Lists equal? "+listFromFile.equals(staff));
    }

    private static void write(ObservableList<EmployeeEntity> employees, Path file) {
        try {

            // write object to file
            OutputStream fos = Files.newOutputStream(file);
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(new ArrayList<EmployeeEntity>(employees));
            oos.close();


        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    private static ObservableList<EmployeeEntity> read(Path file) {
        try {
            InputStream in = Files.newInputStream(file);
            ObjectInputStream ois = new ObjectInputStream(in);
            List<EmployeeEntity> list = (List<EmployeeEntity>) ois.readObject() ;

            return FXCollections.observableList(list);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return FXCollections.emptyObservableList();
    }
}