在java开发中，经常会遇到需要将一个列表（arraylist）中的数据转换并拷贝到另一个列表的场景，特别是当这两个列表存储的对象类型不同，但它们之间存在业务上的关联或部分属性共享时。例如，从一个数据访问对象（dao）列表转换为一个业务逻辑对象（bo）列表，或从一个bo列表转换为一个视图对象（vo）列表。由于对象类型不匹配，我们不能简单地通过赋值操作（如 bclass = aclass;）来完成，而是需要逐个元素进行转换和拷贝。
场景描述
假设我们有两个自定义类 A 和 B，它们都包含 p 和 q 两个字符串属性。此外，A 类还包含一个 ClassX 类型的对象 x，而 B 类包含一个 ClassY 类型的对象 y。ClassX 和 ClassY 结构相似，都包含 r 和 s 两个字符串属性。我们的目标是将 List 中的数据转换并拷贝到 List 中。
// 辅助类 X 和 Y
class ClassX {
private String r;
private String s;
public ClassX(String r, String s) {
this.r = r;
this.s = s;
}
public String getR() { return r; }
public String getS() { return s; }
// Setter 略
}
class ClassY {
private String r;
private String s;
public ClassY(String r, String s) {
this.r = r;
this.s = s;
}
public String getR() { return r; }
public String getS() { return s; }
// Setter 略
}
// 源对象类 A
class A {
private String p;
private String q;
private ClassX x;
public A(String p, String q, ClassX x) {
this.p = p;
this.q = q;
this.x = x;
}
public String getP() { return p; }
public String getQ() { return q; }
public ClassX getX() { return x; }
// Setter 略
}
// 目标对象类 B
class B {
private String p;
private String q;
private ClassY y;
public B(String p, String q, ClassY y) {
this.p = p;
this.q = q;
this.y = y;
}
public String getP() { return p; }
public String getQ() { return q; }
public ClassY getY() { return y; }
// Setter 略
}假设我们有一个已填充数据的 List：
List aClass = new ArrayList<>(); aClass.add(new A("p1_A", "q1_A", new ClassX("r1_X", "s1_X"))); aClass.add(new A("p2_A", "q2_A", new ClassX("r2_X", "s2_X"))); // ... 更多数据
我们的目标是创建一个 List 并将 aClass 中的数据转换后拷贝进去。
核心拷贝策略：迭代与构造
最直接且常用的方法是遍历源列表，为每个源对象创建一个目标对象的新实例，并将相应的属性值从源对象复制到目标对象。这通常通过目标类的构造函数或通过设置器（setter）方法完成。
立即学习“Java免费学习笔记（深入）”；
1. 使用 For-Each 循环
通过增强型 for 循环遍历 List，并在循环体内创建 B 的实例。在创建 B 的实例时，我们需要将 A 中的 p 和 q 属性值传递给 B 的构造函数。对于嵌套对象 ClassX 到 ClassY 的转换，我们也需要类似地创建一个 ClassY 的新实例，并传递 ClassX 的属性。
import java.util.ArrayList;
import java.util.List;
public class ListCopyExample {
public static void main(String[] args) {
// 示例数据
List aClass = new ArrayList<>();
aClass.add(new A("p1_A", "q1_A", new ClassX("r1_X", "s1_X")));
aClass.add(new A("p2_A", "q2_A", new ClassX("r2_X", "s2_X")));
aClass.add(new A("p3_A", "q3_A", null)); // 演示嵌套对象可能为空的情况
// 目标列表
List bClass = new ArrayList<>();
// 使用 for-each 循环进行拷贝和转换
for (A a : aClass) {
// 转换 ClassX 到 ClassY
ClassY newY = null;
if (a.getX() != null) {
newY = new ClassY(a.getX().getR(), a.getX().getS());
}
// 创建 B 的新实例并添加
bClass.add(new B(a.getP(), a.getQ(), newY));
}
// 验证拷贝结果
System.out.println("Original List A:");
aClass.forEach(a -> System.out.println(" P: " + a.getP() + ", Q: " + a.getQ() + ", X: " + (a.getX() != null ? (a.getX().getR() + "," + a.getX().getS()) : "null")));
System.out.println("\nCopied List B:");
bClass.forEach(b -> System.out.println(" P: " + b.getP() + ", Q: " + b.getQ() + ", Y: " + (b.getY() != null ? (b.getY().getR() + "," + b.getY().getS()) : "null")));
}
}2. 使用 Java Stream API
Java 8 引入的 Stream API 提供了一种更函数式和简洁的方式来处理集合操作，包括转换和收集。map 操作可以用来将流中的每个元素转换成另一种类型，然后 collect 操作将转换后的元素收集到一个新的列表中。
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class StreamListCopyExample {
public static void main(String[] args) {
List aClass = new ArrayList<>();
aClass.add(new A("p1_A", "q1_A", new ClassX("r1_X", "s1_X")));
aClass.add(new A("p2_A", "q2_A", new ClassX("r2_X", "s2_X")));
aClass.add(new A("p3_A", "q3_A", null));
List bClass = aClass.stream()
.map(a -> {
ClassY newY = null;
if (a.getX() != null) {
newY = new ClassY(a.getX().getR(), a.getX().getS());
}
return new B(a.getP(), a.getQ(), newY);
})
.collect(Collectors.toList());
// 验证拷贝结果（同上）
System.out.println("Original List A:");
aClass.forEach(a -> System.out.println(" P: " + a.getP() + ", Q: " + a.getQ() + ", X: " + (a.getX() != null ? (a.getX().getR() + "," + a.getX().getS()) : "null")));
System.out.println("\nCopied List B:");
bClass.forEach(b -> System.out.println(" P: " + b.getP() + ", Q: " + b.getQ() + ", Y: " + (b.getY() != null ? (b.getY().getR() + "," + b.getY().getS()) : "null")));
}
}Stream API 的方法在代码量和可读性上通常优于传统的 for 循环，尤其是在进行链式操作时。
注意事项与最佳实践
-
深拷贝与浅拷贝：
- 上述示例中，对于 p 和 q 这类基本类型或不可变对象（如 String），是值拷贝，属于深拷贝的一部分。
- 对于 ClassX 到 ClassY 的转换，我们创建了 new ClassY(...)，这意味着 B 中的 y 引用了一个全新的 ClassY 实例，而不是 A 中 x 的引用，这也是深拷贝。
- 如果 ClassX 或 ClassY 内部还包含复杂对象，并且这些复杂对象也需要独立拷贝而不是共享引用，那么也需要对它们进行递归的深拷贝。
- 重要提示： 如果直接将 a.getX() 赋值给 b.setY(a.getX()) (假设 B 有 setY(ClassX x) 方法)，那么 b.y 和 a.x 将会指向同一个 ClassX 实例。如果 ClassX 是可变对象，修改 a.x 将会影响 b.y，这通常不是我们期望的“拷贝”行为，而是浅拷贝。在大多数数据转换场景中，我们期望的是深拷贝。
-
属性映射复杂性：
- 当源对象和目标对象的属性名称、类型或结构差异较大时，手动编写映射逻辑会变得复杂且容易出错。
- 对于简单的、一对一的属性映射，上述迭代方法足够有效。
- 对于更复杂的场景，例如需要进行类型转换、属性名称不匹配（如 A.id 映射到 B.uuid）、或需要合并多个源属性到目标的一个属性等，可以考虑使用专门的Bean映射库。
-
使用 Bean 映射库：
- ModelMapper, Orika, MapStruct 等是流行的Java Bean映射库。它们能够自动化对象之间的属性拷贝和转换，减少手动编写大量重复代码。
- ModelMapper 运行时通过反射进行映射，配置灵活。
- MapStruct 在编译时生成映射代码，性能接近手动编写，且类型安全。
- 这些库特别适用于大型项目，其中存在大量DTO（Data Transfer Object）、VO（View Object）和实体类之间的转换。
例如，使用 ModelMapper 的大致思路：
// 引入 ModelMapper 依赖 // ModelMapper modelMapper = new ModelMapper(); // List bClass = aClass.stream() // .map(a -> modelMapper.map(a, B.class)) // .collect(Collectors.toList()); // 注意：ModelMapper 默认进行浅拷贝，对于嵌套对象 ClassX 到 ClassY， // 需要配置自定义的 Converter 或 TypeMap 来处理深拷贝或类型转换。
-
性能考量：
- 对于小到中等规模的列表，for 循环和 Stream API 的性能差异通常可以忽略不计。
- 对于非常大的列表，手动编写的 for 循环在某些情况下可能略优于 Stream API（因为 Stream 引入了一些抽象层开销），但通常不是性能瓶颈的主要来源。
- Bean 映射库的性能取决于其实现方式（反射 vs. 代码生成）。MapStruct 通常被认为是性能最好的。
-
健壮性：
- 在进行属性拷贝时，务必处理好 null 值。例如，在转换 a.getX() 到 newY 时，先检查 a.getX() 是否为 null，以避免 NullPointerException。
- 考虑属性类型不匹配时的异常处理或默认值设置。
总结
将数据从一个 ArrayList 拷贝到另一个不同对象类型的 ArrayList 是Java开发中的常见任务。通过传统的 for 循环或现代的 Stream API 结合构造函数或 setter 方法，可以有效地实现这一目标。在处理嵌套对象时，应特别注意深拷贝的需求，以避免意外的副作用。对于复杂或频繁的映射场景，引入专业的Bean映射库可以显著提高开发效率和代码的可维护性。选择哪种方法取决于项目的具体需求、团队偏好以及映射逻辑的复杂程度。
