Stream基本概念

Stream流是來自數據源的元素隊列并支持聚合操作: 元素: 是特定類型的對象,是數據源形成的一個隊列.Java中的Stream不會存儲元素,而是按需計算 數據源: Stream流數據的來源.可以是集合,數組,I/O Channel,產生器Generator等 聚合操作: 類似SQL語句的一系列操作,比如filter,map,reduce,match和sorted等
Stream不是集合元素,不是數據結構來保存數據,是一個有關數據算法和計算的流: 獲取一個數據源source => 數據轉換 => 執行操作獲取需要的結果每次轉換后原來的Stream對象不變,返回一個新的Stream對象這樣可以使得對Stream的操作鏈式排列,形成一個管道
Stream是對集合Collection對象功能的增強: Stream可以對集合對象進行便利高效的聚合操作和大批量的數據操作集合類持有的元素都是存儲在內存中,數據量很大的集合類會占用大量的內存 .Stream的元素是延遲計算的,只有在訪問時才會進入內存進行計算集合類的迭代邏輯是調用者負責的,通常使用for循環 .Stream中的迭代是隱含在對Stream的各種操作當中
Stream操作的兩個基礎特征: Pipelining: 中間操作都會返回流本身.多個操作可以串成一個管道.這樣就可以對操作進行優化,比如延遲執行laziness和短路short-circuiting 內部迭代: 通常對集合的遍歷都是通過Iterator或者forEach操作,顯式地在集合外部進行迭代 .Stream提供了內部迭代的方式,通過訪問者模式Visitor實現
Stream的特點: 不存儲: 數據流Stream不是存儲元素的數據結構數據流Stream將數據元素從源數據結構,數組,生成器函數和輸入輸出管道中傳遞到計算操作的管道中 功能性: 一個數據流Stream中的流操作都會產生一個結果,不會修改源數據流Stream中的元素 延遲計算: 許多流操作中的各種操作,比如過濾,映射,去重等,只有訪問時才會進行計算,這樣可以有更多的機會進行優化 無界性: 集合的大小是有界的,但是數據流Stream可以是無界的短路操作等可以允許無限流計算在有限的時間內完成
示例: 將流程轉化為Java代碼

+--------------------+       +------+   +------+   +---+   +-------+
| stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect|
+--------------------+       +------+   +------+   +---+   +-------+

List<Integer> transactionsIds = widgets.stream()
	.filter(b -> b.getColor == RED)
	.sorted((x, y) -> x.getWeight() - y.getWeight())
	.mapToInt(Widget :: getWeight)
	.sum();

生成流

集合接口有兩種方法來生成流:
- stream(): 為集合創建串行流
- parallelStream(): 為集合創建并行流并行流可以充分發揮多核處理器的優勢使用fork和join并行方式來拆分任務和加速處理過程

List<String> strings = Arrays.asList("I", "want", "to", "be", "", "great");
List<String> filter = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());

Stream的創建方式

數組

通過數組來生成Stream流

String[] arrayStr = {"a", "b", "c"};
// 使用Stream中的靜態方法
Stream<String> stream = Stream.of(arrayStr);

集合

通過集合來生成Stream流

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> strem = list.stream();

Stream.generate()

通過Stream.generate()方法來生成Stream流

Stream<Integer> generate = Stream.generate(() -> 1);

Stream.iterate()

通過Stream.iterate()方法來生成Stream流

Stream<Integer> iterate = Stream.iterate(1, x -> x + 1);

API

通過其余相關的API進行創建

String str = "api";
IntStream stream = str.chars();

Stream常用方法

中間操作

中間操作: 如果調用方法之后返回的結果是Stream對象的操作是一個中間操作

filter

filter方法用于通過設置的條件過濾出元素

/*
 * 過濾出空字符串的個數
 */
List<String> strings = Arrays.asList("I", "want", "to", "be", "", "great");
long count = Strings.stream().filter(string -> string.isEmpty()).count();

/*
 * 過濾出偶數
 */
 Arrays.asList(1, 2, 3, 4, 5).stream()
 	.filter(x -> x % 2 == 0)
 	// 2, 4
 	.forEach(System.out :: println)

/*
 * 求出所有的偶數和
 */
 int count = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9).stream()
 	.filter(x -> x % 2 == 0)
 	.mapToInt(x -> x)
 	.sum();
 System.out.println(count);

distinct

distinct方法通過元素的hashcode()和equals()去除重復元素

Arrays.asList(1, 2, 3, 3, 3, 4, 5).stream()
	.distinct()
	// 1, 2, 3, 4, 5
	.forEach(System.out :: println);

集合Set去重:
Arrays.asList(1, 2, 3, 4, 5).stream() .collect(Collectors.toSet()) // 1, 2, 3, 4, 5 .forEach(System.out :: println); 復制代碼

sorted

sorted方法根據自然排序返回Stream流
sorted(Comparator comparator)方法根據提供的Comparator進行排序

/*
 * 使用sorted方法實現min求最小值和max求最大值
 */
 List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
 // 數字的自然排序就是從小到大
 Optional<Integer> min = list.stream().sorted().findFirst();
 System.out.println(min :: get());

 Optional<Integer> max = list.stream.sorted((a, b) -> b - a).findFirst();
 System.out.println(max :: get());

/*
 * 按照字母順序a - z排序
 */
 Arrays.asList("java", "python", "c").stream().sorted().forEach(System.out :: println);
 
/*
 * 按照字母的長度進行排序
 */
 Arrays.asList("java", "python", "c").stream().sorted((a, b) -> a.length() - b.length()).forEach(System.out :: println);

