将带有lambda的类映射到默认值

Question

后续问题。有这样的等级制度。其中A是基类：

       A 
      / \
     B   C

  |   A    |   |   B       |   |  C      |  
  | getId()|   |A.getId()  |   |A.getId()|
               |isVisible()| 

以及以下内容：

List<A> mappings;

我想将B实例的所有ID映射到B.isVisible（）的值，并将C实例的ID映射到TRUE

在最初问题的帮助下，我将其提炼为以下格式：

mappings.stream().filter(a -> a instanceof B)
                 .map(b -> (B)b)
                 .collect(Collectors.toMap(A::getId, m -> m.isVisible()));

丑陋的版本是：

mappings.stream()                       
        .collect(Collectors.toMap(A::getId, m ->
                        {
                            boolean isB = m instanceof B;
                            return isB ? ((B) m).isVisible() : true;
                        }));

有没有帮助改进它，为更优雅的版本提供默认true？

Answer 1

也许您可以使用helper类执行您想要的操作：

class Helper {
    private final Long id;
    private final boolean visible;

    Helper(A a) {
        this.id = a.getID();
        this.visible = a instanceof B ? ((B) a).isVisible() : true;
    }

    Long getId() { return id; }

    boolean isVisible() { return visible; }
}

然后，将列表的每个元素映射到Helper的实例并收集到映射：

Map<Long, Boolean> map = mappings.stream()
    .map(Helper::new)
    .collect(Collectors.toMap(Helper::getId, Helper::isVisible));

此解决方案仅将可见的是真还是假委托给助手类，并允许您拥有一个干净的流管道。

作为旁注...一般来说，具有Boolean类型值的映射是毫无意义的，因为您可以使用Set具有相同的语义学：

Set<Long> set = mappings.stream()
    .map(Helper::new)
    .filter(Helper::isVisible)
    .collect(Collectors.toSet());

然后，要知道某个元素是否可见，只需检查它是否属于集合：

boolean isVisible = set.contains(elementId);

Answer 2

如果您无法更改源代码，您可以编写实用程序方法isA来描述您想要的内容，例如：

Map<Integer, Boolean> visibility = mappings.stream().collect(toMap(
        A::getId,
        isA(B.class, B::isVisible, any -> true)
));

static <T, S extends T, R> Function<T, R> isA(Class<? extends S> type,
                                              Function<? super S, R> special,
                                              Function<T, R> general) {

    return it -> type.isInstance(it) ? special.apply(type.cast(it))
                                     : general.apply(it);
}

Answer 3

您的变体

mappings.stream()                       
        .collect(Collectors.toMap(A::getId, m ->
                        {
                            boolean isB = m instanceof B;
                            return isB ? ((B) m).isVisible() : true;
                        }));

这不是很难看吗，因为它表达了你的意图。

但您可以简化它，因为不需要局部变量来保存B的m实例：

mappings.stream()                       
        .collect(Collectors.toMap(A::getId, m->m instanceof B? ((B)m).isVisible(): true));

然后，根据经验法则，每当您在复合布尔表达式中有boolean文字时，就有一个没有它的替代方案。

mappings.stream()                       
        .collect(Collectors.toMap(A::getId, m -> !(m instanceof B) || ((B)m).isVisible()));