有人可以解釋深層複製和防禦性複製之間的區別嗎？

Question

我的教授說他們完全不同，但我讀他們很相似。我不知道他指的是什麼背景「不同」。 如果這個問題已經被回答，只是鏈接它。謝謝。

Answer 1

深層複製：一種對象複製技術：深層複製結構中的所有數據。產生對象的深層副本的「苛刻」方法是序列化然後反序列化它。對於樹木，通常遞歸複製是一種有效的解決方案。

防禦性拷貝：保護內部數據的操作結果。通常它是一個深度或淺度的副本，用於防止通過內部參考結果進行不必要的訪問。

From this article:

public int[] getValues() { 
    return Arrays.copyOf(values, values.length); 
} 

在一般情況下，你應該使用防禦性副本，以保護內部數組，集合或其他結構。如果我們簡單地返回（對數組的引用），用戶可以修改我們的內部結構！

查看示例。

湯姆寫了一個類懶洋洋緩存的Integer收集的一些彙總：

public class CachedIntegerAggregator { 

    private List<Integer> integers; 

    private boolean isSumCalculated = false; 
    private int sum = 0; 

    private boolean isMultiCalculated = false; 
    private int multi = 0; 

    public CachedIntegerAggregator(Integer... integers) { 
     this(Arrays.asList(integers)); 
    } 

    public CachedIntegerAggregator(Collection<Integer> integers) { 
     this.integers = new ArrayList<Integer>(integers); 
    } 

    public List<Integer> getIntegers() { 
     return integers; 
    } 

    public int getSum() { 
     if (!isSumCalculated) { 
      sum = 0; 
      for (Integer integer: integers) { 
       sum += integer; 
      } 
      isSumCalculated = true; 
     } 
     return sum; 
    } 

    public int getMulti() { 
     if (!isMultiCalculated) { 
      multi = 1; 
      for (Integer integer: integers) { 
       multi *= integer; 
      } 
      isMultiCalculated = true; 
     } 
     return multi; 
    } 

} 

傑裏使用上述類以這樣的方式

CachedIntegerAggregator aggregator = new CachedIntegerAggregator(2, 3, 4); 

// hm, what is the sum? 
System.out.println(aggregator.getSum()); 

// let's print of integers 
List<Integer> integers = aggregator.getIntegers(); 
System.out.println(integers); 

// now, see the double 
int size = integers.size(); 
for (int i = 0; i < size; i++) { // (oops! this changes internal data!) 
    integers.set(i, integers.get(i) * 2); 
} 
System.out.println(integers); 

// hm, see sum and multi 
System.out.println(aggregator.getSum()); 
System.out.println(aggregator.getMulti()); // (oops! total inconsistency!) 

輸出：

9 
[2, 3, 4] 
[4, 6, 8] 
9 
192 

主要問題是什麼？湯姆泄漏了一個可變的內部結構。解決辦法是什麼？在getIntegers()做它的一個副本返回之前：

public List<Integer> getIntegers() { 
    return new ArrayList<Integer>(integers); 
} 

在某些情況下，一個不可變的包裝是對子級也沒錯：

public List<Integer> getIntegers() { 
    return Collections.unmodifiableList(integers); 
} 

性能？一般來說，不要擔心。快速創建對象是Java的主要優勢之一。當然，有複雜的結構，將被低效地複製。在這種情況下，您可以使用寫入時複製技術。一些大數據結構實現已經建立在寫入時複製支持上，如BigList。