limit

limit方法用來截取指定長度的Stream流
skip方法用來丟棄指定長度的流數據,可以與limit配合實現分頁

/*
 * 打印出集合中20 - 30的數據 
 */
 Stream.iterate(x -> x + 1).limit(50)
 	// 跳過前20個
 	.skip(20)
 	// 輸出20 - 30 
 	.forEach(System.out :: println);

map

map用來將Stream流中的元素按照指定的函數映射成一個新的元素的Stream流
flatMap用來將Stream流中的每個元素轉換成另一個流,然后將所有流連接成一個新的流

List<String> list = Arrays.asList("a, b, c", "1, 2, 3");
/*
 * 將字符串轉換為不帶逗號的元素
 */
 Stream<String> mapList = list.stream().map(s -> s.replace(",", ""));
 // abc 123
 mapList.forEach(System.out :: println);

 Stream<String> flatMapList = list.stream().flatMap(s -> {
 	// 將每一個元素轉換為流數據
 	String[] arrayStr = s.split(",");
 	Stream<String> stream = Arrays.stream(arrayStr);
 	return stream;
 });
 // a  b c 1 2 3
 flatMapList.forEach(System.out :: println);

peek

peek方法用來獲取Stream流中的每一個元素 類似于map, 但是map中接收的是一個Function表達式,有返回值 peek中接收的是一個Consumer表達式,沒有返回值

String str = "11, 22, 33, 44, 55";
// 11 22 33 44 55 165
System.out.println(Stream.of(str.split(",")).peek(System.out :: println).mapToInt(Integer :: valueOf).sum());

終止操作

循環-forEach

forEach用來循環遍歷每一個元素

// 創建一個實體類,包含有一個屬性為num屬性.并且有一個build()方法用于為num賦值
String str = "1, 2, 3"

/*
 * 輸出 num = 1, num = 2, num = 3
 */
Stream.of(str.split(",")).map(x -> new User(x)).forEach(System.out :: println);
Stream.of(str.split(",")).map(User :: new).forEach(System.out :: println);
Stream.of(str.split(",")).map(x -> User.build(x)).forEach(System.out :: println);
Stream.of(str.split(",")).map(User :: build).forEach(System.out :: println);

計算-min,max,count,sum

min: 返回Stream流元素中的最小值
max: 返回Stream流元素中的最大值
count: 返回Stream流元素中的總個數
sum: 對Stream流元素進行求和

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);

// 求集合的最大值 - 6
System.out.println(list.stream().max((a, b) -> a - b).get());
// 求集合的最小值 - 1
System.out.println(list.stream().min((a, b) -> a - b).get());
// 統計元素的個數 - 6
System.out.println(list.stream().count());

// 元素求和
String str = "11, 22, 33, 44, 55";
System.out.println(Stream.of(str.split(",")).mapToInt(x -> Integer.valueOf(x)).sum());
System.out.println(Stream.of(str.split(",")).mapToInt(Integer :: valueOf).sum());
System.out.println(Stream.of(str.split(",")).map(x -> Integer.valueOf(x)).mapToInt(x -> x).sum());
System.out.println(Stream.of(str.split(",")).map(Integer :: valueOf).mapToInt(x -> x).sum());

匹配-anyMatch,allMatch,noneMatch,findFirst,findAny

anyMatch: 接收一個Predicate函數,只要Stream流中有一個元素滿足該斷言則返回true, 否則返回false
allMatch: 接收一個Predicate函數,當Stream流中每一個元素都滿足該斷言則返回true, 否則返回false
noneMatch: 接收一個Predicate函數,當Stream流中每一個元素都不符合該斷言則返回true, 否則返回false
findFirst: 返回Stream流中的第一個元素
findAny: 返回Stream流中的任意一個元素

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);

// 如果集合的元素都大于等于0則返回true
System.out.println(list.stream().allMatch(x -> x >= 0));
// 如果集合中有大于5的元素,返回false
Systemm.out.println(list.stream().noneMatch(x -> x > 5));
// 如果集合中有大于3的元素則返回true
System.out.println(list.stream().anyMatch(x -> x > 3));
// 取第一個偶數
System.out.println(list.stream().filter(x -> x % 2 == 0).findFirst().get());
// 取任意一個偶數
System.out.println(list.stream().filter(x -> x % 2 == 0).findAny().get());

收集器-toArray,collect

collect: 接收一個Collector實例,將流中元素轉變為另外一種數據結構
Collector<T, A, R> 是一個接口,包含5個抽象方法: Supplier< A > supplier(): 創建一個結果容器 BiConsumer<A, T> accumulator(): 消費型接口. 第一個參數為容器A, 第二個參數為流中元素T BinaryOperator< A > combiner(): 函數接口. 該函數的作用是將各個子流程的運行結果,即accumulator函數操作后的容器A進行合并 Function<A, R> finisher(): 函數式接口. 參數為容器A, 返回類型為collect方法需要的結果類型R Set< Chracteristics > characteristics(): 返回一個不可變的Set集合,用來表明該Collector的特性

