Java--Java8Stream

Stream 笔记

package com.example.test;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.junit.Test;

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

@Data
@NoArgsConstructor
@AllArgsConstructor
class Person{
    private Integer id ;
    private String name;
    private Integer age;


}
public class Java8Test {
    @Test
    public void test01(){
        Person p1 = new Person(1,"zhangsan",12);
        Person p2 = new Person(2,null,13);
        Person p3 = new Person(3,null,15);
        List<Person> l1 = new ArrayList();
        l1.add(p1);
        l1.add(p2);
        l1.add(p3);
        l1.stream().filter(x->{
            System.out.println(x.getName());
            return x.getName().equals("");}).forEach(System.out::println);
        System.out.println("stop");
        System.exit(0);

        // 一、创建 Stream
        // 1、通过 Collection 系列集合提供的stream() 或 parallelStream()
        List<String> list1 = new ArrayList<>();
        list1.stream().filter((x)->{return x.equals("1");}).forEach(System.out::println);
        Stream<String> s1 = list1.stream();
        // 2、通过 Arrays 中的静态方法 stream() 获取数组流
        int[] arr = new int[10];
        Arrays.stream(arr);
        // 3、通过 Stream 类中的静态方法 of()
        Stream.of("a","b");
        // 4、创建无限流
            // 迭代
            Stream.iterate(0,(x) -> x+2);
            // 生成
            Stream.generate(() -> Math.random());

        // 二、中间操作
        /**
         * 筛选与切片
         * filter   接收Lambda，从流中排除某些元素
         * limit    截断流，使元素不超过给定的数量
         * skip(n)  跳过元素，返回一个扔掉前n个元素的流，若流中元素不足n个，则返回一个空流，与limit(n)互补
         * distinct 去重，筛选，通过流所生成的元素的hashCode 和 equals 去除元素
         */

        /**
         * 映射
         * map 接收Lambda，将元素转换成其他形式或提取信息，接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
         * .map 返回值是一个流
         *
         * flatMap 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
         */
        List<String> list = Arrays.asList("aaa","bbb");
        list.stream().map(str-> str.toUpperCase())
                .forEach(System.out::print);

        /**
         * 排序
         * sorted 自然排序（Comparable）
         * sorted(Comparator com) 定制排序
         *
         */

        list.stream().sorted()
                .forEach(System.out::print);



        /**
         * 中止操作
         *
         * allMatch 检查是否匹配所有元素
         * anyMatch 检查是否至少匹配一个元素
         * noneMatch 检查是否没有匹配所有元素
         * findFirst 返回第一个元素
         * findAny 返回当前流中任意元素
         * count 返回流中元素总个数
         * max 返回流中最大值
         * min 返回流中最小1
         *
         */


        /**
         * 规约
         * reduce
         * 将流中元素反复结合起来得到一个值
         * 可以和map联合起来，先进行map，之后进行reduce
         */
        // 获取年龄总和
        Optional<Integer> o1 =  l1.stream()
                .map(Person::getAge)
                .reduce(Integer::sum);
        System.out.println(o1.get());

        /**
         * 收集
         * collect
         * 可以 sum count max min group by 多级分组 分区 join 字符串连接
         * 将流转换成其他形式，接收一个Collector 接口的实现，用于给Stream中元素做汇总的方法
         *
         */
        l1.stream()
                .map(Person::getName)
                .collect(Collectors.toList());

        // 获取年龄平均值
        l1.stream()
                .collect(Collectors.averagingInt(Person::getAge));
        //
        IntSummaryStatistics i1 = l1.stream()
                .collect(Collectors.summarizingInt(Person::getAge));
        i1.getSum();
        i1.getAverage();
        i1.getMin();
        i1.getMax();

        /**
         *
         *
         */
    }
}

public class CountTask extends RecursiveTask<Integer>{

    private static final int THREAD_HOLD = 2;

    private int start;
    private int end;

    public CountTask(int start,int end){
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        int sum = 0;
        //如果任务足够小就计算
        boolean canCompute = (end - start) <= THREAD_HOLD;
        if(canCompute){
            for(int i=start;i<=end;i++){
                sum += i;
            }
        }else{
            int middle = (start + end) / 2;
            CountTask left = new CountTask(start,middle);
            CountTask right = new CountTask(middle+1,end);
            //执行子任务
            left.fork();
            right.fork();
            //获取子任务结果
            int lResult = left.join();
            int rResult = right.join();
            sum = lResult + rResult;
        }
        return sum;
    }

    public static void main(String[] args){
        ForkJoinPool pool = new ForkJoinPool();
        CountTask task = new CountTask(1,4);
        Future<Integer> result = pool.submit(task);
        try {
            System.out.println(result.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}