JAVA8 特性 Stream API学习笔记

Stream API简介

介绍

Java8中有两大最为重要的改变。第一个是 Lambda表达式;另外一个则是 Stream API(java.util.stream.*)。

Stream是 Java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API对集合数据进行操作，就类似于使用SQL执行的数据库查询。也可以使用Stream API来并行执行操作。简而言之，Stream API提供了一种高效且易于使用的处理数据的方式。

什么是Stream API

是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。“集合讲的是数据,流讲的是计算!”
注意:
1.Stream 自己不会存储元素。
2.Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
3.Stream操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

特点

（1）代码简洁：函数式编程写出的代码简洁且意图明确，使用stream接口让你从此告别for循环。

（2）多核友好：Java函数式编程使得编写并行程序从未如此简单，你需要的全部就是调用一下方法。

Stream 流操作步骤

一、创建Stream

//创建Stream
@Test
public void createStream() {
    //1.通过Collection系列集合提供的stream() 或者 parallelStream()
    List<String> list = new ArrayList<>();
    Stream<String> stringStream = list.stream();

    //2.通过Arrays 中的静态方法stream()获取数组流
    Employee[] employees = new Employee[10];
    Stream<Employee> employeeStream = Arrays.stream(employees);

    //3.通过Stream类的静态方法 of()
    Stream<String> stream = Stream.of("w", "Q");

    //4.无限流
    //迭代
    Stream<Integer> stream1 =Stream.iterate(0, (x) -> x + 2);
    stream1.limit(5).forEach(System.out::println);

    Stream.iterate(0, (x) -> x + 2).limit(5).forEach(System.out::println);

    //生成
    Stream.generate(()->Math.random()).limit(5).forEach(System.out::println);
}

二、中间操作

流方法	含义
filter	接收 Lambda ，从流中过滤某些元素
distinct	去重复，筛选，通过流所生成的 hashCode() 与 equals() 取除重复元素
limit	截断流，使其元素不超过给定数量
skip	跳过元素，返回一个舍弃了前n个元素的流；若流中元素不足n个，则返回一个空流；与 limit(n) 互补
map	接收 Lambda ，将元素转换为其他形式或提取信息；接受一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
flatMap	接收一个函数作为参数，将流中每一个值都换成另一个流，然后把所有流重新连接成一个流
sorted	返回排序后的流

1.筛选与切片

List<Employee> employeeList = Arrays.asList(
        new Employee("小灰灰", 12, 0),
        new Employee("懒羊羊", 18, 5000),
        new Employee("喜羊羊", 18, 6000),
        new Employee("沸羊羊", 18, 4500),
        new Employee("美羊羊", 18, 4800)
);

//内部迭代：迭代由Stream API 完成
@Test
public void test1() {
    //中间操作：不会执行任何操作
    Stream<Employee> employeeStream = employeeList.stream()
            .filter((e) -> e.getAge() > 12);

    //终止操作：
    employeeStream.forEach(System.out::println);
    System.out.println("--------------------------");
    
    //filter
    employeeList.stream().filter((e) -> e.getGongzi() > 4500).forEach(System.out::println);
   	System.out.println("--------------------------");
    //limit
    employeeList.stream().limit(3).forEach(System.out::println);
    System.out.println("--------------------------");
    //skip
    employeeList.stream().skip(1).forEach(System.out::println);
    System.out.println("--------------------------"); 
    //distinct   记得重写hashCode() 和equals(Object o)方法
     employeeList.stream().distinct().forEach(System.out::println);
  
}

2.映射

@Test
public void test2() {
    //map：接收 Lambda ，将元素转换为其他形式或提取信息；接受一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
    List<String> list = Arrays.asList("www", "qqq");
    list.stream().map((str) -> str.toUpperCase()).forEach(System.out::println);

    employeeList.stream().map(Employee::getName).forEach(System.out::println);
    //flatMap：接收一个函数作为参数，将流中每一个值都换成另一个流，然后把所有流重新连接成一个流
    System.out.println("----------------------------------------------------------------------------");
    list.stream().flatMap(TestStreamAI2::filterCharacter).forEach(System.out::print);
}