// 將對象值轉化為List
List<Integer> ageList = userList.stream().map(User :: getAge).collect(Collectors.toList());
// 將對象值轉化為Set
Set<Integer> ageSet = userList.stream().map(User :: getAge).collect(Collectors.toMap());
// 將對象值轉換為Map. 要求key的取值不能相同
Map<String, Integer> userMap = userList.stream().collect(Colletors.toMap(User :: getName, User :: getAge));
// 字符串分隔符連接
String joinName = userList.stream().map(User :: getName).collect(Collectors.join(",", "(", ")"))
// 聚合操作 - 計算對象總數
Long count = userList.stream().collect(Collectors.counting());
// 聚合操作 - 計算最大值
Integer maxAge = userList.stream().map(User :: getAge).collect(Collectors.maxBy(Integer :: compare)).get(); 
// 聚合操作 - 計算對象值總數
Integer sumAge = userList.stream().collect(Collectors.summingInt(User :: getAge));
// 聚合操作 - 計算對象值的平均數
Double averageAge = userList.stream().collet(Collectors.averagingDouble(User :: getAge));
// 根據Age分組
Map<Integer, List<User>> ageMap = userList.stream().collect(Collectors.groupingBy(User :: getAge));
// 根據條件分區: 一部分大于10, 一部分小于10
Map<Boolean, List<User>> partMap = userList.stream().collect(Collectors.partitionBy(x -> x.getAge() > 10));
// 規約
Integer value = userList.stream().map(User :: getAge).collect(Collectors.reducing(Integer :: sum)).get();

parallelStream

parallelStream是流并行處理程序的代替方法

List<String> strings = Arrays.asList("I", "want", "to", "be", "", "great");
long count = strings.parallelStream().filter(string -> string.isEmpty()).count();

可以很容易的在順序運行和并行之間進行直接切換

Collectors

Collectors類實現很多歸約操作,比如將流轉換成集合和聚合元素
Collectors可用于返回列表和字符串

List<String> strings = Arrays.asList("I", "want", "to", "be", "", "great");
// 過濾掉空字符串
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
// 合并字符串
String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(","));

averagingDouble

/**
 * 返回一個Collector,生成應用于輸入元素double值函數的算術平均值
 * 結果可能會存在誤差
 *  
 * @param mapper 獲取需要計算算數平均值的值的映射器
 * @return Collector<T, ?, Double> 計算算術平均值的Collector
 */
 public static <T> Collector<T, ?, Double> averagingDouble(ToDoubleFunction<? super T> mapper) {
        /*
         * 在收集操作的數組中:
         * 	索引0 - 運行總和的高位
         * 	索引1 - 補償計算總和的低位
         * 	索引2 - 可見值的數量
         */
        return new CollectorImpl<>(
                () -> new double[4],
                (a, t) -> { double val = mapper.applyAsDouble(t); sumWithCompensation(a, val); a[2]++; a[3]+= val;},
                (a, b) -> { sumWithCompensation(a, b[0]); sumWithCompensation(a, b[1]); a[2] += b[2]; a[3] += b[3]; return a; },
                a -> (a[2] == 0) ? 0.0d : (computeFinalSum(a) / a[2]),
                CH_NOID);
}

averagingInt

/**
 * 返回一個Collector,生成應用于輸入元素int值函數的算術平均值
 *  
 * @param mapper 獲取需要計算算數平均值的值的映射器
 * @return Collector<T, ?, Double> 計算算術平均值的Collector
 */
 public static <T> Collector<T, ?, Double> averagingInt(ToIntFunction<? super T> mapper) {
        return new CollectorImpl<>(
                () -> new long[2],
                (a, t) -> { a[0] += mapper.applyAsInt(t); a[1]++; },
                (a, b) -> { a[0] += b[0]; a[1] += b[1]; return a; },
                a -> (a[1] == 0) ? 0.0d : (double) a[0] / a[1], CH_NOID);
}

averagingLong

/**
 * 返回一個Collector,生成應用于輸入元素long值函數的算術平均值
 *  
 * @param mapper 獲取需要計算算數平均值的值的映射器
 * @return Collector<T, ?, Double> 計算算術平均值的Collector
 */
 public static <T> Collector<T, ?, Double> averagingLong(ToLongFunction<? super T> mapper) {
        return new CollectorImpl<>(
                () -> new long[2],
                (a, t) -> { a[0] += mapper.applyAsLong(t); a[1]++; },
                (a, b) -> { a[0] += b[0]; a[1] += b[1]; return a; },
                a -> (a[1] == 0) ? 0.0d : (double) a[0] / a[1], CH_NOID);
}

collectingAndThen

/**
 * 調整Collector進行額外的轉換 
 *  
 * @param downstream 生成的下游收集器
 * @param finisher 額外執行的操作
 * @return Collector<T,A,RR> 進行額外操作的下游收集器
 */
public static<T,A,R,RR> Collector<T,A,RR> collectingAndThen(Collector<T,A,R> downstream, Function<R,RR> finisher) {
        Set<Collector.Characteristics> characteristics = downstream.characteristics();
        if (characteristics.contains(Collector.Characteristics.IDENTITY_FINISH)) {
            if (characteristics.size() == 1)
                characteristics = Collectors.CH_NOID;
            else {
                characteristics = EnumSet.copyOf(characteristics);
                characteristics.remove(Collector.Characteristics.IDENTITY_FINISH);
                characteristics = Collections.unmodifiableSet(characteristics);
            }
        }
        return new CollectorImpl<>(downstream.supplier(),
                                   downstream.accumulator(),
                                   downstream.combiner(),
                                   downstream.finisher().andThen(finisher),
                                   characteristics);
}

counting

/**
 * 返回Collector中指定類型元素的數量 
 *  
 * @return Collector<T, ?, Long> 指定輸入元素數量的收集器
 */
public static <T> Collector<T, ?, Long> counting() {
        return summingLong(e -> 1L);
}

groupingBy

