Java8——Stream流的使用(收集操作)(一)

在流水线处理完毕之后,我们总想将此时的流元素使用一个数据结构收集起来,或者得到一个汇总的结果。此时,我们就可以利用Stream中非常强大的collect收集操作了,通过collect操作,我们可以得到自己想要的数据结构或者一个结果。

  在流水线处理完毕之后,我们总想将此时的流元素使用一个数据结构收集起来,或者得到一个汇总的结果。此时,我们就可以利用Stream中非常强大的collect收集操作了,通过collect操作,我们可以得到自己想要的数据结构或者一个结果。
  实际上,只需要将一个通用的Collector收集器传递给collect方法,收集器定义了如何收集元素以及返回什么样的结果,我们几乎可以自己实现前面已经学习的所有终端操作,比如reduce、max、count……!而Java8经帮我们预定义了很多收集器,他们都可以通过Collectors工厂类的静态方法获取,通常我们都会直接将Collectors的所有静态方法都导入进来。当然我们也可以创建属于自己的收集器,完成更加特殊的功能!

1. 归纳

  collect方法几乎支持reduce方法的所有归纳操作,比如计数、求和、最值等等,并且Collectos已经为这些归纳操作预定义好了收集器,我们直接使用即可!

1.1 计数

  Collectos的静态方法中定义了计数的收集器!

public static < T > Collector<T,?,Long> counting()

  返回一个Collector,用于计算输入元素的数量,如果没有元素,则结果为0。相当于:reducing(0L, e -> 1L, Long::sum)操作。

使用案例:

/**
 * 计数操作
 */
@Test
public void count() {
    //前面我们讲过三种计数操作
    //Stream的count方法
    System.out.println(Stream.of(1, 2, 3, 4, 7).count());
    //特性化流的count方法
    System.out.println(Stream.of(1, 2, 3, 4, 7).mapToInt(x -> x).count());
    //map+reduce实现计数
    System.out.println(Stream.of(1, 2, 3, 4, 7)
            .map(d -> 1)
            .reduce(0, Integer::sum));


    //现在,collect操作也提供计数功能,并且已经提供了预定于的收集器
    //counting()静态方法就返回一个用于计数的收集器
    System.out.println(Stream.of(1, 2, 3, 4, 7).collect(counting()));
}
1.2 最值

  Collectos的静态方法中定义了求最值的收集器!

public static < T > Collector<T,?,Optional< T >> minBy(Comparator<? super T> comparator)

  返回一个Collector,它根据给定的Comparator产生最小元素,返回Optional< T > 。

public static < T > Collector<T,?,Optional< T >> maxBy(Comparator<? super T> comparator)

  返回一个Collector,它根据给定的Comparator产生最大元素,返回Optional< T > 。

使用案例:

/**
 * 最值
 */
@Test
public void max_min() {
    //前面我们讲过二种最值操作

    //特性化流的方法
    Stream.of(1, 2, 3, 4, 7).mapToInt(x -> x).max().ifPresent(System.out::println);
    //reduce方法
    Optional<Integer> maxReduce = Stream.of(1, 2, 3, 4, 7)
            //使用方法引用Integer::max来表示求最值的意图
            .reduce(Integer::max);
    maxReduce.ifPresent(System.out::println);


    //现在,collect操作也提供求最值功能,并且已经提供了预定于的收集器

    //minBy(Comparator) 静态方法就返回一个用于求最小值的收集器
    Stream.of(1, 2, 3, 4, 7).collect(minBy(Integer::compareTo)).ifPresent(System.out::println);
    //maxBy(Comparator) 静态方法就返回一个用于求最大值的收集器
    Stream.of(1, 2, 3, 4, 7).collect(maxBy(Integer::compareTo)).ifPresent(System.out::println);
    Stream.of(1, 2, 3, 4, 7).collect(maxBy(Comparator.comparingInt(x -> x))).ifPresent(System.out::println);
}
1.3 汇总

  Collectors的静态方法中预定义了汇总操作的收集器,比如求和、求平均数,还有一个能够返回所有参数的收集器!

public static < T > Collector<T,?,Integer> summingInt(ToIntFunction<? super T> mapper)

  返回一个Collector,它产生应用于输入元素的int值函数的和。如果没有元素,结果为0。

public static < T > Collector<T,?,Long> summingLong(ToLongFunction<? super T> mapper)

  返回一个Collector,它产生应用于输入元素的long值函数的和。如果没有元素,结果为0。

public static < T > Collector<T,?,Double> summingDouble(ToDoubleFunction<? super T> mapper)

  返回一个Collector,它产生应用于输入元素的double值函数的和。如果没有元素,结果为0。

public static < T > Collector<T,?,Double> averagingInt(ToIntFunction<? super T> mapper)

  返回一个Collector ,它产生应用于输入元素的int值函数的算术平均值。 如果没有元素,结果为0。

public static < T > Collector<T,?,Double> averagingLong(ToLongFunction<? super T> mapper)

  返回一个Collector ,它产生应用于输入元素的long值函数的算术平均值。 如果没有元素,结果为0。

public static < T > Collector<T,?,Double> averagingDouble(ToDoubleFunction<? super T> mapper)

  返回一个Collector ,它产生应用于输入元素的double值函数的算术平均值。 如果没有元素,结果为0。

public static < T > Collector<T,?,IntSummaryStatistics> summarizingInt(ToIntFunction<? super T> mapper)

  返回一个Collector ,返回int数据的总数,总和、平均值、最大值和最小值的汇总。