3.排序

@Test
public void test3() {
    // sorted()：自然排序
    List<String> list = Arrays.asList("bbb", "aaa", "www", "qqq");
    list.stream().sorted().forEach(System.out::println);
    System.out.println("-----------------------------------------------------------------------");
    //sorted(Comparator c)：定制排序
    employeeList.stream()
            .sorted((e1, e2) -> { 
                if (e1.getAge().equals(e2.getAge())) {
                    return e1.getName().compareTo(e2.getName());
                } else {
                    return e1.getAge().compareTo(e2.getAge());
                }
            })
            .forEach(System.out::println);
}

三、终止操作

流方法	含义
anyMatch	检查是否至少匹配一个元素，返回boolean。
allMatch	检查是否匹配所有元素，返回boolean。
noneMatch	检查是否没有匹配所有元素，返回boolean。
findAny	将返回当前流中的任意元素。
findFirst	返回第一个元素
forEach	遍历流
collect	收集器，将流转换为其他形式。
reduce	可以将流中元素反复结合起来，得到一个值。
count	返回流中元素总数。
max	返回流中最大值
min	返回流中最小值

1.查找与匹配

@Test
public void test() {
    //allMatch：检查是否匹配所有元素
    boolean b1 = employeeList.stream()
            .allMatch((s) -> s.equals(Status.BUSY));
    System.out.println(b1);

    //anyMatch：检查是否至少匹配一个元素
    boolean b2 = employeeList.stream()
            .anyMatch((s) -> s.equals(Status.BUSY));
    System.out.println(b2);

    //noneMatch：检查是否没有匹配所有元素
    boolean b3 = employeeList.stream()
            .noneMatch((s) -> s.equals(Status.BUSY));
    System.out.println(b3);

    //findFirst：返回第一个元素
    Optional<Employee> op = employeeList.stream().sorted((e1, e2) -> Integer.compare(e1.getAge(), e2.getAge())).findFirst();
    System.out.println(op.get());

    //findAny：返回当前流中的任意元素
    Optional<Employee> op1 = employeeList.stream().filter((e -> e.getStatus().equals(Status.VOCATION))).findAny();
    System.out.println(op1.get());
}

@Test
public void test2() {
    //count：返回流中元素的总个数
    Long count = employeeList.stream().count();
    System.out.println(count);

    //max：返回流中最大值
    Optional<Employee> opmax = employeeList.stream().max((e1, e2) -> Integer.compare(e1.getAge(), e2.getAge()));
    System.out.println(opmax);

    //min：返回流中最小值
    Optional<Employee> opmin = employeeList.stream().min((e1, e2) -> Integer.compare(e1.getAge(), e2.getAge()));
    System.out.println(opmin);
}

2.规约与收集

@Test
public void test3() {
    List<Integer> integerList = Arrays.asList(
            1, 2, 3
    );
    List<String> stringList = Arrays.asList(
            "h", "a", "p", "p", "y"
    );
    //reduce  可以将流中元素反复结合起来，得到一个值。
    Optional<Integer> op = integerList.stream().reduce((x, y) -> (x + y));
    System.out.println(op.get());//输出结果 6

    Optional<String> stringOptional = stringList.stream().reduce((a, b) -> (a + b));
    System.out.println(stringOptional.get());//输出结果 happy

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


    //collect  收集器，将流转换为其他形式。
    stringList.stream().collect(Collectors.toList()).forEach(System.out::print);
    System.out.println();
    stringList.stream().collect(Collectors.toSet()).forEach(System.out::print);
    System.out.println();
    Map<String, String> map = stringList.stream().collect(Collectors.toMap(v ->v.concat("_name"), v1 -> v1, (v1, v2) -> v1));
    System.out.println(map);
}