/**
 * 返回一個對輸入的指定類型的元素執行分組操作的Collector
 * 	- 根據分組函數進行分組操作
 * 	- 并將結果以Map類型返回 
 *  
 * @param classifier 指定的分組函數
 * @return Collector<T, ?, Map<K, List<T>>> Map類型的返回結果
 */
public static <T, K> Collector<T, ?, Map<K, List<T>>> groupingBy(Function<? super T, ? extends K> classifier) {
        return groupingBy(classifier, toList());
}

/**
 * 返回一個對輸入的指定類型的元素執行級聯分組操作的Collector
 * 	- 根據分組函數進行分組操作
 * 	- 然后根據下游收集器對關聯key的value值執行指定的規約操作 
 *  
 * @param classifier 指定的分組函數
 * @param downstream 指定執行規約操作的下游收集器
 * @return Collector<T, ?, Map<K, D>> 實現了級聯分組操作的結果
 */
public static <T, K, A, D> Collector<T, ?, Map<K, D>> groupingBy(Function<? super T, ? extends K> classifier, Collector<? super T, A, D> downstream) {
        return groupingBy(classifier, HashMap::new, downstream);
}

/**
 * 返回一個對輸入的指定類型的元素執行級聯分組操作的,并以指定的Map實現方式保存結果返回的Collector
 * 	- 根據分組函數進行分組操作
 * 	- 再根據下游收集器對關聯key的value值執行指定的規約操作
 * 	- 然后將結果保存到指定方式實現的Map中 
 *  
 * @param classifier 指定的分組函數
 * @param mapFactory 指定的Map實現
 * @param downstream 指定執行規約操作的下游收集器
 * @return Collector<T, ?, M> 實現了級聯分組操作的Collector結果
 */
public static <T, K, D, A, M extends Map<K, D>> Collector<T, ?, M> groupingBy(Function<? super T, ? extends K> classifier, Supplier<M> mapFactory, Collector<? super T, A, D> downstream) {
        Supplier<A> downstreamSupplier = downstream.supplier();
        BiConsumer<A, ? super T> downstreamAccumulator = downstream.accumulator();
        BiConsumer<Map<K, A>, T> accumulator = (m, t) -> {
            K key = Objects.requireNonNull(classifier.apply(t), "element cannot be mapped to a null key");
            A container = m.computeIfAbsent(key, k -> downstreamSupplier.get());
            downstreamAccumulator.accept(container, t);
        };
        BinaryOperator<Map<K, A>> merger = Collectors.<K, A, Map<K, A>>mapMerger(downstream.combiner());
        @SuppressWarnings("unchecked")
        Supplier<Map<K, A>> mangledFactory = (Supplier<Map<K, A>>) mapFactory;

        if (downstream.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)) {
            return new CollectorImpl<>(mangledFactory, accumulator, merger, CH_ID);
        }
        else {
            @SuppressWarnings("unchecked")
            Function<A, A> downstreamFinisher = (Function<A, A>) downstream.finisher();
            Function<Map<K, A>, M> finisher = intermediate -> {
                intermediate.replaceAll((k, v) -> downstreamFinisher.apply(v));
                @SuppressWarnings("unchecked")
                M castResult = (M) intermediate;
                return castResult;
            };
            return new CollectorImpl<>(mangledFactory, accumulator, merger, finisher, CH_NOID);
        }
}

groupingByConcurrent

/**
 * 返回一個對輸入的指定類型的元素執行分組操作的并行Collector
 * 	- 根據分組函數進行分組操作
 * 	- 并將結果以Map類型返回 
 *  
 * @param classifier 指定的分組函數
 * @return Collector<T, ?, ConcurrentMap<K, List<T>>> 實現分組操作的并發無序的Collector
 */
public static <T, K> Collector<T, ?, ConcurrentMap<K, List<T>>> groupingByConcurrent(Function<? super T, ? extends K> classifier) {
        return groupingByConcurrent(classifier, ConcurrentHashMap::new, toList());
}

/**
 * 返回一個對輸入的指定類型的元素執行級聯分組操作的并行Collector
 * 	- 根據分組函數進行分組操作
 * 	- 然后根據下游收集器對關聯key的指定value值執行指定的規約操作 
 *  
 * @param classifier 指定的分組函數
 * @downstream 指定執行規約操作的下游收集器
 * @return Collector<T, ?, ConcurrentMap<K, D>> 實現分組操作的并發無序的Collector
 */
public static <T, K, A, D> Collector<T, ?, ConcurrentMap<K, D>> groupingByConcurrent(Function<? super T, ? extends K> classifier, Collector<? super T, A, D> downstream) {
        return groupingByConcurrent(classifier, ConcurrentHashMap::new, downstream);
}

/**
 * 返回一個對輸入的指定類型的元素執行級聯分組操作的并行Collector
 * 	- 根據分組函數進行分組操作
 * 	- 再根據下游收集器對關聯key的指定value值執行指定的規約操作 
 *  - 然后將結果保存到指定方式實現的Map中
 *  
 * @param classifier 指定的分組函數
 * @param mapFactory 指定的Map實現
 * @downstream 指定執行規約操作的下游收集器
 * @return Collector<T, ?, ConcurrentMap<K, D>> 實現分組操作的并發無序的Collector
 */
