有两段代码是这样的：

A段：

List<String> list1 = new ArrayList<>();
Bear B = new Bear();
for(Apple apple : apples){B.url = apple.url;B.content = apple.content;list1.add(Bear);
}

B段：

List<String> list1 = new ArrayList<>();
for(Apple apple : apples){
Bear B = new Bear();B.url = apple.url;B.content = apple.content;list1.add(Bear);
}

显而易见，这两段代码的区别在于Bear对象的创建的位置不同，第一段代码里面，先创建了一个 Bear 对象 B，然后在循环中不断更新 B 的属性，并将同一个 B 对象多次添加到 list1 中。由于 list1 中存储的是对象的引用，因此最终 list1 中存储的是多个指向同一个 Bear 对象的引用。

而第二段代码中，我们在每次循环中都创建了一个新的 Bear 对象 B，并将其添加到 list1 中。因此，list1 中存储的是多个不同的 Bear 对象的引用。

所以，其实两次list的存储的Bear对象结果会是不同的，第一段代码存了一堆一样的Bear，那么问题来了：我想不重复创建Bear对象，但是也能达到第二段效果，应该怎么做？

答案是使用深度拷贝；

在修复代码之前，深浅度拷贝的定义我们复习下：

浅拷贝（Shallow Copy）：

• 浅拷贝是指在复制对象时，只复制对象本身和其内部引用的对象的引用，而不复制引用的对象本身。
• 在浅拷贝中，新对象和原对象共享内部引用的对象，即新对象和原对象的引用指向同一个内部对象。
• 如果原对象的属性是基本数据类型，那么浅拷贝会复制这些属性的值；如果原对象的属性是引用类型，那么浅拷贝只会复制引用，而不会复制引用指向的对象。

深度拷贝（Deep Copy）：

• 深度拷贝是指在复制对象时，不仅复制对象本身，还会递归复制对象内部引用的对象，直到所有引用的对象都被复制。
• 在深度拷贝中，新对象和原对象的所有引用对象都是独立的，即新对象和原对象的引用指向不同的内部对象。
• 无论原对象的属性是基本数据类型还是引用类型，深度拷贝都会复制所有属性的值或引用指向的对象。

原理比较：

• 浅拷贝只复制对象本身和其内部引用的对象的引用，因此新对象和原对象共享内部引用的对象，可能会导致对象之间的状态相互影响。
• 深度拷贝会递归复制对象内部引用的对象，确保新对象和原对象的所有引用对象都是独立的，避免对象之间的状态相互影响。

那么好，我们基于该原理改造下我们的第一段代码：

首先需要重写Bear对象，重写clone方法：

public class Bear implement Clone{private String url;private String content;//构造函数等省略@Overridepublic Bear clone(){try{Bear cloned = (Bear) super.clone(); // 首先调用父类的 clone 方法进行浅拷贝// 对象的属性进行深度拷贝cloned.url = new String(this.url);cloned.content = new String(this.content);return cloned; }catch(CloneNotSupportedException e){throw new AssertionError();}}}

写完Bear类的clone方法后，就可以用它的clone方法来做对象复制，最终第一段代码改写如下：

List<String> list1 = new ArrayList<>();
Bear originalBear = new Bear(); // 假设有一个原始的 Bear 对象
for(Apple apple : apples){Bear clonedBear = originalBear.clone(); // 使用克隆方法创建新的 Bear 对象clonedBear.url = apple.url;clonedBear.content = apple.content;list1.add(clonedBear);
}

这样修改后，可以避免多次创建新对象，同时确保 list1 中加载不同的 Bear 对象。