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

Question

跟进来自this 的问题。 有这样的层次结构。其中 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

你的变种

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

没有那么难看，因为它表达了你的意图。

但是你可以简化它，因为你不需要一个局部变量来保存m instanceof B：

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()));

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

也许你可以用帮助类做你想做的事：

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));

此解决方案只是将visible 是true 还是false 委托给Helper 类，并让您拥有一个干净的流管道。

附带说明...一般来说，使用类型为 Boolean 的映射是没有意义的，因为您可以拥有与 Set 相同的语义：

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

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

boolean isVisible = set.contains(elementId);

Answer 4

您的代码很难看，因为您的层次结构没有意义。你可能想要的是这样的：

class A
{
    abstract public boolean isVisible();
    // or make it concrete and return a default if you need to
}

// B can stay the same (+ @Override)

class C extends A
{
    @Override
    public boolean isVisible()
    {
        return true;
    }
}

那么就可以这样做了：

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

Answer 5

可能将 C 映射到流中的 null，然后在 null 上返回 true？像这样：

mappings.stream().map(a -> a instanceof C ? (B)null : (B)a)
                 .collect(Collectors.toMap(A::getId, m==null || m.isVisible()));

Answer 6

我已经编写了这个简单的 Collector 实现，它应该可以满足您的需求：

public class AToMapCollector implements Collector<A, Map<Integer, Boolean>, Map<Integer, Boolean>>{
    @Override
    public Supplier<Map<Integer, Boolean>> supplier(){
        return HashMap::new;
    }

    @Override
    public BiConsumer<Map<Integer, Boolean>, A> accumulator(){
        return (map, a) -> {
            boolean visible = true;
            if(a instanceof B){
                visible = ((B) a).isVisible();
            }
            map.put(a.getId(), visible);
        };
    }

    @Override
    public BinaryOperator<Map<Integer, Boolean>> combiner(){
        return (map1, map2) -> {
            map1.putAll(map2);
            return map1;
        };
    }

    @Override
    public Function<Map<Integer, Boolean>, Map<Integer, Boolean>> finisher(){
        return map -> map;
    }

    @Override
    public Set<Characteristics> characteristics(){
        return EnumSet.of(Characteristics.IDENTITY_FINISH, Characteristics.UNORDERED);
    }
}

最终可以这样调用：

Map<Integer, Boolean> map = mappings.stream().collect(new AToMapCollector());

添加一个全新的类是这个收集器的可重用性，也增加了可读性而不是多行 lambda。