public static <T, K, A, D, M extends ConcurrentMap<K, D>> Collector<T, ?, M> groupingByConcurrent(Function<? super T, ? extends K> classifier, Supplier<M> mapFactory, Collector<? super T, A, D> downstream) {
        Supplier<A> downstreamSupplier = downstream.supplier();
        BiConsumer<A, ? super T> downstreamAccumulator = downstream.accumulator();
        BinaryOperator<ConcurrentMap<K, A>> merger = Collectors.<K, A, ConcurrentMap<K, A>>mapMerger(downstream.combiner());
        @SuppressWarnings("unchecked")
        Supplier<ConcurrentMap<K, A>> mangledFactory = (Supplier<ConcurrentMap<K, A>>) mapFactory;
        BiConsumer<ConcurrentMap<K, A>, T> accumulator;
        if (downstream.characteristics().contains(Collector.Characteristics.CONCURRENT)) {
            accumulator = (m, t) -> {
                K key = Objects.requireNonNull(classifier.apply(t), "element cannot be mapped to a null key");
                A resultContainer = m.computeIfAbsent(key, k -> downstreamSupplier.get());
                downstreamAccumulator.accept(resultContainer, t);
            };
        }
        else {
            accumulator = (m, t) -> {
                K key = Objects.requireNonNull(classifier.apply(t), "element cannot be mapped to a null key");
                A resultContainer = m.computeIfAbsent(key, k -> downstreamSupplier.get());
                synchronized (resultContainer) {
                    downstreamAccumulator.accept(resultContainer, t);
                }
            };
        }

        if (downstream.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)) {
            return new CollectorImpl<>(mangledFactory, accumulator, merger, CH_CONCURRENT_ID);
        }
        else {
            @SuppressWarnings("unchecked")
            Function<A, A> downstreamFinisher = (Function<A, A>) downstream.finisher();
            Function<ConcurrentMap<K, A>, M> finisher = intermediate -> {
                intermediate.replaceAll((k, v) -> downstreamFinisher.apply(v));
                @SuppressWarnings("unchecked")
                M castResult = (M) intermediate;
                return castResult;
            };
            return new CollectorImpl<>(mangledFactory, accumulator, merger, finisher, CH_CONCURRENT_NOID);
        }
}

joining

/**
 * 返回一個根據接收元素的順序將元素連接成一個String字符串的Collector
 *  
 * @return Collector<CharSequence, ?, String> 根據接收元素的順序將元素連接成一個字符串的Collector
 */
public static Collector<CharSequence, ?, String> joining() {
        return new CollectorImpl<CharSequence, StringBuilder, String>(
                StringBuilder::new, StringBuilder::append,
                (r1, r2) -> { r1.append(r2); return r1; },
                StringBuilder::toString, CH_NOID);
}

/**
 * 返回一個根據接收元素的順序將元素連接成一個String字符串并以指定的分隔符分割的Collector
 *  
 * @param delimiter 用于每個元素之間的分割符
 * @return Collector<CharSequence, ?, String> 根據接收元素的順序將元素連接成一個字符串并以指定分割符分割的Collector
 */
public static Collector<CharSequence, ?, String> joining(CharSequence delimiter) {
        return joining(delimiter, "", "");
}

/**
 * 返回一個根據接收元素的順序將元素連接成一個String字符串并以指定的分隔符分割和指定前綴和后綴的Collector
 *  
 * @param delimiter 用于每個元素之間的分割符
 * @param prefix 指定的前綴
 * @param suffix 指定的后綴 
 * @return Collector<CharSequence, ?, String> 根據接收元素的順序將元素連接成一個字符串并以指定分割符分割和指定的前綴和后綴的Collector
 */
public static Collector<CharSequence, ?, String> joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix) {
        return new CollectorImpl<>(
                () -> new StringJoiner(delimiter, prefix, suffix),
                StringJoiner::add, StringJoiner::merge,
                StringJoiner::toString, CH_NOID);
}

mapping

/**
 * 在累積元素之前應用映射函數將類型為U的收集器調整為類型為T的收集器
 * mapping操作對多級規約操作最有用
 *  
 * @param mapper 映射函數
 * @param downstream 下游收集器
 * @return Collector<T, ?, R> 執行映射函數操作后的收集器
 */
public static <T, U, A, R> Collector<T, ?, R> mapping(Function<? super T, ? extends U> mapper, Collector<? super U, A, R> downstream) {
        BiConsumer<A, ? super U> downstreamAccumulator = downstream.accumulator();
        return new CollectorImpl<>(downstream.supplier(),
                                   (r, t) -> downstreamAccumulator.accept(r, mapper.apply(t)),
                                   downstream.combiner(), downstream.finisher(),
                                   downstream.characteristics());
}

maxBy

/**
 * 返回一個根據給定的比較器Comparator生成最大元素的Collector,使用Optional<T>描述
 *  
 * @param comparator 指定的比較器
 * @return Collector<T, ?, Optional<T>> 根據比較器生成最大元素的Collector
 */
public static <T> Collector<T, ?, Optional<T>> maxBy(Comparator<? super T> comparator) {
        return reducing(BinaryOperator.maxBy(comparator));
}

minBy

/**
 * 返回一個根據給定的比較器Comparator生成最小元素的Collector,使用Optional<T>描述
 *  
 * @param comparator 指定的比較器
 * @return Collector<T, ?, Optional<T>> 根據比較器生成最小元素的Collector
 */
public static <T> Collector<T, ?, Optional<T>> (Comparator<? super T> comparator) {
        return reducing(BinaryOperator.minBy(comparator));
}

partitioningBy

/**
 * 返回一個根據指定規則分類的Collector,結果保存到Map<Boolean, List>中
 *  
 * @param predicate 指定的分類規則
 * @return Collector<T, ?, Map<Boolean, List<T>>> 按照指定規則進行分類,并將結果保存到Map<Boolean, List>的收集器
 */
