我将这个 vector 定义为实例变量以及内部类:
private Vector<MATIdentifier> matIds = new Vector<MATIdentifier>(){
@Override
public boolean add(MATIdentifier mi){
if(this.contains(mi)){
return false;
}
super.add(mi);
return true;
}
@Override
public boolean contains(Object o){
if(o instanceof MATIdentifier){
for(MATIdentifier mi: this){
if(mi.getIdValue().equals(((MATIdentifier)o).getIdValue())){
return true;
}
}
}
return false;
}
};
稍后在程序中，我想从数据库填充这个 vector 。最好创建此 Vector 类的新实例，而不是简单地删除所有元素并重用同一对象 - 我想我可以这样做，但我仍然想了解如何克隆该对象。
我知道如何做到这一点的唯一方法是克隆()这个对象。这安全吗？它会克隆重写的方法 add(MATIdentifier) 和 contains(Object) 吗？
也许我也应该重写clone()...？或者Vector中预定义的clone()方法就足够了？
注意:我自己添加了 @Override 注解，Java 编译器(Eclipse)出于某种原因并没有让我这样做。
最佳答案
这个问题涉及 Java 中的几个概念。
首先，我想问一下，如果你想保证唯一性，为什么不使用 java.util.Set ？
接下来是克隆方法。克隆是 shallow copy或 deep copy原始数据结构？如果我们看一下 Vector API documentation from Oracle ，它告诉我们:
Returns a clone of this vector. The copy will contain a reference to a clone of the internal data array, not a reference to the original internal data array of this Vector object.
所以我们可以从中了解到，首先，它也克隆了内部数据，所以这表明了深度复制。现在，它是否也复制重写的方法？对此的快速测试告诉我，是的，确实如此。
最后，如何测试呢？我建议你使用像junit这样的单元测试框架。 以下是如何使用此框架来确保您的假设正确的示例:
package test.good;
import static org.junit.Assert.*;
import java.util.Vector;
import org.junit.Before;
import org.junit.Test;
public class CloneTest {
private Vector<MATIdentifier> matIds;
MATIdentifier id1 = new MATIdentifier("first");
MATIdentifier id2 = new MATIdentifier("second");
MATIdentifier id3 = new MATIdentifier("third");
MATIdentifier idDuplicate = new MATIdentifier("first");
@Before
public void prepare() {
matIds = new Vector<MATIdentifier>() {
@Override
public boolean add(MATIdentifier mi) {
if (this.contains(mi)) {
return false;
}
super.add(mi);
return true;
}
@Override
public boolean contains(Object o) {
if (o instanceof MATIdentifier) {
for (MATIdentifier mi : this) {
if (mi.getIdValue().equals(((MATIdentifier) o).getIdValue())) {
return true;
}
}
}
return false;
}
};
}
private void populateVector(Vector<MATIdentifier> vector) {
vector.add(id1);
vector.add(id2);
vector.add(id3);
}
/**
* Tests that adding new values returns true, and adding duplicates returns
* false, and that the duplicates are not actually added
*/
@Test
public void testDuplicateFails() {
boolean added;
added = matIds.add(id1);
assertTrue(added);
added = matIds.add(id2);
assertTrue(added);
added = matIds.add(idDuplicate);
assertFalse(added);
assertEquals(2, matIds.size());
}
@Test
public void testDeepCopy() {
// Start with by pupulating our customized vector
populateVector(matIds);
assertEquals(3, matIds.size());
// Clone the vector
Vector<MATIdentifier> clone = (Vector<MATIdentifier>) matIds.clone();
assertEquals(3, clone.size());
// remove something from the original
matIds.remove(2);
assertEquals(3, clone.size());
assertEquals(2, matIds.size());
// add something to the original
matIds.add(new MATIdentifier("New Value"));
assertEquals(3, clone.size());
assertEquals(3, matIds.size());
// add a duplicate to the clone, to ensure that the overridden behavior
// is present in the clone
boolean added = clone.add(id1);
assertFalse(added);
}
}
class MATIdentifier {
private String idValue;
public MATIdentifier(String idValue) {
this.idValue = idValue;
}
public String getIdValue() {
return idValue;
}
public void setIdValue(String idValue) {
this.idValue = idValue;
}
}
PS，最好的做法是覆盖 MATIdentifier 上的 equals 操作或创建 MATIdentifier Comparator而不是创建自定义 contains 并为您的 Vector 添加 impl。我真的建议你使用 java.util.Set。 此外，使用我认为重要的功能创建这样的匿名内部类型并不是一个好的做法，因为它会使您的代码更难以测试。如果您坚持继续使用专门的 Vector 实现，则应该将其移至一个类中。
关于java - 克隆内部类定义的对象，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/18514425/