StreamAPI

package cn.com.css.xtbg;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@EqualsAndHashCode
@NoArgsConstructor
public class Employee {
    private  Integer id;
    private String name;
    private Integer age;
    private  Double salary;

}

 

import org.apache.xmlbeans.impl.regex.Match;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.function.UnaryOperator;
import java.util.stream.Stream;
public class Test {
    /*
    Stream API
     */

    public static void main(String[] args) {

        createStream();
    }

    /*
    创建Stream流
     */
    private  static void createStream(){

       // 1.集合创建
        ArrayList<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();

        //  2.数组
        Integer[] integers = new Integer[10];
        Stream<Integer> stream2 = Arrays.stream(integers);

        // 3.Stream的静态方法
        Stream<Integer> stream3 = Stream.of(1, 2, 3, 4, 5);

        //4.无限流
        Stream<Integer> stream4 = Stream.iterate(0, (x) -> x + 2).limit(10);
        System.out.println("4.无限流");
        stream4.forEach(System.out::println);



        //5.生成2个随机数
        Stream<Double> stream5 = Stream.generate(Math::random).limit(2);
        System.out.println("生成2个随机数");
        stream5.forEach(System.out::println);

    }

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

       */
   

private  static void operate(){
    ArrayList<Employee> employees = new ArrayList<>();
    employees.add(new Employee(1,"zhangsan1",30,5000.20));
    employees.add(new Employee(2,"zhangsan2",35,5000.20));
    employees.add(new Employee(3,"zhangsan3",30,5000.20));
    employees.add(new Employee(4,"zhangsan4",35,5000.20));
    employees.add(new Employee(5,"zhangsan5",30,5000.20));
    employees.add(new Employee(6,"zhangsan6",35,6000.20));
    employees.add(new Employee(7,"zhangsan7",30,5000.20));
    employees.add(new Employee(8,"zhangsan8",30,4000.20));
    employees.add(new Employee(9,"zhangsan9",30,5000.20));
    employees.add(new Employee(10,"zhangsan10",28,5000.20));
    employees.add(new Employee(11,"zhangsan11",30,5000.20));
    employees.add(new Employee(12,"zhangsan12",30,5000.20));
    employees.add(new Employee(13,"zhangsan13",18,5000.20));
    employees.add(new Employee(14,"zhangsan14",35,5000.20));

    System.out.println("employees总数:"+employees.size());

    //filter的使用
    System.out.println("------filter的使用--------");
    System.out.println("1.过滤筛选出年龄大于等于30的员工");
    List<Employee> employees1 = employees.stream().filter((e) -> {
        return e.getAge() >= 30;
    }).collect(Collectors.toList());

    employees1.stream().forEach(System.out::println);
    System.out.println("总数: " +employees1.size());


    System.out.println("2.过滤筛选出年龄大于等于30的员工,取前三");
    List<Employee> employees2 = employees.stream().filter((e) -> {
        return e.getAge() >= 30;
    }).limit(3).collect(Collectors.toList());;

    employees2.stream().forEach(System.out::println);
    System.out.println("总数: " +employees2.size());




    System.out.println("------skip的使用--------");
    System.out.println("skip: 跳过元素");
    List<Employee> employees3 = employees.stream().filter((e) -> {
        return e.getAge() >= 30;
    }).skip(2).collect(Collectors.toList());;

    employees3.stream().forEach(System.out::println);
    System.out.println("总数: " +employees3.size());

  System.out.println("------distinct的使用--------");
  List<Employee> employees4 = employees.stream().distinct().collect(Collectors.toList());
  employees4.stream().forEach(System.out::println);
  System.out.println("总数: " +employees4.size());




}
}

 map与flatMap:

 

 

 

 

 

@Test
    public void test21(){
        
        List<String> strList = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");

       
       //map得到，的是一个新流，流中是流流里面是Character
        Stream<Stream<Character>> stream2 = strList.stream()
                .map(StreamAPITest::filterCharacter);
        
        stream2.forEach((sm) -> {
            sm.forEach(System.out::println);
        });
        
        System.out.println("---------------------------------------------");
        //flatMap:将所有流连接成一个流
        Stream<Character> stream3 = strList.stream()
                .flatMap(StreamAPITest::filterCharacter);
        stream3.forEach(System.out::println);
    }
    
    
    public static Stream<Character> filterCharacter(String str){
        List<Character> list = new ArrayList<>();
        for (Character ch : str.toCharArray()) {
            list.add(ch);
        }
        return list.stream();
    }

 