public static <T> Collector<T, ?, Map<Boolean, List<T>>> partitioningBy(Predicate<? super T> predicate) {
        return partitioningBy(predicate, toList());
}

/**
 * 返回一個根據指定規則分類的Collector,并將結果值按照下游收集器執行規約操作,然后將規約后的結果保存到Map<Boolean, D>中
 * 
 * @param predicate 指定的分類規則
 * @param downstream 指定的執行規約操作的下游收集器
 * @return Collector<T, ?, Map<Boolean, D>> 按照指定規則進行分類,并將結果值按照下游收集器執行規約操作,然后將規約后的結果保存到Map<Boolean, D>的收集器
 */
public static <T, D, A> Collector<T, ?, Map<Boolean, D>> partitioningBy(Predicate<? super T> predicate, Collector<? super T, A, D> downstream) {
        BiConsumer<A, ? super T> downstreamAccumulator = downstream.accumulator();
        BiConsumer<Partition<A>, T> accumulator = (result, t) ->
                downstreamAccumulator.accept(predicate.test(t) ? result.forTrue : result.forFalse, t);
        BinaryOperator<A> op = downstream.combiner();
        BinaryOperator<Partition<A>> merger = (left, right) ->
                new Partition<>(op.apply(left.forTrue, right.forTrue),
                                op.apply(left.forFalse, right.forFalse));
        Supplier<Partition<A>> supplier = () ->
                new Partition<>(downstream.supplier().get(),
                                downstream.supplier().get());
        if (downstream.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)) {
            return new CollectorImpl<>(supplier, accumulator, merger, CH_ID);
        }
        else {
            Function<Partition<A>, Map<Boolean, D>> finisher = par ->
                    new Partition<>(downstream.finisher().apply(par.forTrue),
                                    downstream.finisher().apply(par.forFalse));
            return new CollectorImpl<>(supplier, accumulator, merger, finisher, CH_NOID);
        }
}

reducing

/**
 * 返回一個按照指定的規約操作獲得結果的Colletor.結果以Optional<T>描述
 *  
 * @param op 指定的規約操作
 * @return Collector<T, ?, Optional<T>> 按照指定的規約操作執行的結果
 */
public static <T> Collector<T, ?, Optional<T>> reducing(BinaryOperator<T> op) {
        class OptionalBox implements Consumer<T> {
            T value = null;
            boolean present = false;

            @Override
            public void accept(T t) {
                if (present) {
                    value = op.apply(value, t);
                }
                else {
                    value = t;
                    present = true;
                }
            }
        }

        return new CollectorImpl<T, OptionalBox, Optional<T>>(
                OptionalBox::new, OptionalBox::accept,
                (a, b) -> { if (b.present) a.accept(b.value); return a; },
                a -> Optional.ofNullable(a.value), CH_NOID);
}

/**
 * 返回一個使用指定標識,按照指定的規約操作獲得結果的Colletor
 *  
 * @param identity 指定的標識,也是結果為空時的返回值
 * @param op 指定的規約操作
 * @return Collector<T, ?, T> 按照指定的規約操作執行的結果,當結果為空時返回指定的標識identity
 */
public static <T> Collector<T, ?, T> reducing(T identity, BinaryOperator<T> op) {
        return new CollectorImpl<>(
                boxSupplier(identity),
                (a, t) -> { a[0] = op.apply(a[0], t); },
                (a, b) -> { a[0] = op.apply(a[0], b[0]); return a; },
                a -> a[0],
                CH_NOID);
}

/**
 * 返回一個使用指定標識,按照指定的映射操作和規約操作獲得結果的Colletor
 *  
 * @param identity 指定的標識,也是結果為空時的返回值
 * @param mapper 指定的映射操作
 * @param op 指定的規約操作
 * @return Collector<T, ?, Optional<T>> 按照指定的映射操作和規約操作執行的結果,當結果為空時返回指定的標識identity
 */
public static <T, U> Collector<T, ?, U> reducing(U identity, Function<? super T, ? extends U> mapper, BinaryOperator<U> op) {
        return new CollectorImpl<>(
                boxSupplier(identity),
                (a, t) -> { a[0] = op.apply(a[0], mapper.apply(t)); },
                (a, b) -> { a[0] = op.apply(a[0], b[0]); return a; },
                a -> a[0], CH_NOID);
}

summarizingDouble

/**
 * 返回一個使用double類型映射每一個輸入元素并返回結果值匯總信息的Collector
 *  
 * @param mapper 指定的映射操作
 * @return Collector<T, ?, DoubleSummaryStatistics> 匯總信息的規約操作
 */
public static <T> Collector<T, ?, DoubleSummaryStatistics> summarizingDouble(ToDoubleFunction<? super T> mapper) {
        return new CollectorImpl<T, DoubleSummaryStatistics, DoubleSummaryStatistics>(
                DoubleSummaryStatistics::new,
                (r, t) -> r.accept(mapper.applyAsDouble(t)),
                (l, r) -> { l.combine(r); return l; }, CH_ID);
}

summarizingInt

/**
 * 返回一個使用int類型映射每一個輸入元素并返回結果值匯總信息的Collector
 *  
 * @param mapper 指定的映射操作
 * @return Collector<T, ?, IntSummaryStatistics> 匯總信息的規約操作
 */
