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<Person> 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<Person> DataFilter(List<Person> personList) {
        /**
         * 这里我们过滤年龄是15&地址是浙江的数据
         */
        return personList.stream().filter(x -> x.getAge() == 15 && x.getAddress().equals("浙江")).collect(Collectors.toList());
    }


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


    /**
     * map转集合数据
     *
     * @return
     */
    public static List<Object> mapToListHandler(Map<Object, Object> map) {
        return map.values().stream().collect(Collectors.toList());
    }


    /**
     * 数据集合转换流
     *
     * @return
     */
    public static Stream<Object> listToStreamHandler(List<Person> personList) {
        return Stream.of(personList.toArray());
    }


    public static void main(String[] args) {
        log.debug("数据集合的filter操作");
        acceptDataAndPrint(DataFilter(personList));
        log.debug("数据集合的map操作");
        List<Integer> integerList = mapHandler(personList);
        integerList.stream().forEachOrdered(x -> System.out.print(x + "\t"));
        log.debug("数据集合的去重操作");
        List<String> stringList = distinctHandler(personList);
        stringList.forEach(x -> System.out.print(x + "\t"));
        log.debug("数据集合的自然排序操作");
        acceptDataAndPrint(sortHandler(personList));
        log.debug("数据集合的自定义排序");
        acceptDataAndPrint(sortHandlerWithComparator(personList));
        log.debug("数据集合的limit限制数据的返回");
        acceptDataAndPrint(limitHandler(personList));
        log.debug("数据集合的skip跳过指定数据的处理");
        acceptDataAndPrint(skipHandler(personList));
        log.debug("数据集合的聚合操作");
        String handler = reduceHandler(personList);
        System.out.println("handler = " + handler);
        log.debug("返回数据的最大值数据");
        Person person = maxHandler(personList);
        System.out.println("person = " + person);
        log.debug("返回数据的最小值数据");
        Person p = minHandler(personList);
        System.out.println("p = " + p);
        log.debug("数据直接的allMatch操作");
        boolean matchHandler = allMatchHandler(personList);
        System.out.println("matchHandler = " + matchHandler);
        log.debug("数据直接的anyMatch操作");
        boolean anyMatchHandler = anyMatchHandler(personList);
        System.out.println("anyMatchHandler = " + anyMatchHandler);
        log.debug("数据直接的noneMatch操作");
        boolean noneMatchHandler = noneMatchHandler(personList);
        System.out.println("noneMatchHandler = " + noneMatchHandler);
        log.debug("数据集合的统计操作");
        long count = countHandler(personList);
        System.out.println("count = " + count);
        log.debug("数据集合的findFirst操作");
        Person firstHandler = findFirstHandler(personList);
        System.out.println("firstHandler = " + firstHandler);
        log.debug("数据集合转为数组的操作");
        Object[] objects = toArrayHandler(personList);
        Arrays.stream(objects).forEachOrdered(System.out::println);
        log.debug("数据集合转为map操作");
        Map<Object, Object> map = listToMapHandler(personList);
        mapDataHandler(map);
        Map<String,String>  hashMap = new HashMap<>(16,0.75f);
        hashMap.put("key","value");
        hashMap.put("key2","value2");
        hashMap.put("key3","value3");
        log.debug("map转为集合的操作");
        List<Object> objectList = mapToListHandler(map);
        objectList.stream().forEach(System.out::println);
        log.debug("转为数据流Stream的操作");
        Stream<Object> stream = listToStreamHandler(personList);
        List<Object> collect = stream.collect(Collectors.toList());
        collect.forEach(System.out::println);
    }
}

关于集合的Stream操作就到这里结束了，还是喜欢那简单而有用的示例程序，java基础性的文章终于告一段落了。文中的实体类person主要包含id,name,age,address字段用于测试，自己在用时新建一个就可以了。