Java8 -- Stream 使用

Stream 流创建

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Stream;

/**
 * @Author LWL
 * @Date 2022/7/29 0:14
 * @TODO Stream 流创建
 */
public class Create {

    // TODO List集合创建
    public static void create1() {
        ArrayList<String> list = new ArrayList<>(1024);
        Stream<String> stream = list.stream();
    }

    // TODO 数组创建
    public static void create2() {
        Integer[] arr = {1, 2, 3, 4, 5, 5};
        Stream<Integer> arr1 = Stream.of(arr);
        Stream<Integer> stream = Arrays.stream(arr);
    }

    // TODO Map集合创建
    public static void create3() {
        HashMap<String, Object> map = new HashMap<>();
        Stream<Map.Entry<String, Object>> stream = map.entrySet().stream();
    }
}

filter & distinct

    // TODO 过滤及去重
    public static void filter() {
        list1.stream().filter(item -> item.length() > 1).distinct().forEach(System.out::println);
    }

Map & sorted

    // TODO 转换计算排序
    public static void map() {
        list2.stream().map(TestModel::getAge).
                map(item -> item + 10).sorted((a, b) -> b - a).collect(Collectors.toList()).forEach(System.out::println);
    }

limit & skip

    // TODO 控制数据量 skip跳过条数
    public static void limit() {
        list2.stream().map(TestModel::getName).limit(2).skip(2).forEach(System.out::println);
    }

flatMap

    // TODO 控制集合
    public static void flatMap() {
        list2.stream().
                flatMap(x -> x.getTestModel2().stream())
                .map(x -> x.getHeight())
                .collect(Collectors.toList())
                .forEach(System.out::println);
    }
    public static void flatMap2() {
        list2.stream()
                .flatMap(x -> x.getTestModel2().stream())
                .distinct()
                .flatMap(x -> Arrays.stream(x.getHobby().split(",")))
                .distinct()
                .forEach(System.out::println);
    }

count

    // TODO 总数
    public static void count() {
        System.out.println(list2.stream().distinct().count());
    }

Max & Min

    // TODO 最值
    public static void maxAndMin() {
        list2.stream()
                .flatMap(x -> x.getTestModel2().stream())
                .distinct()
                .map(x -> x.getHeight())
                .max(Comparator.comparingInt(a -> a))
                .get();
    }

anyMatch & allMatch & noneMatch

    // TODO 匹配
    public static void anyMath() {
        // TODO 任意一个匹配条件,任意一个符合,返回true
        list2.stream()
                .anyMatch(x -> x.getAge() > 22);

        // TODO 所有元素匹配条件,所有元素符合才返回true
        list2.stream()
                .allMatch(x -> x.getAge() > 22);

        // TODO 所有元素匹配条件,所有元素都不符合才返回true
        list2.stream()
                .noneMatch(x -> x.getAge() > 22);
    }

findAny & findFirst

    // TODO 查找
    public static void qry() {
        // TODO 获取随机值
        System.out.println(list2.stream().findAny().get());
        // TODO 获取第一条
        System.out.println(list2.stream().findFirst().get());
    }

reduce

    // TODO 归并
    public static void reduce() {

        /*  ========================================   reduce 源码    ========================================
         *  boolean foundAny = false;
         *      T result = null;
         *      for (T element : this stream) {
         *          if (!foundAny) {
         *              foundAny = true;
         *              result = element;
         *          }
         *          else
         *              result = accumulator.apply(result, element);
         *      }e
         *      return foundAny ? Optional.of(result) : Optional.empty();
         */

        // TODO 求和
        Integer sum = list2.stream().map(TestModel::getAge).reduce(0, (result, element) -> result + element);
        // TODO 最值
        Integer max = list2.stream().map(TestModel::getAge).reduce(Integer.MIN_VALUE, (result, element) -> result > element ? result : element);
        Integer min = list2.stream().map(TestModel::getAge).reduce(Integer.MAX_VALUE, (result, element) -> result < element ? result : element);
    }

parallel & parallelStream

    // TODO 并行流
    public static void parallel() {
        Integer sum = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
                .parallel()
                .peek(x -> System.out.println(Thread.currentThread().getName()))//中间操作
                .filter(num -> num > 5)
                .reduce((result, element) -> result + element)
                .get();
        System.out.println(sum);

        ArrayList<Object> list = new ArrayList<>();
        list.parallelStream(); // stream().parallel() 简写
    }
}