匿名类:
java
package l8;
import java.util.*;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector;
import java.util.stream.Collectors;
public class CollectorToList2 {
public static void main(String[] args) {
/**
*
<T> -- the type of input elements to the reduction operation
<A> -- the mutable accumulation type of the reduction operation (often hidden as an implementation detail)
<R> -- the result type of the reduction operation 最终返回结果的类型
*/
Collector<Integer, List<Integer>, List<String>> toList = new Collector<Integer, List<Integer>, List<String>>() {
// 初始一个容器,用于做为累加的容器
@Override
public Supplier<List<Integer>> supplier() {
return () -> new ArrayList<>();
}
/**
* 元素累加
* @return
*/
@Override
public BiConsumer<List<Integer>, Integer> accumulator() {
return List::add;
}
/**
* 将多个容器进行合并(应该是在并行Stream时使用的)
* @return
*/
@Override
public BinaryOperator<List<Integer>> combiner() {
return (a, b) -> {
System.out.println("combiner call");
a.addAll(b);
return a;
};
}
/**
* 最终类型转换
* @return
*/
@Override
public Function<List<Integer>, List<String>> finisher() {
return list -> list.stream()
.map(e -> e + "").collect(Collectors.toList());
}
@Override
public Set<Characteristics> characteristics() {
return Collections.singleton(Characteristics.UNORDERED);
}
};
List<String> collect = Arrays.asList(1, 2, 3).stream().collect(toList);
System.out.println(collect);
collect = Arrays.asList(1, 2, 3).parallelStream().collect(toList);
System.out.println(collect);
}
}
javascript:void(0)
Combiner:
应用:
优化初始容器的容量:
java
/**
* <T> -- the type of input elements to the reduction operation
* <A> -- the mutable accumulation type of the reduction operation (often hidden as an implementation detail)
* <R> -- the result type of the reduction operation 最终返回结果的类型
*/
class ToListWithInitialCapacity implements Collector<Integer, List<Integer>, List<String>> {
private int initialCapacity;
public ToListWithInitialCapacity(int initialCapacity) {
this.initialCapacity = initialCapacity;
}
// 初始一个容器,用于做为累加的容器
@Override
public Supplier<List<Integer>> supplier() {
return () -> new ArrayList<>(initialCapacity);
}
/**
* 元素累加
*
* @return
*/
@Override
public BiConsumer<List<Integer>, Integer> accumulator() {
return List::add;
}
/**
* 将多个容器进行合并(应该是在并行Stream时使用的)
*
* @return
*/
@Override
public BinaryOperator<List<Integer>> combiner() {
return (a, b) -> {
System.out.println("combiner call");
a.addAll(b);
return a;
};
}
/**
* 最终类型转换
*
* @return
*/
@Override
public Function<List<Integer>, List<String>> finisher() {
return list -> list.stream()
.map(e -> e + "").collect(Collectors.toList());
}
@Override
public Set<Characteristics> characteristics() {
return Collections.singleton(Characteristics.UNORDERED);
}
}
Jdk toList默认实现:
java
/**
* Returns a {@code Collector} that accumulates the input elements into a
* new {@code List}. There are no guarantees on the type, mutability,
* serializability, or thread-safety of the {@code List} returned; if more
* control over the returned {@code List} is required, use {@link #toCollection(Supplier)}.
*
* @param <T> the type of the input elements
* @return a {@code Collector} which collects all the input elements into a
* {@code List}, in encounter order
*/
public static <T>
Collector<T, ?, List<T>> toList() {
return new CollectorImpl<>(ArrayList::new, List::add,
(left, right) -> { left.addAll(right); return left; },
CH_ID);
}