结果是：效果相同但是，但是遍历逻辑有所不同



排序:
sorted()——自然排序
sorted(Comparator com)——定制排序

 @Test
    public void test22(){
        emps.stream()
                .map(Employee::getName)
                .sorted()
                .distinct()
                .forEach(System.out::println);
        System.out.println("------------------------------------");
        emps.stream()
                .sorted((x, y) -> {
                    if(x.getAge() == y.getAge()){
                        return x.getName().compareTo(y.getName());
                    }else{
                        return Integer.compare(x.getAge(), y.getAge());
                    }
                }).distinct()
                .forEach(System.out::println);
    }
终止操作
查找与匹配:
allMatch–检查是否匹配所有元素
anyMatch–检查是否至少匹配一个元素
noneMatch–检查是否没有匹配所有元素
findFirst–返回第一个元素
findAny–返回当前流中的任意元素

测试：
  @Test
    public void test01() {
        //检查是否所有员工状态都是BUSY
        boolean b1 = emps.stream()
                .allMatch((e) -> e.getStatus().equals(Employee.Status.BUSY));
        System.out.println(b1);
        //检查是否至少有一个员工状态都是BUSY
        boolean b2 = emps.stream()
                .anyMatch((e) -> e.getStatus().equals(Employee.Status.BUSY));
        System.out.println(b2);
        //检查是否没有员工状态都是BUSY
        boolean b3 = emps.stream()
                .noneMatch((e) -> e.getStatus().equals(Employee.Status.BUSY));
        System.out.println(b3);

        System.out.println("---------------------------------------------");

        //从大到小排序，取第一个（相当于Max）
        Optional<Employee> first = emps.stream()
                .sorted((e1, e2) -> -Double.compare(e1.getSalary(), e2.getSalary()))
                .findFirst();
        System.out.println(first.get());

        System.out.println("---------------------------------------------");


        //串行流，一个一个查，顺序不变,一般是拿的第一个
        Optional<Employee> any = emps.stream()
                .filter((e1) -> e1.getStatus().equals(Employee.Status.FREE))
                .findAny();
        System.out.println(any.get());

        System.out.println("---------------------------------------------");

        //并行流，多线程一起查，随机拿符合条件的
        Optional<Employee> any2 = emps.parallelStream()
                .filter((e1) -> e1.getStatus().equals(Employee.Status.FREE))
                .findAny();
        System.out.println(any2.get());
    }
结果是：



这里需要注意的是，最后两个，单线程和多线程的区别，串行查出来的数据一般是按顺序的，并行就不一定了（赵六顺序再张三后面）
查找与匹配:
count–返回流中元素的总个数
max–返回流中最大值
min–返回流中最小值

 @Test
    public void test02() {
       //计数，员工人数
        long count = emps.stream()
                .count();
        System.out.println(count);

        //按工资取出最大值员工
        Optional<Employee> max = emps.stream().max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(max.get());
        
        //用map取出工资，再用min得到最小工资
        Optional<Double> min = emps.stream()
                .map(Employee::getSalary)
                .min(Double::compare);
        System.out.println(min.get());
    }

 

运行结果：



归约:
reduce(T identity, BinaryOperator) / reduce(BinaryOperator)
——可以将流中元素反复结合起来，得到一个值。

@Test
    public void test1() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        //计算和
        //计算结果作为x，再从数组中取出新值作为y,进行下一步计算
        Integer sum = list.stream()
                .reduce(0, (x, y) -> x + y);
        
        System.out.println(sum);

        System.out.println("----------------------------------------");
       
       //计算总工资
        Optional<Double> op = emps.stream()
                .map(Employee::getSalary)
                .reduce(Double::sum);

        System.out.println(op.get());
    }

结果是：



collect——将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法

 @Test
    public void test3() {
        //取名字，封装成list
        List<String> list = emps.stream()
                .map(Employee::getName)
                .collect(Collectors.toList());

        list.forEach(System.out::println);

        System.out.println("----------------------------------");
    
       //取名字，封装成set
        Set<String> set = emps.stream()
                .map(Employee::getName)
                .collect(Collectors.toSet());

        set.forEach(System.out::println);

        System.out.println("----------------------------------");
        
        //取名字，封装成hashset
        HashSet<String> hs = emps.stream()
                .map(Employee::getName)
                .collect(Collectors.toCollection(HashSet::new));

        hs.forEach(System.out::println);
    }
结果是:按照各种集合的规则将流封装成各种集合