如何让Java方法根据输入列表类型返回对应类型列表并复用逻辑？

核心思路 #

通过接口统一属性访问+策略模式管理类型转换，实现核心映射逻辑的复用，同时避免硬编码分支和冗余包装类。

具体实现步骤 #

1. 定义通用属性接口 #

让所有输入元素类实现该接口，统一获取共同属性（比如示例中的name）：

public interface HasName {
    String getName();
}

// 输入元素类实现接口
public class Cat implements HasName {
    private String name;

    // 构造器、getter等
    @Override
    public String getName() {
        return name;
    }
}

public class Dog implements HasName {
    private String name;

    @Override
    public String getName() {
        return name;
    }
}

2. 维护类型映射策略 #

用一个Map存储「输入元素类型 → 转换函数」的映射，新增类型时仅需添加映射关系：

import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

public class MapperService {
    // 注册所有支持的类型转换规则
    private static final Map<Class<? extends HasName>, Function<HasName, ?>> TYPE_MAPPERS = Map.of(
            Cat.class, cat -> Kitten.builder().name(cat.getName()).build(),
            Dog.class, dog -> Puppy.builder().name(dog.getName()).build()
            // 新增Bird→Chick时，只需添加：Bird.class, bird -> Chick.builder().name(bird.getName()).build()
    );

    @SuppressWarnings("unchecked")
    public <S> List<S> foo(List<? extends HasName> items) {
        if (items.isEmpty()) {
            return List.of();
        }

        // 根据元素类型获取对应的转换函数
        Class<? extends HasName> itemType = items.get(0).getClass();
        Function<HasName, S> mapper = (Function<HasName, S>) TYPE_MAPPERS.get(itemType);
        
        if (mapper == null) {
            throw new IllegalArgumentException("不支持的输入类型：" + itemType.getName());
        }

        // 复用核心映射逻辑
        return items.stream()
                .map(mapper)
                .collect(Collectors.toList());
    }
}

3. 输出类示例 #

以Kitten和Puppy为例，保持常规的Builder模式即可：

public class Kitten {
    private String name;

    private Kitten() {}

    public static Kitten builder() {
        return new Kitten();
    }

    public Kitten name(String name) {
        this.name = name;
        return this;
    }

    public Kitten build() {
        return this;
    }
}

// Puppy类实现类似，省略

方案优势 #

• 逻辑复用：核心的stream映射代码仅需编写一次，所有类型共享
• 扩展性强：新增类型时无需修改foo方法，仅需添加一行映射规则，符合开闭原则
• 无冗余代码：不需要创建专门的列表包装类，避免类膨胀
• 类型安全：通过接口和泛型约束，减少类型转换风险

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