Java 8平台地图，流，收集

Question

我有一种情况

class A {
    private B b;

    public B getB() {
        return b;
    }
}

另一个B级

class B {
    private List<C> c;

    public List<C> getListC() {
        return c;
    }
}

现在C类包含两个实例变量

class C {
     private int id;
     private String name;

     public int getId() { 
         return id;
     }

     public String getName() {
         return name;
     }
}

现在，我想使用java 8实现以下功能

List<C> newListC = a.getB().getListC();
Map<Integer, String> map = new HashMap<>();

for(C c : newListC) {
  map.put(c.getId,c.getName());
}

我试过很多次了，但每次我都面临不同的问题。我的代码：

    Optional<A> a=Optional.of(new A());
    Map<Integer, String> map= a.map(A::getB)
                            .flatMap(b ->
                                    b.getListC()
                                            .stream()
                                            .collect(Collectors.toMap(
                                        C::getId,
                                        C::getName
                                                    )
                                            )
                            );

错误信息：

Error:(164, 33) java: incompatible types: no instance(s) of type
variable(s) U,R,A,capture#1 of ?,T,K,U exist so that
java.util.Optional<U> conforms to
java.util.Map<java.lang.Integer,java.lang.String>

提前感谢

Answer 1

不能将flatMap Optional传递给Map；函数必须返回Optional。另一方面，由于函数不返回Optional，因此没有必要使用flatMap，而普通的map就可以：

Map<Integer, String> map = Optional.of(new A())
    .map(A::getB)
    .map(b -> b.getListC().stream().collect(Collectors.toMap(C::getId, C::getName)))
    .orElse(Collections.emptyMap());

但是，由于new A()的结果不能是null (使用of而不是ofNullable承认这一点)，在链开始处的间接处理是不必要的：

Map<Integer, String> map = Optional.ofNullable(new A().getB())
    .map(b -> b.getListC().stream().collect(Collectors.toMap(C::getId, C::getName)))
    .orElse(Collections.emptyMap());

但是请注意，只处理getB结果的空性，因为传递到下一个映射步骤的函数无条件地调用getListC返回的列表上的stream()。但是，返回预期为null的List无论如何都是糟糕的编码风格；您可以始终返回一个空列表来表示没有值。

也许您的困惑源于基于Stream的替代解决方案：

Map<Integer, String> map = Stream.of(new A().getB())
    .filter(Objects::nonNull)
    .flatMap(b -> b.getListC().stream())
    .collect(Collectors.toMap(C::getId, C::getName));

在这里，创建一个最多由一个元素组成的流，然后flatMap将其添加到getListC…返回的列表项中。

Answer 2

虽然我碰到了几个编译错误，因为我可以看到几个排版，但是

尝试：

    List<C> newListC= new A().getB().getListC();

    Map<Integer, String> stringMap = newListC.stream()
            .collect(Collectors
                    .toMap(C::getId, C::getName));

如果您修复了您的编译问题，它应该释放的结果相当于非流版本的地图。