java8 stream api简单说明

实体类

package com.example.demo.java8;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
class Employee {
    private int id;
    private String name;
    private double salary ;

    public Employee(Integer id) {
        this.id = id;
    }

    public Employee(Integer id, String name) {
        this.id = id;
        this.name = name;
    }
}

实体类方法

package com.example.demo.java8;

import java.util.ArrayList;
import java.util.List;

public class EmployeeFunction {
    public static List<Employee> getList(){
        ArrayList<Employee> list = new ArrayList<>();
        list.add(new Employee(1,"单点",45d));
        list.add(new Employee(2,"方法",40d));
        list.add(new Employee(3,"听音乐",30d));
        list.add(new Employee(4,"堂堂一个",25d));
        //这个重复数据
        list.add(new Employee(4,"堂堂一个",25d));
        list.add(new Employee(6,"狗狗狗",25d));
        return list;
    }
}

stream方法演示

package com.example.demo.java8;

import org.junit.Test;

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

public class TestStream {

    // 创建流
    @Test
    public void test1(){
        //顺序流
        List<Employee> list = EmployeeFunction.getList();
        Stream<Employee> stream = list.stream();

        //并行流
        Stream<Employee> parallelStream = list.parallelStream();

        //通过数组
        int[] a = {1,2,3};
        IntStream intStream = Arrays.stream(a);

        //stream of方法
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6);
    }

    /**
     * 筛选与切片
     */
    @Test
    public void test2(){
        List<Employee> list = EmployeeFunction.getList();

        //过滤
        list.stream().filter(a ->a.getSalary()>30d).forEach(System.out::println);
        System.out.println("---------------------------------------------------------------");

        //只取前面几个元素
        list.stream().limit(1).forEach(System.out::println);
        System.out.println("---------------------------------------------------------------");

        //跳过前面几个元素
        list.stream().skip(2).forEach(System.out::println);
        System.out.println("---------------------------------------------------------------");

        //去重 hashcode和equals方法
        list.stream().distinct().forEach(System.out::println);
        System.out.println("---------------------------------------------------------------");

    }

    /**
     * 映射
     */
    @Test
    public void test3(){
        List<String> list = Arrays.asList("aaa", "bbb", "ccc");
        List<Employee> employees = EmployeeFunction.getList();

        //map映射使用
        list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);

        //取出名字长度大于2的姓名
        Stream<String> nameStream = employees.stream().map(Employee::getName);
        nameStream.filter(str->str.length()>2).forEach(System.out::println);

        //flatmap映射使用
        //使用map来做
        Stream<Stream<Character>> stream1 = list.stream().map(TestStream::stringToStream);
        stream1.forEach(s-> {
            s.forEach(System.out::println);
        });

        System.out.println();

        //使用flatMap来做
        Stream<Character> stream2 = list.stream().flatMap(TestStream::stringToStream);
        stream2.forEach(System.out::println);


    }

    public static Stream<Character> stringToStream(String str){
        ArrayList<Character> list = new ArrayList<>();

        for (Character c : str.toCharArray()){
            list.add(c);
        }
        return list.stream();
    }

    /**
     * 排序
     */
    @Test
    public void test4(){
        //自然排序
        List<Integer> asList = Arrays.asList(12, 12122, -1, 1);
        asList.stream().sorted().forEach(System.out::println);

        //比较器  按id倒着排序
        List<Employee> list = EmployeeFunction.getList();
        list.stream().sorted( (s1,s2)-> {
            return -Integer.compare(s1.getId(), s2.getId());
        }).forEach(System.out::println);
    }

    /**终止操作 //匹配与查找
     */
    @Test
    public void test5(){
        List<Employee> list = EmployeeFunction.getList();

        //allMatch 全匹配
        boolean b1 = list.stream().allMatch(e -> e.getSalary() > 30);
        System.out.println(b1);

        //anyMatch 一个匹配上就行
        boolean b2 = list.stream().anyMatch(e -> e.getSalary() > 20);
        System.out.println(b2);

        //noneMatch 是否没有匹配元素
        boolean b3 = list.stream().noneMatch(e -> e.getName().startsWith("听"));
        System.out.println(b3);

        //findFirst返回第一个
        Optional<Employee> first = list.stream().findFirst();
        System.out.println(first);

        //findAny返回任意元素
        Optional<Employee> any = list.stream().findAny();
        System.out.println(any);

        //计数 计算工资大于31的个数
        long count = list.stream().filter(e -> e.getSalary() > 31).count();
        System.out.println(count);

        //最大
        Optional<Employee> max = list.stream().max((e1, e2) -> {
            return Integer.compare(e1.getId(), e2.getId());
        });
        System.out.println(max);

        //最小
        Optional<Employee> min = list.stream().min((e1, e2) -> {
            return Integer.compare(e1.getId(), e2.getId());
        });
        System.out.println(min);
    }

    /**终止操作 //归约
     */
    @Test
    public void test6(){
        List<Integer> asList = Arrays.asList(1, 2, 3);
        Integer reduce1 = asList.stream().reduce(0, Integer::sum);
        System.out.println(reduce1);

        //计算工资总和
        List<Employee> list = EmployeeFunction.getList();
        Optional<Double> reduce2 = list.stream().map(e -> e.getSalary()).reduce(Double::sum);
        System.out.println(reduce2);
    }

    /**终止操作 //收集
     */
    @Test
    public void test7(){
        //找出工资大于29的员工
        List<Employee> list = EmployeeFunction.getList();

        List<Employee> list1 = list.stream().filter(e -> e.getSalary() > 29).collect(Collectors.toList());
        System.out.println(list1);

        Set<Employee> set1 = list.stream().collect(Collectors.toSet());
        System.out.println(set1);
    }

    /**optional类
     */
    @Test
    public void test8(){
        
    }
}