List<Base> 到 List<Long> ...条件转换

Question

假设我有这 3 个课程（大大减少）：

public interface Base
{
    String getType();
}

public class Object1 implements Base
{
    String getType() { ... };

    long getSerialNr() { ... };
}

public class Object2 implements Base
{
    String getType() { ... };

    long getPartNr() { ... };
}

我将如何（使用 Java 8 流）使用条件强制转换将 List<Base> 转换为 List<Long>？我从这个开始：

List<Long> result = baseList.stream().filter(Objects::nonNull)
    .filter(Object1.class::isInstance)
    .map(Object1.class::cast)
    .map(o -> o.getSerialNr())
    .collect(Collectors.toList());

...但是如何整合第二种情况，其中元素是Object2 的实例，我想返回getPartNr？

Answer 1

假设类的数量可能会增加，您可能必须抽象类型到属性的映射：

static Map<Predicate<Base>,Function<Base,Long>> ACCESSORS;
static {
    Map<Predicate<Base>,Function<Base,Long>> m=new HashMap<>();
    m.put(Object1.class::isInstance, base -> ((Object1)base).getSerialNr());
    m.put(Object2.class::isInstance, base -> ((Object2)base).getPartNr());
    ACCESSORS=Collections.unmodifiableMap(m);
}
static Stream<Long> get(Base b) {
    return ACCESSORS.entrySet().stream()
            .filter(e -> e.getKey().test(b))
            .map(e -> e.getValue().apply(b));
}

get 方法假定谓词是互斥的，在测试这些非interface 类型时就是这种情况。

然后，你可以像这样使用它：

List<Long> result = baseList.stream()
    .flatMap(YourClass::get)
    .collect(Collectors.toList());

您也可以内联 get 方法，但这并没有提高可读性：

List<Long> result = baseList.stream()
    .flatMap(b -> ACCESSORS.entrySet().stream()
        .filter(e -> e.getKey().test(b))
        .map(e -> e.getValue().apply(b)))
    .collect(Collectors.toList());

Answer 2

首先，如果接口 Base 中没有一个所有类都应该实现的通用方法，那么接口就没有意义。如果你想那样做，那就不好了。您应该将代码更改为下面的代码：

List<Long> aList = baseList.stream().filter((Objects::nonNull)
        .filter(obj->(obj instanceof Object1 || obj instanceof Object2))
        .map(num-> (num instanceof Object1) ? ((Object1) num).getPratNr() : ((Object2) num).getPratNr())
        .collect(Collectors.toList());

Answer 3

您可以尝试按元素类对 baseList 进行分组。

public class MyTest {

  @Test
  public void java8_listbase_to_listlong_conditional_cast() {
    List<Base> baseList = new ArrayList<>();
    baseList.add(new Object1());
    baseList.add(new Object2());

    Map<?, List<Base>> group = baseList.stream()
      .filter(Objects::nonNull)
      .collect(Collectors.groupingBy(key -> key.getClass()));

    Stream<Long> object1stream = group.get(Object1.class)
      .stream()
      .map(Object1.class::cast)
      .map(Object1::getSerialNr);

    Stream<Long> object2stream = group.get(Object2.class)
      .stream()
      .map(Object2.class::cast)
      .map(Object2::getPartNr);

    List<Long> longList = Stream.concat(object1stream, object2stream).collect(Collectors.toList());

    assertArrayEquals(new Long[] {0l, 1l}, longList.toArray());
  }



  public interface Base {
  }

  public class Object1 implements Base {
    long getSerialNr() { return 0L; };
  }

  public class Object2 implements Base {
    long getPartNr() { return 1L; };
  }
}