在 Java 中保留泛型的封装

Question

晚上好。

我有一个相当复杂的问题。为了练习 Java，我一直在重新实现标准库中的一些数据结构。 Stacks、LinkedLists、Trees 等。我刚刚通过一个非常简单的示例确定，当使用peek() 或pop() 方法时，java.util.Stack 类执行深层复制。这是可以理解的，因为目标是保护课程内容免受外界干扰。到目前为止，在我自己的 Stack 实现中（一个简单的数组的幼稚实现，链表会在后面出现），我根本没有关心这个：

public class ArrayStack<T> implements Stack<T> {
    private T[] data; // Will expand the array when stack is full.
    private int top; // serves as both top and count indicator.
    ...
    ...
   @Override
   public T pop() throws EmptyStackException {
    if(top == -1)
        throw new EmptyStackException("Stack is empty.");
    return data[top--]; // Shallow copy, dangerous!
}

不幸的是，由于无法实例化泛型，因此我不能假设复制构造函数并执行 return new T(data[top--]); 之类的事情clone() 的变体。 This 线程建议将类的签名扩展为：

public class ArrayStack<T extends DeepCloneableClass> implements Stack<T>
...

其中DeepCloneableClass 是一个实现允许“深度克隆”的接口的类（有关详细信息，请参阅该线程中的顶部响应）。当然，这种方法的问题在于，我真的不能指望String 或Integer 等标准类扩展我的自定义类，当然，我所有现有的 jUnit 测试现在都是在编译时抱怨，因为它们依赖于这样的整数和字符串堆栈。所以我觉得这个解决方案不可行。

This 线程建议使用第三方库来克隆几乎任何对象。虽然这个库似乎仍然受支持（最新的错误修复日期不到一个月前），但我宁愿不依赖第三方工具，而是使用 Java 可以为我提供的任何东西。原因是这些 ADT 的源代码有朝一日可能会与本​​科生共享，我不希望他们承担安装额外工具的负担。

因此，我正在寻找一种简单且尽可能有效的方法来维护通用 Java 数据结构的内部完整性，同时仍然允许与 pop()、peek()、popFront() 等方法的简单接口.

非常感谢您的帮助！

杰森

Answer 1

为什么需要克隆对象？

您的堆栈只有一个引用集合。您可能不需要克隆它们，只需创建一个新数组并将适当的引用放入其中，然后丢弃旧数组即可。

Answer 2

Integer、Strings 等都是不可变的，因此它们的内容在设计上是安全的。

对于自定义对象，虽然有经验的 Java 程序员肯定会对此有不同的感受，但implementing a custom interface 无疑是解决问题的一种方法。

另一种是制作<T extends Serializable>（由Integer、String等实现）和"clone" through serialization。

但是，如果您想以“正确的方式”教您的学生，我肯定会使用第三方库...您只需在项目中创建一个 lib 文件夹并配置您的构建工具/IDE 以将所需的 jar 添加到Classpath 使用相对路径，因此您的本科生无需安装或设置任何东西。

仅供参考，this question 可能很有用。

我一直在使用这种方法教授 Java 入门课程（作为 IT 讲师/不是作为大学教授），而且它不像听起来那么痛苦。

Answer 3

cmets 帮助我了解我做错了什么。我正在使用以下示例向自己和其他人“证明”Java 标准库的集合在提供对集合中对象的引用时会进行深层复制：

import java.util.Stack;

public class StackTestDeepCopy {
    public static void main(String[] args){
        Stack<String> st = new Stack<String>();
        st.push("Jim");
        st.push("Jill");
        String top = st.peek();
        top = "Jack";
        System.out.println(st); 
    }
}

打印 st 时，我看到对象没有改变，并得出结论，发生了深拷贝。错误的！ Strings 是不可变的，因此声明 top = "Jack" 不会以任何方式修改 String （并不是说任何 Object 都会被这样的声明“修改”，但我没有直截了当） ，它只是将参考点指向堆上的一个新位置。一个涉及实际可变类的新示例使我以自己的方式理解了错误。

现在这个问题已经解决了，我对标准库允许这样做的事实感到很困惑。为什么访问标准库中的元素被实现为浅拷贝？听起来很不安全。

Answer 4

java.util.Stack 不做深拷贝：

import java.util.Stack;
public class Test {
    String foo;
    public static void main(String[] args) {
        Test test = new Test();
        test.foo = "bar";
        Stack<Test> stack = new Stack<Test>();
        stack.push(test);
        Test otherTest = stack.pop();
        otherTest.foo = "wibble";
        System.out.println("Are the same object: "+(test.foo == otherTest.foo));
    }
}

结果：

Are the same object: true

如果它确实进行了复制，那么 test 和 otherTest 将指向不同的对象。典型的堆栈实现只是返回对添加到堆栈中的同一对象的引用，而不是副本。

---

您可能还希望在返回之前将数组项设置为 null，否则该数组仍将持有对该对象的引用。