使用泛型从三个相似的方法中创建一个简洁的方法

Question

我已经尝试过使用泛型做一些事情，但我个人似乎找不到任何简单的解决方案。尽管如此，我仍然认为将这 3 种类似的方法搁置一旁是一种罪过。

    public List<PassengerPlane> getPassengerPlanes() {
        List<PassengerPlane> passengerPlanes = new ArrayList<>();
        for (Plane plane : planes) {
            if (plane instanceof PassengerPlane) {
                passengerPlanes.add((PassengerPlane) plane);
            }
        }
        return passengerPlanes;
    }

    public List<MilitaryPlane> getMilitaryPlanes() {
        List<MilitaryPlane> militaryPlanes = new ArrayList<>();
        for (Plane plane : planes) {
            if (plane instanceof MilitaryPlane) {
                militaryPlanes.add((MilitaryPlane) plane);
            }
        }
        return militaryPlanes;
    }

    public List<ExperimentalPlane> getExperimentalPlanes() {
        List<ExperimentalPlane> experimentalPlanes = new ArrayList<>();
        for (Plane plane : planes) {
            if (plane instanceof ExperimentalPlane) {
                experimentalPlanes.add((ExperimentalPlane) plane);
            }
        }
        return experimentalPlanes;
    }

Answer 1

您需要的是泛型方法，但问题是instanceof 无法检查类型参数（实际上在编译过程中已删除），它需要实际的类引用。因此，您可以明确地将其提供给该方法：

public <T extends Plane> List<T> getPlanes(Class<T> claz) {
  List<T> result = new ArrayList<>();
  for (Plane plane : planes) {
    if (claz.isInstance(plane)) {
      result.add(claz.cast(plane));
    }
  }
  return result;
}

注意instanceof 和显式转换如何更改为对.isInstance() 和.cast() 的调用

像这样使用它

getPlanes(PassengerPlane.class)

Answer 2

您可以使用 Streams 使事情变得更短，但我不确定是否有办法在此处使用 instanceof：

public List<PassengerPlane> getPassengerPlanes() {
    return planes.stream().filter(t -> t instanceof PassengerPlane)
                 .map(t -> (PassengerPlane) t).collect(Collectors.toList());
}
public List<MilitaryPlane> getMilitaryPlanes() {
    return planes.stream().filter(t -> t instanceof MilitaryPlane)
                 .map(t -> (MilitaryPlane) t).collect(Collectors.toList());
}
public List<ExperimentalPlane> getExperimentalPlanes() {
    return planes.stream().filter(t -> t instanceof ExperimentalPlane)
                 .map(t -> (ExperimentalPlane) t).collect(Collectors.toList());
}

Answer 3

以下是我使用泛型解决问题的方法：

public <T> List<T> getTPlanes(Class<T> clazz) { //declare the method to take a type generic
    List<T> tPlanes = new ArrayList<>(); //initialize an ArrayList of that type

    planes.stream() //stream the planes list
            .filter(clazz::isInstance) //filter it down to only planes of the type that we want
            .forEach((p) -> tPlanes.add((T) p)); //add each plane left in the stream to our new ArrayList, and cast it to the type generic

    return tPlanes; //return the ArrayList we just created and populated
}

Answer 4

您确实需要在某处进行强制转换：这是一个采用单一方法的解决方案，该方法采用子类型。

import java.util.*;
import java.util.stream.*;

public class Example {
    public static class Plane { }
    public static class PassengerPlane extends Plane { }
    public static class MilitaryPlane extends Plane { }
    public static class ExperimentalPlane extends Plane { }

    private static List<Plane> planes =
        List.of(new PassengerPlane(),
                new MilitaryPlane(),
                new ExperimentalPlane());

    public static <T extends Plane> List<T> getPlanesOfType(Class<T> type, List<Plane> planes) {
        List<T> list =
            planes.stream()
            .filter(t -> type.isAssignableFrom(t.getClass()))
            .map(t -> type.cast(t))
            .collect(Collectors.toList());

        return list;
    }

    public static void main(String[] args) throws Exception {
        System.out.println(getPlanesOfType(PassengerPlane.class, planes));
        System.out.println(getPlanesOfType(MilitaryPlane.class, planes));
        System.out.println(getPlanesOfType(ExperimentalPlane.class, planes));
        System.out.println(getPlanesOfType(Plane.class, planes));
    }
}

[Example$PassengerPlane@7b227d8d]                                                                                                                                                                                                      
[Example$MilitaryPlane@7219ec67]                                                                                                                                                                                                       
[Example$ExperimentalPlane@45018215]                                                                                                                                                                                                   
[Example$PassengerPlane@7b227d8d, Example$MilitaryPlane@7219ec67, Example$ExperimentalPlane@45018215]

您可以使用单一方法来替换所有三个或使用它来实现。

Answer 5

如果您的问题真的很短暂，那么可能不值得付出努力。但是，这是访问者模式的典型问题（尤其是如果您的重复代码较大）。

步骤 1

创建Visitor接口访问Plane的各个类型：

interface Visitor {
    void visit(MilitaryPlane militaryPlane);
    void visit(ExperimentalPlane experimentalPlane);
    void visit(PassengerPlane passengerPlane);
}