public static < T > Collector<T,?,LongSummaryStatistics> summarizingLong(ToLongFunction<? super T> mapper)

  返回一个Collector ,返回long数据的总数,总和、平均值、最大值和最小值的汇总。

public static < T > Collector<T,?,DoubleSummaryStatistics> summarizingDouble(ToDoubleFunction<? super T> mapper)

  返回一个Collector ,返回double数据的总数,总和、平均值、最大值和最小值的汇总。

使用案例:

/**
 * 汇总
 */
@Test
public void sum() {
    //前面我们讲过二种求和操作

    //特性化流的方法
    System.out.println(Stream.of(1, 2, 3, 4, 7).mapToInt(x -> x).sum());
    //reduce方法
    Stream.of(1, 2, 3, 4, 7)
            //使用方法引用Integer::sum来表示求和的意图
            .reduce(Integer::sum)
            .ifPresent(System.out::println);


    //现在,collect操作也提供求和功能,并且已经提供了预定于的收集器

    //summingInt(ToIntFunction) 静态方法就返回一个用于求int数据和的收集器,返回int类型的值
    System.out.println(Stream.of(1, 2, 3, 4, 7)
            .collect(summingInt(x -> x)));

    //summingLong(ToLongFunction) 静态方法就返回一个用于求long数据和的收集器,返回long类型的值
    System.out.println(Stream.of(1, 2, 3, 4, 7)
            .collect(summingLong(x -> x)));

    //summingDouble(ToDoubleFunction) 静态方法就返回一个用于求double数据和的收集器,返回double类型的值
    System.out.println(Stream.of(1, 2, 3, 4, 7)
            .collect(summingDouble(x -> x)));

    //现在,count操作还提供求平均数功能,并且已经提供了预定于的收集器

    //averagingInt(ToIntFunction) 静态方法就返回一个用于求int数据算术平均数的收集器
    System.out.println(Stream.of(1, 2, 3, 4, 7)
            .collect(averagingInt(x -> x)));

    //averagingLong(ToLongFunction) 静态方法就返回一个用于求long数据算术平均数的收集器
    System.out.println(Stream.of(1, 2, 3, 4, 7)
            .collect(averagingLong(x -> x)));

    //averagingDouble(ToDoubleFunction) 静态方法就返回一个用于求double数据算术平均数的收集器
    System.out.println(Stream.of(1, 2, 3, 4, 7)
            .collect(averagingDouble(x -> x)));


    //summarizingInt(ToIntFunction) 静态方法就返回一个用于求int数据的总和、平均值、最大值和最小值的收集器
    //返回IntSummaryStatistics对象,内部收集了所有的值
    System.out.println(Stream.of(1, 2, 3, 4, 7)
            .collect(summarizingInt(x -> x)));

    //summarizingLong(ToLongFunction) 静态方法就返回一个用于求long数据的总和、平均值、最大值和最小值的收集器
    //返回LongSummaryStatistics对象,内部收集了所有的值
    System.out.println(Stream.of(1, 2, 3, 4, 7)
            .collect(summarizingLong(x -> x)));

    //summarizingDouble(ToDoubleFunction) 静态方法就返回一个用于求double数据的总和、平均值、最大值和最小值的收集器
    //返回DoubleSummaryStatistics对象,内部收集了所有的值
    System.out.println(Stream.of(1, 2, 3, 4, 7)
            .collect(summarizingDouble(x -> x)));
}
1.4 连接

  Collectors预定义了用于连接所有字符串元素的收集器!

public static Collector<CharSequence,?,String> joining()

  返回一个Collector ,将输入元素按照顺序连接成为一个String。

public static Collector<CharSequence,?,String> joining(CharSequence delimiter)

  返回一个Collector ,将输入元素按照顺序连接成为一个String,每一个元素的字符串使用delimiter分隔。

public static Collector<CharSequence,?,String> joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)

  返回一个Collector ,将输入元素按照顺序连接成为一个String,每一个元素的字符串使用delimiter分隔。在开始连接之前加上prefix,在连接完成之后加上suffix。

  当然,前两个方法也可以直接使用Java8在String API中新增的join方法替代。使用案例:

/**
 * 连接字符串
 */
@Test
public void string() {

    //join()
    System.out.println(Stream.of("校花","小花","晓华","笑话").collect(joining()));
    System.out.println(String.join("", "校花","小花","晓华","笑话"));

    //joining(CharSequence delimiter)
    System.out.println(Stream.of("校花","小花","晓华","笑话").collect(joining("——")));
    System.out.println(String.join("——", "校花","小花","晓华","笑话"));

    //joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)
    System.out.println(Stream.of("校花","小花","晓华","笑话").collect(joining("——","开始:","。结束")));
}
全文链接:Java8——Stream流的使用(收集操作)

  • 发表于 2020-09-16 16:14
  • 阅读 ( 18 )

0 条评论

请先 登录 后评论
NX小编
NX小编

995 篇文章

作家榜 »

  1. NX小编 995 文章
  2. 58沈剑 309 文章
  3. 奈学教育 131 文章
  4. 李希沅 | 奈学教育 28 文章
  5. 江帅帅 | 奈学教育 27 文章
  6. 林淮川 | 奈学教育 12 文章
  7. 科技热点 10 文章
  8. 邱鹏超 2 文章