Java中作为参数的类类型

我有一个方法：

private List<ApplicationForVacancy> createListOfApplicationsForVacancy(List<Document> documents) {
        return documents.stream()
                .filter(d -> d instanceof ApplicationForVacancy)
                .map(d -> (ApplicationForVacancy) d)
                .collect(Collectors.toList());
}

private List创建空缺申请列表（列出文档）{
returndocuments.stream（）
.filter（空缺申请的d->d实例）
.地图（d->（空缺申请）d）
.collect（Collectors.toList（））；
}

但是我想在参数和方法的返回类型中传递类的名称/类的类型，如下所示：

private List<TypeOfSomeClass> createList (List<Document> documents, String or Type typeOfSomeClass) {
            return documents.stream()
                    .filter(d -> d instanceof typeOfSomeClass)
                    .map(d -> (typeOfSomeClass) d)
                    .collect(Collectors.toList());
}

private static <T> List<T> filterType(List<?> input, Class<T> clazz) {
    return input.stream()
            .filter(clazz::isInstance)
            .map(clazz::cast)
            .collect(Collectors.toList());
}

List<Object> stuff = List.of("String", Integer.valueOf(3), Double.valueOf(42), new Object());
List<String> strings = filterType(stuff, String.class);
List<Number> numbers  = filterType(stuff, Number.class);

private List createList（列出文档、字符串或someclass的类型）{
returndocuments.stream（）
.filter（某类类型的d->d实例）
.map（d->（某些类别的类型）d）
.collect（Collectors.toList（））；
}

---

可能吗？如何才能做到这一点？

您必须提供一个

类

对象来声明类型并向方法添加类型参数，如下所示：

private List<TypeOfSomeClass> createList (List<Document> documents, String or Type typeOfSomeClass) {
            return documents.stream()
                    .filter(d -> d instanceof typeOfSomeClass)
                    .map(d -> (typeOfSomeClass) d)
                    .collect(Collectors.toList());
}

private static <T> List<T> filterType(List<?> input, Class<T> clazz) {
    return input.stream()
            .filter(clazz::isInstance)
            .map(clazz::cast)
            .collect(Collectors.toList());
}

List<Object> stuff = List.of("String", Integer.valueOf(3), Double.valueOf(42), new Object());
List<String> strings = filterType(stuff, String.class);
List<Number> numbers  = filterType(stuff, Number.class);

私有静态列表过滤器类型（列表输入，类clazz）{
返回input.stream（）
.filter（clazz:：isInstance）
.map（clazz:：cast）
.collect（Collectors.toList（））；
}

然后按如下方式调用该方法：

private List<TypeOfSomeClass> createList (List<Document> documents, String or Type typeOfSomeClass) {
            return documents.stream()
                    .filter(d -> d instanceof typeOfSomeClass)
                    .map(d -> (typeOfSomeClass) d)
                    .collect(Collectors.toList());
}

private static <T> List<T> filterType(List<?> input, Class<T> clazz) {
    return input.stream()
            .filter(clazz::isInstance)
            .map(clazz::cast)
            .collect(Collectors.toList());
}

List<Object> stuff = List.of("String", Integer.valueOf(3), Double.valueOf(42), new Object());
List<String> strings = filterType(stuff, String.class);
List<Number> numbers  = filterType(stuff, Number.class);

List stuff=List.of（“字符串”、Integer.valueOf（3）、Double.valueOf（42）、new Object（））；
List strings=filterType（stuff，String.class）；
列表编号=过滤器类型（stuff，Number.class）；

---

字符串

将只包含

字符串

，

数字

将包含两个数值。

据我所知，您不能执行这样的类型转换。但是您可以在方法的开头创建一个新的列表实例，其中包含指定的类型。然后在现有列表中循环，筛选出结果中应该包含的所有实例。添加这些，然后返回新列表。这里有一些伪代码

public <T> List<T> filterInstances(List<?> input, Class<T> type){
  List<T> result = new ArrayList<>();
  for(Object o : input){
    if(type.isAssignableFrom(o.getClass()){
      result.add((T)o);
    }
  }
  return result;
}

公共列表过滤器状态（列表输入，类类型）{
列表结果=新建ArrayList（）；
for（对象o：输入）{
if（键入.isAssignableFrom（o.getClass（））{
结果：添加（（T）o）；
}
}
返回结果；
}

不总是，但在使用时经常必须使用

instanceof

表明设计不好。为什么你的程序需要根据列表中的类型对列表进行排序？我知道。这是面试测试的强制类设计。我无法更改它。列表包含一些类型，我需要将其分离为几个单独的列表我想用一种方法来实现它。这正是我想要的。非常感谢你，伙计！你不需要手动调用

valueOf

。

List.of（“String”，3，42.0，new Object（））；

就可以了。@Holger:我很清楚这一点，但我想让混合类型更明确。即使如此，

List.of（“String”，“Integer”）3，（Double）42.0，new Object（）；

就足够了。@Holger:当然，我只是碰巧更喜欢这种表示法。Joachim Sauer发布的解决方案有效。你的代码也正确；）谢谢，伙计！是的，他的解决方案更适合你的用例。我没有研究流API。我只是试图解释一般过程：）