Java中不同类型ArrayList之间的数据复制策略

// 类 A 的定义
public class A {
    private String p;
    private String q;
    // 可能包含其他字段，例如 private ClassX x;

    public A(String p, String q) {
        this.p = p;
        this.q = q;
    }

    public String getP() {
        return p;
    }

    public String getQ() {
        return q;
    }
}

// 类 B 的定义
public class B {
    private String p;
    private String q;
    // 可能包含其他字段，例如 private ClassY y;

    public B(String p, String q) { // B 类通常需要一个构造函数来接收初始化数据
        this.p = p;
        this.q = q;
    }

    // 为了验证，可以添加getter方法
    public String getP() {
        return p;
    }

    public String getQ() {
        return q;
    }
}

import java.util.ArrayList;
import java.util.List;

public class ListConversionExample {

    public static void main(String[] args) {
        // 1. 初始化源 List<A> 并填充数据
        List<A> aClassList = new ArrayList<>();
        aClassList.add(new A("A_p_val_1", "A_q_val_1"));
        aClassList.add(new A("A_p_val_2", "A_q_val_2"));
        aClassList.add(new A("A_p_val_3", "A_q_val_3"));

        // 2. 初始化目标 List<B>
        List<B> bClassList = new ArrayList<>();

        // 3. 遍历 aClassList，将数据转换为 B 类型并添加到 bClassList
        for (A a : aClassList) {
            // 从 A 对象中获取相关数据，并用于创建新的 B 对象实例
            // 这里假设 B 的构造函数与 A 的 getter 方法返回的类型匹配
            bClassList.add(new B(a.getP(), a.getQ()));
        }

        // 4. 验证转换结果（可选）
        System.out.println("--- 原始 A 对象列表 ---");
        for (A a : aClassList) {
            System.out.println("A: p=" + a.getP() + ", q=" + a.getQ());
        }

        System.out.println("\n--- 转换后的 B 对象列表 ---");
        for (B b : bClassList) {
            System.out.println("B: p=" + b.getP() + ", q=" + b.getQ());
        }
    }
}

// 嵌套类 X
public class X {
    private String r;
    private String s;
    public X(String r, String s) { this.r = r; this.s = s; }
    public String getR() { return r; }
    public String getS() { return s; }
}

// 嵌套类 Y
public class Y {
    private String r;
    private String s;
    public Y(String r, String s) { this.r = r; this.s = s; }
    public String getR() { return r; }
    public String getS() { return s; }
}

// 更新 A 类，包含 X 类型的字段
public class A {
    private String p;
    private String q;
    private X xField; // 包含 ClassX 对象

    public A(String p, String q, X xField) {
        this.p = p;
        this.q = q;
        this.xField = xField;
    }
    public String getP() { return p; }
    public String getQ() { return q; }
    public X getXField() { return xField; }
}

// 更新 B 类，包含 Y 类型的字段
public class B {
    private String p;
    private String q;
    private Y yField; // 包含 ClassY 对象

    public B(String p, String q, Y yField) {
        this.p = p;
        this.q = q;
        this.yField = yField;
    }
    public String getP() { return p; }
    public String getQ() { return q; }
    public Y getYField() { return yField; }
}

// 假设 aClassList 已经填充了包含 X 对象的 A 实例
List<A> aClassListWithNested = new ArrayList<>();
aClassListWithNested.add(new A("P1", "Q1", new X("R1", "S1")));
aClassListWithNested.add(new A("P2", "Q2", null)); // 模拟嵌套对象可能为空

List<B> bClassListWithNested = new ArrayList<>();

for (A a : aClassListWithNested) {
    Y yInstance = null;
    if (a.getXField() != null) {
        // 递归地将 ClassX 转换为 ClassY
        yInstance = new Y(a.getXField().getR(), a.getXField().getS());
    }
    // 使用转换后的 Y 实例创建 B 对象
    bClassListWithNested.add(new B(a.getP(), a.getQ(), yInstance));
}

import java.util.stream.Collectors;

// ... (假设 aClassList 已经初始化) ...

List<B> bClassListStream = aClassList.stream()
                                     .map(a -> new B(a.getP(), a.getQ())) // 对每个 A 对象进行映射转换
                                     .collect(Collectors.toList());      // 收集结果到新的 List<B>