拆分Java方法并复用同一列表：可行方案及适配设计模式咨询

问题背景 #

现有如下简化的Java方法，负责从两种DataSet中生成Person列表，实际逻辑会用到a、b变量做更多处理：

public static List<Person> getPersons(String a, int b, DataSetX dataSetX, DataSetY dataSetY) {
    List<Person> persons = new ArrayList<>();
    
    if(dataSetX != null) {
        while (dataSetX.hasNext()) {
            // 创建具有特定属性的Person实例                
            persons.add(processX(dataSetX.next()));
        }
    }

    if(dataSetY != null) {
        while (dataSetY.hasNext()) {
           // 创建具有特定属性的Person实例               
            persons.add(processY(dataSetY.next()));
        }
    }
    return persons;        
} 

你尝试拆分出单独处理DataSetX的方法，但调用方式语义模糊、易出错：

// 拆分后的方法
public static List<Person> getPersons(String a, DataSetX dataSetX, List<Person> persons) {
    if(dataSetX != null) {
        while (dataSetX.hasNext()) {
            // 创建具有特定属性的Person实例
            persons.add(processX(dataSetX.next()));
        }
    }
    return persons;
}

// 调用方式
List<Person> persons = getPersons(a, dataSetX, new ArrayList<Person>());
getPersons(a, dataSetX, persons);    

优化方案 #

1. 语义明确的填充方法拆分 #

核心是把"往列表填充数据"的逻辑拆分为独立的void方法，方法名直接体现作用，避免返回值带来的误解：

// 专门处理DataSetX，往传入的列表填充Person
public static void fillPersonsFromDataSetX(String a, int b, DataSetX dataSetX, List<Person> persons) {
    if (dataSetX == null) {
        return;
    }
    while (dataSetX.hasNext()) {
        // 这里可结合a、b做自定义处理
        persons.add(processX(dataSetX.next()));
    }
}

// 专门处理DataSetY，往传入的列表填充Person
public static void fillPersonsFromDataSetY(String a, int b, DataSetY dataSetY, List<Person> persons) {
    if (dataSetY == null) {
        return;
    }
    while (dataSetY.hasNext()) {
        // 这里可结合a、b做自定义处理
        persons.add(processY(dataSetY.next()));
    }
}

// 原方法重构为协调入口，复用同一列表
public static List<Person> getPersons(String a, int b, DataSetX dataSetX, DataSetY dataSetY) {
    List<Person> persons = new ArrayList<>();
    fillPersonsFromDataSetX(a, b, dataSetX, persons);
    fillPersonsFromDataSetY(a, b, dataSetY, persons);
    return persons;
}

这种方式既拆分了逻辑，又保证始终复用同一个列表，无需合并，调用语义清晰，不会出现重复调用或传参错误。

2. 适配设计模式：策略模式（支持扩展） #

如果后续可能新增更多DataSet类型，可使用策略模式抽象处理逻辑，符合开闭原则：

// 抽象处理器接口，定义统一处理契约
interface DataSetPersonProcessor {
    void process(String a, int b, List<Person> targetList);
}

// DataSetX的具体处理器
class DataSetXProcessor implements DataSetPersonProcessor {
    private final DataSetX dataSetX;

    public DataSetXProcessor(DataSetX dataSetX) {
        this.dataSetX = dataSetX;
    }

    @Override
    public void process(String a, int b, List<Person> targetList) {
        if (dataSetX == null) return;
        while (dataSetX.hasNext()) {
            targetList.add(processX(dataSetX.next()));
        }
    }
}

// DataSetY的具体处理器
class DataSetYProcessor implements DataSetPersonProcessor {
    private final DataSetY dataSetY;

    public DataSetYProcessor(DataSetY dataSetY) {
        this.dataSetY = dataSetY;
    }

    @Override
    public void process(String a, int b, List<Person> targetList) {
        if (dataSetY == null) return;
        while (dataSetY.hasNext()) {
            targetList.add(processY(dataSetY.next()));
        }
    }
}

// 重构后的入口方法，可灵活扩展处理器
public static List<Person> getPersons(String a, int b, DataSetX dataSetX, DataSetY dataSetY) {
    List<Person> persons = new ArrayList<>();
    // 可根据需求动态添加处理器
    List<DataSetPersonProcessor> processors = Arrays.asList(
            new DataSetXProcessor(dataSetX),
            new DataSetYProcessor(dataSetY)
    );
    for (DataSetPersonProcessor processor : processors) {
        processor.process(a, b, persons);
    }
    return persons;
}

后续新增DataSet类型时，只需新增对应的处理器实现类，无需修改getPersons方法，扩展性更强。

内容的提问来源于stack exchange，提问作者Jim