Java泛型下如何创建对应实现类的空List<String>？

嘿，这个需求我之前也碰到过——要写一个通用的List过滤方法，还得保留原List的具体实现类型（比如原先是ArrayList过滤后还是ArrayList，LinkedList过滤后还是LinkedList），核心难点就是如何动态创建泛型T的实例，因为Java的泛型擦除机制让我们没法直接用new T()。下面给你几种可行的解决方案：

方案一：利用反射创建同类型实例 #

这种方法依赖List实现类的公共无参构造器，标准库中的ArrayList、LinkedList都满足这个条件，代码如下：

import java.lang.reflect.InvocationTargetException;
import java.util.List;
import java.util.function.Predicate;

public class ListFilter {
    public static <T extends List<String>> T filterList(T list, Predicate<String> predicate) {
        try {
            // 通过反射获取原列表的无参构造器，创建空实例
            T newList = list.getClass().getDeclaredConstructor().newInstance();
            list.forEach(s -> {
                if (predicate.test(s)) {
                    newList.add(s);
                }
            });
            return newList;
        } catch (InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
            // 构造失败时抛出运行时异常，或者根据需求返回默认实现（比如new ArrayList<>()）
            throw new RuntimeException("无法创建" + list.getClass().getSimpleName() + "实例", e);
        }
    }
}

注意点： #

• 如果传入的是不可变List（比如List.of()返回的实例），调用add方法会抛出UnsupportedOperationException，所以需要确保传入的是可变List，或者在方法里添加判断逻辑。
• 自定义List实现如果没有公共无参构造器，这种方法会失效。

方案二：让调用者提供列表供应器（更推荐） #

这种方式完全避免了反射的依赖，让调用者明确指定如何创建新的List实例，灵活性和安全性更高，符合Java函数式编程风格：

import java.util.List;
import java.util.function.Predicate;
import java.util.function.Supplier;

public class ListFilter {
    public static <T extends List<String>> T filterList(T list, Predicate<String> predicate, Supplier<T> listSupplier) {
        T newList = listSupplier.get();
        list.stream()
            .filter(predicate)
            .forEach(newList::add);
        return newList;
    }
}

调用示例： #

// 过滤ArrayList
ArrayList<String> originalArrayList = new ArrayList<>(List.of("apple", "banana", "cherry"));
ArrayList<String> filteredArrayList = ListFilter.filterList(originalArrayList, s -> s.startsWith("a"), ArrayList::new);

// 过滤LinkedList
LinkedList<String> originalLinkedList = new LinkedList<>(List.of("red", "green", "blue"));
LinkedList<String> filteredLinkedList = ListFilter.filterList(originalLinkedList, s -> s.length() == 3, LinkedList::new);

优势： #

• 不需要依赖反射，没有反射的性能开销和异常风险。
• 支持需要特殊构造参数的自定义List实现（比如带初始容量的ArrayList），调用者可以灵活指定创建逻辑。

方案三：结合Stream API简化实现 #

如果你的项目使用Java 8+，可以结合Stream的collect方法来简化代码，同样可以搭配反射或Supplier：

搭配反射的Stream版本： #

import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class ListFilter {
    public static <T extends List<String>> T filterList(T list, Predicate<String> predicate) {
        return list.stream()
            .filter(predicate)
            .collect(Collectors.toCollection(() -> {
                try {
                    return list.getClass().getDeclaredConstructor().newInstance();
                } catch (ReflectiveOperationException e) {
                    throw new RuntimeException("创建列表实例失败", e);
                }
            }));
    }
}

搭配Supplier的Stream版本： #

import java.util.List;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Collectors;

public class ListFilter {
    public static <T extends List<String>> T filterList(T list, Predicate<String> predicate, Supplier<T> listSupplier) {
        return list.stream()
            .filter(predicate)
            .collect(Collectors.toCollection(listSupplier));
    }
}

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