public static <T> Collector<T, ?, IntSummaryStatistics> summarizingInt(ToIntFunction<? super T> mapper) {
        return new CollectorImpl<T, IntSummaryStatistics, IntSummaryStatistics>(
                IntSummaryStatistics::new,
                (r, t) -> r.accept(mapper.applyAsInt(t)),
                (l, r) -> { l.combine(r); return l; }, CH_ID);
}

summarizingLong

/**
 * 返回一個使用long類型映射每一個輸入元素并返回結果值匯總信息的Collector
 *  
 * @param mapper 指定的映射操作
 * @return Collector<T, ?, IntSummaryStatistics> 匯總信息的規約操作
 */
public static <T> Collector<T, ?, LongSummaryStatistics> summarizingLong(ToLongFunction<? super T> mapper) {
        return new CollectorImpl<T, LongSummaryStatistics, LongSummaryStatistics>(
                LongSummaryStatistics::new,
                (r, t) -> r.accept(mapper.applyAsLong(t)),
                (l, r) -> { l.combine(r); return l; }, CH_ID);
}

summingDouble

/**
 * 返回一個使用double類型映射每一個輸入元素并返回元素之和的Collector
 * 如果不存在元素則返回0
 *  
 * @param mapper 指定的映射操作
 * @return Collector<T, ?, Double> 執行元素求和規約操作的Collector
 */
public static <T> Collector<T, ?, Double> summingDouble(ToDoubleFunction<? super T> mapper) {
        /*
         * 在為收集操作分配的數組中:
         * 	索引0 - 運行和的高位
         * 	索引1 - 補償計算的和的低階位求和
         * 	索引2 - 當存在無窮大結果和時正確的符號
         */
        return new CollectorImpl<>(
                () -> new double[3],
                (a, t) -> { double val = mapper.applyAsDouble(t);
                            sumWithCompensation(a, val);
                            a[2] += val;},
                (a, b) -> { sumWithCompensation(a, b[0]);
                            a[2] += b[2];
                            return sumWithCompensation(a, b[1]); },
                a -> computeFinalSum(a),
                CH_NOID);
}

summingInt

/**
 * 返回一個使用int類型映射每一個輸入元素并返回元素之和的Collector
 * 如果不存在元素則返回0
 *  
 * @param mapper 指定的映射操作
 * @return Collector<T, ?, Integer> 執行元素求和規約操作的Collector
 */
public static <T> Collector<T, ?, Integer> summingInt(ToIntFunction<? super T> mapper) {
        return new CollectorImpl<>(
                () -> new int[1],
                (a, t) -> { a[0] += mapper.applyAsInt(t); },
                (a, b) -> { a[0] += b[0]; return a; },
                a -> a[0], CH_NOID);
}

summingLong

/**
 * 返回一個使用long類型映射每一個輸入元素并返回元素之和的Collector
 * 如果不存在元素則返回0
 *  
 * @param mapper 指定的映射操作
 * @return Collector<T, ?, Integer> 執行元素求和規約操作的Collector
 */
public static <T> Collector<T, ?, Long> summingLong(ToLongFunction<? super T> mapper) {
        return new CollectorImpl<>(
                () -> new long[1],
                (a, t) -> { a[0] += mapper.applyAsLong(t); },
                (a, b) -> { a[0] += b[0]; return a; },
                a -> a[0], CH_NOID);
}

toCollection

/**
 * 返回一個將接收的元素按照接收順序放入生成的集合的Collector
 *  
 * @param collectionFactory 指定的生成的集合
 * @return Collector<T, ?, C> 將接收的元素按照接收順序生成集合的Collector
 */
public static <T, C extends Collection<T>> Collector<T, ?, C> toCollection(Supplier<C> collectionFactory) {
        return new CollectorImpl<>(collectionFactory, Collection<T>::add,
                                   (r1, r2) -> { r1.addAll(r2); return r1; },
                                   CH_ID);
}

toConcurrentMap

/**
 * 返回一個將接收的元素放入并發的Map中的并發Collector,其中Map的key和value按照指定的映射函數生成
 *  
 * @param keyMapper 鍵的映射器
 * @param valueMapper 值的映射器
 * @return Collector<T, ?, ConcurrentMap<K,U>> 將接收的元素按照放入并發的Map中的并發無序Collector
 */
public static <T, K, U> Collector<T, ?, ConcurrentMap<K,U>> toConcurrentMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper) {
        return new CollectorImpl<>(ConcurrentHashMap::new,
                                   uniqKeysMapAccumulator(keyMapper, valueMapper),
                                   uniqKeysMapMerger(),
                                   CH_CONCURRENT_ID);
}

/**
 * 返回一個將接收的元素放入并發的Map中的并發Collector,其中Map的key和value按照指定的映射函數生成
 * 如果存在重復的鍵值,則會應用指定的合并函數
 *  
 * @param keyMapper 鍵的映射器
 * @param valueMapper 值的映射器
 * @param mergeFunction 指定的合并函數
 * @return Collector<T, ?, ConcurrentMap<K,U>> 將接收的元素按照放入并發的Map中的并發Collector
 */
public static <T, K, U> Collector<T, ?, ConcurrentMap<K,U>> toConcurrentMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator<U> mergeFunction) {
        return toConcurrentMap(keyMapper, valueMapper, mergeFunction, ConcurrentHashMap::new);
}

/**
 * 返回一個將接收的元素放入指定方式實現的并發Map中的并發Collector,其中Map的key和value按照指定的映射函數生成
 * 如果存在重復的鍵值,則會應用指定的合并函數
 *  
 * @param keyMapper 鍵的映射器
 * @param valueMapper 值的映射器
 * @param mergeFunction 指定的合并函數
 * @param mapFactory 指定的Map實現方式
 * @return Collector<T, ?, M> 將接收的元素按照放入指定方式實現的并發Map中的并發Collector
 */