...并以List<Plane> 开头的方式实现它，每个.visit() 都可以丰富它：

class PlaneVisitor implements Visitor {

    private final List<Plane> planes;

    PlaneVisitor(List<Plane> planes) {
        this.planes = requireNonNull(planes);
    }

    @Override
    public void visit(MilitaryPlane militaryPlane) {
        planes.add(militaryPlane);
    }

    @Override
    public void visit(ExperimentalPlane experimentalPlane) {
        planes.add(experimentalPlane);
    }

    @Override
    public void visit(PassengerPlane passengerPlane) {
        planes.add(passengerPlane);
    }

    public List<Plane> getPlanes() {
        return planes;
    }
}

第 2 步 - 在您的课程中启用访问者

在您的基类Plane 中添加一个abstract 方法以接受访问者：

public abstract class Plane {
    //...
    abstract void accept(Visitor visitor);
    //...
}

然后在每个子类中实现这个方法，让Visitor实例visit本身（this）。 PassengerPlane 的示例（所有其他类的逻辑相同）：

public class PassengerPlane extends Plane {
    //...
    @Override
    void accept(Visitor visitor) {
        visitor.visit(this);
    }
    //...
}

第 3 步 - 调整您的功能

您的函数现在可以遍历planes 的列表，而不关心类型。将由visitor解决：

public List<Plane> getPlanes() {
    PlaneVisitor planeVisitor = new PlaneVisitor(new ArrayList<>());
    for (Plane plane : planes) {
        plane.accept(planeVisitor);
    }
    return planeVisitor.getPlanes();
}

请注意，您需要添加一些方法/接口来执行此操作。由于您的代码非常小，即使它不是很“优雅”，您也可以想象它保持原样。但是，如果您的代码实际上应该比您向我们展示的更多，那么上面的示例可能会有所启发。

Answer 6

可以通过引入一个做公共部分的方法来做到这一点：

private static <T> List<T> createFilteredList(List<Plane> inList, Class<T> clazz) {
    List<T> outList = new ArrayList<>();
    for (Plane value : inList) {
        if (clazz.isInstance(value)) {
            outList.add(clazz.cast(value));
        }
    }
    return outList;
}

那么就可以这样使用了：

public List<PassengerPlane> getPassengerPlanes() {
    return createFilteredList(planes, PassengerPlane.class);
}
public List<MilitaryPlane> getPassengerPlanes() {
    return createFilteredList(planes, MilitaryPlane.class);
}
public List<ExperimentalPlane> getPassengerPlanes() {
    return createFilteredList(planes, ExperimentalPlane.class);
}

Answer 7

所以，您有一个可迭代的 Plane 作为输入。 飞机可以是PassengerPlane、MilitaryPlane 或ExperimentalPlane。

您要做的是通过谓词过滤平面集合。谓词是一个函数，它接受一个平面并回答真或假。过滤器使用谓词来确定是在结果中包含给定项目还是跳过。

如果您使用的是 Java 8 或更高版本，则可以使用 Streams API。 https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html

1. 从可迭代平面生成流。
2. 对其应用过滤器（中间操作）。
3. 收集要列出的结果。

使用 Stream API，您可以将上述方法转换为单行。像这样：

planes.stream().filter(plane -> plane instanceof MilitaryPlane).collect(toList());

那么，您可能不需要单独的简洁方法。 但是如果你想要一些可重用的代码，那么你必须弄清楚这里的参数是什么。在上面的代码中，它是一个特定的平面实现：

public List<Plane> filterPlanes(Iterable<Plane> planes, Class<? extends Plane> planeImplementation)

因此，您可以使用此参数构建谓词：

plane -> planeImplementation.isInstance(plane)

Answer 8

如果你有一个 Plane 超类型，你可以让子类继承 getPlanes() 方法。 this.getClass 将仅提取从列表中调用该方法的子类的平面。这样，您不必将类传递给方法，因为它可以从调用它的子类派生。

public abstract class Plane {

    public Plane(){}

    public List<Plane> getPlanes() {
        List<Plane> result = new ArrayList<>();
        for (Plane plane : planes) {
            if (this.getClass().isInstance(plane)) {
                result.add(this.getClass().cast(plane));
            }
        }
        return result;
    }
}

class PassengerPlane extends Plane {
}
class MilitaryPlane extends Plane {
}
class ExperimentalPlane extends Plane {
}

public class PlaneList {
    public String name;
    public static ArrayList<Plane> planes = new ArrayList<>();

    public PlaneList(){
        planes.add(new MilitaryPlane());
        planes.add(new MilitaryPlane());
        planes.add(new MilitaryPlane());
        planes.add(new PassengerPlane());
        planes.add(new PassengerPlane());
        planes.add(new ExperimentalPlane());
    }
}

我是这样测试的：

public class Main {

    public static void main(String[] args) {
        PlaneList list = new PlaneList();
        Plane plane = new PassengerPlane();

        for(Plane p : plane.getPlanes()){
            System.out.println(p.toString());
        }
    }
}

输出：

com.company.PassengerPlane@7dc36524
com.company.PassengerPlane@35bbe5e8