Czy istnieje elegancki sposób na ograniczenie strumienia map do jednej mapy?

Question

Czy istnieje pewna mapa, w której można umieścić wszystkie swoje wpisy w jednej mapie?

Ignorowanie kwestie null, wpisy nadmiernie piśmie etc, co chciałbym kod jest:

public static <K, V> Map<K, V> reduce(Map<K, V>... maps) { 
    return Arrays.stream(maps) 
     .reduce(new HashMap<K, V>(), (a, b) -> a.putAll(b)); 
} 

ale daje to błąd kompilacji, ponieważ a.putAll(b) jest void. Jeśli wróci this, to będzie działać.

Aby obejść ten problem, mam zakodowane:

public static <K, V> Map<K, V> reduce(Map<K, V>... maps) { 
    return Arrays.stream(maps) 
     .reduce(new HashMap<K, V>(), (a, b) -> {a.putAll(b); return a;}); 
} 

który kompiluje i działa, ale jest brzydki lambda; kodowanie return a; wydaje się zbędne.

Jedno podejście byłaby na sposób jej przydatność

public static <K, V> Map<K, V> reduce(Map<K, V> a, Map<K, V> b) { 
    a.putAll(b); 
    return a; 
} 

który czyści lambda

public static <K, V> Map<K, V> reduce(Map<K, V>... maps) { 
    return Arrays.stream(maps) 
     .reduce(new HashMap<K, V>(), (a, b) -> reduce(a, b)); 
} 

lecz teraz ma, aczkolwiek nieco wielokrotnego użytku, sposób bezużyteczny użytkową.

Czy istnieje bardziej elegancki sposób wywoływania metody na akumulatorze i zwracania jej w zakresie lambda?

Answer 1

reduce działa podobnie do

U result = identity; 
for (T element : this stream) 
    result = accumulator.apply(result, element) 
return result; 

co oznacza, że ​​N stanowiących accumulator.apply potrzeby do return związku (końcowe i pośrednie jeden).

Jeśli chcesz tego uniknąć zachowanie używać collect który działa bardziej jak

R result = supplier.get(); 
for (T element : this stream) 
    accumulator.accept(result, element); 
return result; 

tak lambda reprezentujący accumulator.accept nie trzeba return żadnej wartości, ale do modyfikacji result podstawie element.

przykład:

public static <K, V> Map<K, V> reduce(Map<K, V>... maps) { 
    return Arrays.stream(maps) 
      .collect(HashMap::new, Map::putAll, Map::putAll); 
      //      ^  ^
      //       |   collect results from parallel streams 
      //      collect results in single thread 
}