public static <T, K, U, M extends ConcurrentMap<K, U>> Collector<T, ?, M> toConcurrentMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper,BinaryOperator<U> mergeFunction,Supplier<M> mapFactory) {
        BiConsumer<M, T> accumulator
                = (map, element) -> map.merge(keyMapper.apply(element),
                                              valueMapper.apply(element), mergeFunction);
        return new CollectorImpl<>(mapFactory, accumulator, mapMerger(mergeFunction), CH_CONCURRENT_ID);
}

toList

/**
 * 返回一個將接收的元素按照接收的順序放入List中的收集器Collector
 *  
 * @return Collector<T, ?, List<T>> 包含輸入元素的List類型的收集器Collector
 */
public static <T> Collector<T, ?, List<T>> toList() {
        return new CollectorImpl<>((Supplier<List<T>>) ArrayList::new, List::add,
                                   (left, right) -> { left.addAll(right); return left; },
                                   CH_ID);
}

toMap

/**
 * 返回一個將接收的元素放入Map中的Collector,其中Map的key和value按照指定的映射函數生成
 *  
 * @param keyMapper 鍵映射函數
 * @param valueMapper 值映射函數
 * @return Collector<T, ?, Map<K,U>> 將接收的元素放入Map中的Collector
 */
public static <T, K, U> Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper) {
        return new CollectorImpl<>(HashMap::new,
                                   uniqKeysMapAccumulator(keyMapper, valueMapper),
                                   uniqKeysMapMerger(),
                                   CH_ID);
}

/**
 * 返回一個將接收的元素放入Map中的Collector,其中Map的key和value按照指定的映射函數生成
 * 如鍵重復,則使用指定的合并函數合并
 *  
 * @param keyMapper 鍵映射函數
 * @param valueMapper 值映射函數
 * @param mergeFunction 指定的合并函數
 * @return Collector<T, ?, Map<K,U>> 將接收的元素放入Map中的Collector
 */
public static <T, K, U> Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator<U> mergeFunction) {
        return toMap(keyMapper, valueMapper, mergeFunction, HashMap::new);
}

/**
 * 返回一個將接收的元素放入指定實現方式的Map中的Collector,其中Map的key和value按照指定的映射函數生成
 * 如鍵重復,則使用指定的合并函數合并
 *  
 * @param keyMapper 鍵映射函數
 * @param valueMapper 值映射函數
 * @param mergeFunction 指定的合并函數
 * @param mapFactory 指定的Map實現方式
 * @return Collector<T, ?, Map<K,U>> 將接收的元素放入指定實現方式的Map中的Collector
 */
public static <T, K, U, M extends Map<K, U>> <T, ?, M> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator<U> mergeFunction, <M> mapFactory) {
        BiConsumer<M, T> accumulator
                = (map, element) -> map.merge(keyMapper.apply(element),
                                              valueMapper.apply(element), mergeFunction);
        return new CollectorImpl<>(mapFactory, accumulator, mapMerger(mergeFunction), CH_ID);
}

toSet

/**
 * 返回一個將接收的元素放入Set中的收集器Collector
 *  
 * @return Collector<T, ?, Set<T>> 將接收的元素放入Set中的Collector
 */
public static <T> Collector<T, ?, Set<T>> toSet() {
       return new CollectorImpl<>((Supplier<Set<T>>) HashSet::new, Set::add,
                                   (left, right) -> {
                                       if (left.size() < right.size()) {
                                           right.addAll(left); return right;
                                       } else {
                                           left.addAll(right); return left;
                                       }
                                   },
                                   CH_UNORDERED_ID);
}

統計

產生統計結果的收集器,主要用于int,double,long等類型

List<Integer> numbers = Arrays.asList(3, 2, 3, 7, 3, 5);
IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();

System.out.println("列表中最大的數:" + stats.getMax());
System.out.println("列表中最小的數:" + stats.getMin());
System.out.println("所有數之和:" + stats.getSum());
System.out.println("平均數:" + stats.getAverage());

點擊展開全文

java流的概念（java代碼大全及詳解）

Stream基本概念

生成流

Stream的創建方式

數組

集合

Stream.generate()

Stream.iterate()

API

Stream常用方法

中間操作

filter

distinct

sorted

limit

map

peek

終止操作

循環-forEach

計算-min,max,count,sum

匹配-anyMatch,allMatch,noneMatch,findFirst,findAny

收集器-toArray,collect

parallelStream

Collectors

averagingDouble

averagingInt

averagingLong

collectingAndThen

counting

groupingBy

groupingByConcurrent

joining

mapping

maxBy

minBy

partitioningBy

reducing

summarizingDouble

summarizingInt

summarizingLong

summingDouble

summingInt

summingLong

toCollection

toConcurrentMap

toList

toMap

toSet

統計

相關推薦

2020年java好找工作嗎（java程序員的工資待遇）

java學起來難嗎，培訓java編程費用標準

java好找工作嗎，java就業前景和工資待遇

如何優化代碼運行速度，Java性能調優技巧

java架構師簡歷模板，月薪過萬的Java開發簡歷寫法

內部oa系統開發是什么，java開源oa系統源碼

發表評論

java學起來難嗎，培訓java編程費用標準

java好找工作嗎，java就業前景和工資待遇

java架構師簡歷模板，月薪過萬的Java開發簡歷寫法

內部oa系統開發是什么，java開源oa系統源碼