Java 创建空列表<；字符串>；基于泛型

因此，我目前正在尝试实现一种方法，该方法对列表进行一些过滤，而不考虑它们的实际类型。以下是实际的方法：

public static <T extends List<String>> T filterList(T list, Predicate <String> predicate) {

    T newList = ???
    list.forEach(s -> {
        if (predicate.test(s)) newList.add(s);
    });
    return newList;

}

publicstatict过滤器列表（T列表，谓词）{
T newList=？？？
列表。forEach（s->{
if（predicate.test）newList.add（s）；
});
返回newList；
}

所以泛型类型T基本上是List的一些实现，比如ArrayList或LinkedList，不管它们的实际实现如何，我想通过作为参数传递的谓词进行一些过滤。方法的返回类型与作为参数传递的列表相同。但是，如何能够基于T实例化空列表（参见第2行）？ 为了向您展示如何使用该方法，我提供了一个示例。以下示例将根据包含字符串的长度筛选ArrayList：

ArrayList<String> listOfNames = new ArrayList<>();
listOfNames.add("stackoverflowuser");
listOfNames.add("sitaguptana");
listOfNames.add("nyan cat");
listOfNames.add("pedro");

Predicate<String> lengthUnderTen = (string) -> string.length() < 10;

ArrayList <String> result = filterList(listOfNames,lengthUnderTen);

ArrayList listOfNames=new ArrayList（）；
添加（“stackoverflowuser”）；
名称列表。添加（“sitaguptana”）；
名称列表。添加（“年猫”）；
名称列表。添加（“pedro”）；
谓词lengtunderten=（string）->string.length（）<10；
ArrayList结果=过滤器列表（名称列表，长度）；

如果您可以将方法修改为

public static <T> List<T> filterList(List<T> list, Predicate<T> predicate) {

    return list.stream().filter(predicate).collect(Collectors.toList());
}

公共静态列表过滤器列表（列表列表，谓词）{
return list.stream（）.filter（谓词）.collect（收集器.toList（））；
}

---

它看起来很干净，因为它适用于任何类型的列表，而不仅仅是列表。此方法将更加通用。

让调用方也传入一个

供应商

public static <T extends List<String>> T filterList(T list, Predicate <String> predicate, Supplier<T> listCreator) {

    T newList = listCreator.get();
    list.forEach(s -> {
       // ...

公共静态T过滤器列表（T列表、谓词谓词、供应商列表创建者）{
T newList=listCreator.get（）；
列表。forEach（s->{
// ...
如果我正确理解了您的问题，那么我不明白您为什么需要在这里使用泛型

以下函数将接受扩展列表的任何类作为参数，例如ArrayList、LinkedList等：

public static List<String> filterList(List<String> list, Predicate<String> predicate) {
    return list.stream().filter(predicate).collect(Collectors.toList());
}

公共静态列表过滤器列表（列表列表，谓词）{
return list.stream（）.filter（谓词）.collect（收集器.toList（））；
}

完整示例：

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

public class Example {

    public static void main(String[] args) {
        ArrayList<String> example1 = new ArrayList<>();
        example1.add("abc");
        example1.add("ghe");

        LinkedList<String> example2 = new LinkedList<>();
        example2.add("foo");
        example2.add("bar");

        List<String> result1 = filterList(example1, s -> s.contains("a"));
        List<String> result2 = filterList(example2, s -> s.contains("f"));
    }

    public static List<String> filterList(List<String> list, Predicate<String> predicate) {
        return list.stream().filter(predicate).collect(Collectors.toList());
    }
}

import java.util.ArrayList；
导入java.util.LinkedList；
导入java.util.List；
导入java.util.function.Predicate；
导入java.util.stream.collector；
公开课范例{
公共静态void main（字符串[]args）{
ArrayList example1=新的ArrayList（）；
例1.添加（“abc”）；
例1.添加（“ghe”）；
LinkedList example2=新建LinkedList（）；
例2.添加（“foo”）；
例2.添加（“条”）；
List result1=filterList（示例1，s->s.contains（“a”）；
List result2=filterList（示例2，s->s.contains（“f”）；
}
公共静态列表过滤器列表（列表列表，谓词）{
return list.stream（）.filter（谓词）.collect（收集器.toList（））；
}
}
通过将
列表作为参数传递，可以通过反射创建类。

事实上，您不需要为列表指定任何通配符

public static List<String> filterList(List<String> list,  Predicate<String> predicate) throws InstantiationException, IllegalAccessException {

    List<String> newList = list.getClass()
                               .newInstance();
    list.forEach(s -> {
        if (predicate.test(s)) newList.add(s);
    });
    return  newList;
}

public static List filterList（列表列表，谓词谓词）抛出实例化异常，IllegalAccessException{
List newList=List.getClass（）
.newInstance（）；
列表。forEach（s->{
if（predicate.test）newList.add（s）；
});
返回newList；
}

但请注意，如果实现不重要，则更干净的方法是使用流来收集新列表：

public static List<String> filterList(List<String> list,  Predicate<String> predicate) throws InstantiationException, IllegalAccessException {

  return list.stream()
             .filter(predicate)
             .collect(Collectors.toList());
}

public static List filterList（列表列表，谓词谓词）抛出实例化异常，IllegalAccessException{
return list.stream（）
.filter（谓词）
.collect（Collectors.toList（））；
}
您有一个基类，它已经允许您对接口进行干净的编程。您可以将此API方法设计为返回
列表
对象，将泛型类型保持在元素级别

请注意，此模式已经由标准API（列表/集合+流）提供，因此您不需要重新创建它。-请参阅底部的注释

如果您对该方法返回的列表类型没有任何约束，则该实现可以选择返回的列表类型（使用下面的数组列表）：

公共静态列表过滤器列表（列表列表，谓词）{
List newList=new ArrayList（）；//您可以在此处选择其他类型
列表。forEach（s->{
if（predicate.test）newList.add（s）；
});
返回newList；
}

如果您让调用方选择创建的列表类型，那么您可能应该选择工厂：

public static <U, T extends List<U>> T filterList(T list, 
      Predicate<U> predicate, Supplier<T> newListFactory) {

    T newList = newListFactory.get(); //You can choose a different type here
    list.forEach(s -> {
        if (predicate.test(s))
            newList.add(s);
    });

    return newList;
}

公共静态T过滤器列表（T列表，
谓词谓词，供应商（工厂）{
T newList=newListFactory.get（）；//您可以在此处选择其他类型
列表。forEach（s->{
if（谓词测试）
新列表。添加（s）；
});
返回newList；
}

注意：此模式已由collections API提供：

java.util.stream.Stream.filter(Predicate<? super T>)

java.util.stream.stream.filter（predicatePredicatePlease）是否有人可以提供example@solomid看看giorashc或I postedI的链接，我不认为这回答了我的问题，效果很好，而且更干净！
java.util.stream.Stream.filter(Predicate<? super T>)