java进阶|java8Stream数据处理全面总结

java8提供了对集合数据进行处理一系列数据的方法，今天就全面解析一下其用法，也是自己对其的一个总结性文章的结束了，后面就不再写这样的文章了。

关于Stream的用法，记住原点，中间操作，终端操作这三个知识点就可以了。

整个代码的示例程序已经包含了整个用法的详细解释，这里就不一一用文字进行描述了。

package com.wpw.springbootjuc.java8;


import lombok.extern.slf4j.Slf4j;


import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;


/**
 * 使用最新的Stream流数据api进行数据处理
 *
 * @author wpw
 */
@Slf4j
public class CollectionTest {
    private static final List personList = new ArrayList<>();


    static {
        personList.add(Person.builder().build().setId(1L).setName("张三").setAge(15).setAddress("浙江"));
        personList.add(Person.builder().build().setId(2L).setName("李四").setAge(15).setAddress("河南"));
        personList.add(Person.builder().build().setId(3L).setName("王五").setAge(16).setAddress("北京"));
        personList.add(Person.builder().build().setId(4L).setName("赵六").setAge(16).setAddress("上海"));
        personList.add(Person.builder().build().setId(5L).setName("孙七").setAge(17).setAddress("浙江"));
    }


    /**
     * 数据过滤的测试
     */
    private static List DataFilter(List personList) {
        /**
         * 这里我们过滤年龄是15&地址是浙江的数据
         */
        return personList.stream().filter(x -> x.getAge() == 15 && x.getAddress().equals("浙江")).collect(Collectors.toList());
    }


    /***
     * 数据的输出print
     */
    public static void acceptDataAndPrint(List personList) {
        personList.forEach(x -> System.out.println("x = " + x));
    }


    /**
     * 数据的转换或者可以说是处理map
     *
     * @return
     */
    public static List mapHandler(List personList) {
        /***
         * 只获取年纪这个字段的数据，进行数据的收集
         * 其它字段的数据收集类推
         */
        return personList.stream().map(Person::getAge).collect(Collectors.toList());
    }


    /**
     * 数据集合的去重distinct
     *
     * @return
     */
    public static List distinctHandler(List personList) {
        /**
         * 处理数据集合地址重复的数据，然后进行收集
         */
        return personList.stream().map(Person::getAddress).distinct().collect(Collectors.toList());
    }


    /**
     * 数据集合的自然排序
     *
     * @return
     */
    public static List sortHandler(List personList) {
        return personList.stream().sorted().collect(Collectors.toList());
    }


    /***
     *数据集合的自定义排序
     * @return
     */
    public static List sortHandlerWithComparator(List personList) {
        /**
         * 按照年级进行排序，你可以根据自己的需求进行排序
         */
        return personList.stream().sorted(Comparator.comparing(Person::getAge)).collect(Collectors.toList());
    }


    /**
     * 数据集合的limit,想到mysql这样的db用法了
     *
     * @return
     */
    public static List limitHandler(List personList) {
        /**
         * 只会过滤出前两条数据
         */
        return personList.stream().limit(2).collect(Collectors.toList());
    }


    /**
     * 数据集合skip方法的使用
     *
     * @return
     */
    public static List skipHandler(List personList) {
        /**
         * 跳过前两个数据，然后进行数据的收集
         */
        return personList.stream().skip(2).collect(Collectors.toList());
    }


    /**
     * 数据的收集聚合操作reduce
     *
     * @return
     */
    public static String reduceHandler(List personList) {
        return personList.stream().map(Person::getAddress).reduce("地址集合", (x, y) -> x + y);
    }


    /**
     * 返回数据集合中年纪最大的数据max
     *
     * @return
     */
    public static Person maxHandler(List personList) {
        return personList.stream().max(Comparator.comparing(Person::getAge)).orElse(null);
    }


    /**
     * 返回数据集合中年纪最小的数据min
     *
     * @return
     */
    public static Person minHandler(List personList) {
        return personList.stream().min(Comparator.comparing(Person::getAge)).orElse(null);
    }


    /**
     * 判断数据集合是否全部满足某一规则
     *
     * @return
     */
    public static boolean allMatchHandler(List personList) {
        return personList.stream().map(Person::getAddress).allMatch("浙江"::equals);
    }


    /**
     * 判断数据集合是否任意满足某一规则
     *
     * @return true/false
     */
    public static boolean anyMatchHandler(List personList) {
        return personList.stream().map(Person::getAddress).anyMatch("浙江"::equals);
    }


    /**
     * 判断数据集合是否全部不满足某一规则
     *
     * @return true/false
     */
    public static boolean noneMatchHandler(List personList) {
        return personList.stream().map(Person::getAddress).noneMatch("郑州"::equals);
    }


    /**
     * 统计数据集合的数据count
     *
     * @return count汇总数据的个数
     */
    public static long countHandler(List personList) {
        return personList.stream().count();
    }


    /**
     * 处理数据集合中，满足执行条件的第一个数据findFirst
     *
     * @return
     */
    public static Person findFirstHandler(List personList) {
        return personList.stream().filter(x -> x.getAddress().equals("浙江")).findFirst().orElse(null);
    }


    /**
     * 数据转集合，集合转数据的介绍toArray
     *
     * @return
     */
    public static Object[] toArrayHandler(List personList) {
        return personList.stream().map(Person::getAddress).toArray();
    }


    /**
     * 数据集合转为map
     *
     * @return
     */
    public static Map listToMapHandler(List personList) {
        /**
         * 按照地址进行map的转换
         */
        return personList.stream().collect(Collectors.toMap(Function.identity(), Person::getAddress));
    }


    /**
     * 处理map的数据信息
     */
    public static void mapDataHandler(Map map) {
        map.forEach((key, value) -> {
            System.out.println(String.format("键%s--值:%s", key, value));
        });
    }


    /**
     * map转集合数据
     *
     * @return
     */
    public static List