Java通用可序列化、可重用堆栈

以下是我的程序片段，用于序列化和反序列化通用堆栈
反序列化方法

public Stack<?> readAll(Path aPath){
    Stack<?> temp = new Stack<>();
    try(ObjectInputStream readStream = new ObjectInputStream(new BufferedInputStream(Files.newInputStream(aPath)))) {
        temp = (Stack<?>) readStream.readObject();
    }catch(EOFException e) {
        e.printStackTrace();
        System.out.println("EOF");
    }catch(IOException | ClassNotFoundException e) {
        e.printStackTrace();
        System.exit(1);
    }
    return temp;
}

public void writeAll(Path aPath) {
    try(ObjectOutputStream writeStream = new ObjectOutputStream(new BufferedOutputStream(Files.newOutputStream(aPath)))) {
        writeStream.writeObject(this);
    }catch(IOException e) {
    e.printStackTrace();
    }
}  

import java.nio.file.*;
public class StackTrial {
    public static void main(String[] args) {
        String[] names = {"A","B","C","D","E"};
        Stack<String> stringStack = new Stack<>(); //Stack that will be Serialized
        Stack<String> readStack = new Stack<>(); //Stack in which data will be read
        Path aPath = Paths.get("C:/Documents and Settings/USER/Beginning Java 7/Stack.txt");//Path of file

        for(String name : names) { //pushing data in
            stringStack.push(name);
        }

        for(String a : stringStack) { //displaying content
            System.out.println(a);
        }
        stringStack.writeAll(aPath); //Serialize
        readStack = (Stack<String>) readStack.readAll(aPath);//Deserialize

        for(String a : readStack) { //Display the data read
            System.out.println(a);
        }
    }
}  

数据如何序列化和反序列化

public Stack<?> readAll(Path aPath){
    Stack<?> temp = new Stack<>();
    try(ObjectInputStream readStream = new ObjectInputStream(new BufferedInputStream(Files.newInputStream(aPath)))) {
        temp = (Stack<?>) readStream.readObject();
    }catch(EOFException e) {
        e.printStackTrace();
        System.out.println("EOF");
    }catch(IOException | ClassNotFoundException e) {
        e.printStackTrace();
        System.exit(1);
    }
    return temp;
}

public void writeAll(Path aPath) {
    try(ObjectOutputStream writeStream = new ObjectOutputStream(new BufferedOutputStream(Files.newOutputStream(aPath)))) {
        writeStream.writeObject(this);
    }catch(IOException e) {
    e.printStackTrace();
    }
}  

import java.nio.file.*;
public class StackTrial {
    public static void main(String[] args) {
        String[] names = {"A","B","C","D","E"};
        Stack<String> stringStack = new Stack<>(); //Stack that will be Serialized
        Stack<String> readStack = new Stack<>(); //Stack in which data will be read
        Path aPath = Paths.get("C:/Documents and Settings/USER/Beginning Java 7/Stack.txt");//Path of file

        for(String name : names) { //pushing data in
            stringStack.push(name);
        }

        for(String a : stringStack) { //displaying content
            System.out.println(a);
        }
        stringStack.writeAll(aPath); //Serialize
        readStack = (Stack<String>) readStack.readAll(aPath);//Deserialize

        for(String a : readStack) { //Display the data read
            System.out.println(a);
        }
    }
}  

导入java.nio.file.*； 公开审判{ 公共静态void main（字符串[]args）{ 字符串[]名称={“A”、“B”、“C”、“D”、“E”}； Stack stringStack=新堆栈（）；//将被序列化的堆栈 Stack readStack=new Stack（）；//将在其中读取数据的堆栈 Path aPath=Path.get（“C:/Documents and Settings/USER/beging Java 7/Stack.txt”）；//文件的路径 对于（字符串名称：名称）{//将数据推入 stringStack.push（名称）； } 对于（字符串a:stringStack）{//显示内容 系统输出打印项次（a）； } stringStack.writeAll（aPath）；//序列化 readStack=（Stack）readStack.readAll（aPath）；//反序列化 对于（字符串a:readStack）{//显示读取的数据 系统输出打印项次（a）； } } } 问题：readAll（）方法的返回类型是否真的提供了灵活性，或者如果我将其更改为

Stack

---

我的逻辑是，写入文件的数据可能是

堆栈的

，因此在回读时可能会导致问题

，编译器无法检查您读取的是

堆栈

，还是

堆栈

。因此，最后，您必须知道堆栈中有什么，并且必须确定堆栈的类型。剩下的是糖

如果你这样离开它，并且你知道你正在读一个

堆栈

，你就必须写

Stack<Integer> stack = (Stack<Integer>) readAll(path);

Stack Stack=（Stack）readAll（path）；

如果你把它写成

public <T> Stack<T> readAll(Path aPath) {...}

public Stack readAll（Path aPath）{…}

编译器可以从变量声明中推断类型，因此您可以编写

Stack<Integer> stack = readAll(path);

Stack-Stack=readAll（路径）；

---

但最终，结果是一样的。当从堆栈中获取整数时，如果它不是一个真正的

堆栈

，您将得到一个异常：

公共堆栈readAll（Path aPath）{…}

下面的public不是必需的，是吗？是的，它是必需的。否则该方法将不是泛型方法，编译器将搜索一个名为t的具体类。对于我的方法

公共堆栈readAll（Path aPath）

，我不需要

，因为它是通配符，对吗？只有当它是

公共堆栈readAll（Path aPath）

时，我才需要

确定我将更改应用于所有构造函数和方法，并且现在将其标记为errorsOh。因此，您正在实现自己的堆栈类。我错过了。为什么不使用标准集合类？无论如何，我不知道你的堆栈是如何实现的，我也不知道错误是什么。。。但是我怀疑您的类已经是泛型的，所以您不需要参数化push方法。