Java 基础(Stream APl)

1. Java8 中有两大最为重要的改变。第一个是Lambda表达式;另外一个则是Stream API。
2. Stream API(java.util.stream)把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。
3. Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用 Stream API 对集合数据进行操作，就类似于使用SQL执行的数据库查询。也可以使用 Stream API 来并行执行操作。简言之，Stream API提供了一种高效且易于使用的处理数据的方式。

Stream 是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。
“集合讲的是数据，Stream讲的是计算!”

注意:
stream 自己不会存储元素。
stream 不会改变源对象。相反，他们会返回一个持有结果的新 Stream。
Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

Stream 的操作三个步骤

1. 创建Stream
   一个数据源（如:集合、数组)，获取一个流
2. 中间操作
   一个中间操作链，对数据源的数据进行处理
3. 终止操作(终端操作)
   一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

StreamAPITest.java

package com.klvchen.java3;

/*
1. Stream关注的是对数据的运算，与CPU打交道
   集合关注的是数据的存储，与内存打交道

2.
  Stream 自己不会存储元素。
  Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
  Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行

3.
  Stream 执行流程
  Stream 的实例化
  一系列的中间操作(过滤、映射、...)
  终止操作

4.说明：
  一个中间操作链，对数据源的数据进行处理
  一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

 Java8 中的Arrays的静态方法stream()可以获取数组流:


 */

import com.klvchen.java2.Employee;
import com.klvchen.java2.EmployeeData;
import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class StreamAPITest {

    //创建 Stream 方式一:通过集合
    @Test
    public void test1(){
        List<Employee> empployees = EmployeeData.getEmployees();

        //default Stream<E> stream() :返回一个顺序流
        Stream<Employee> stream = empployees.stream();

        //default Stream<E> parallelStream() :返回一个并行流
        Stream<Employee> parallerlStream = empployees.parallelStream();

    }

    //创建Stream方式二:通过数组
    @Test
    public void test2(){
        int[] arr = new int[]{1, 2, 3, 4, 5, 6};

        //调用Arrays类的static <T> Stream<T> stream(T[] array):返回一个流
        IntStream stream = Arrays.stream(arr);

        Employee e1 = new Employee(1001, "Tom");
        Employee e2 = new Employee(1002, "Jeery");
        Employee[] arr1 = new Employee[]{e1, e2};
        Stream<Employee> stream1 = Arrays.stream(arr1);

    }

    //创建Stream方式三:通过Stream 的of()
    @Test
    public void test3(){

        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);

    }

    //创建Stream方式四:创建无限流
    @Test
    public void test4(){

        //迭代
        // public static<T> Stream<T> iterate(final T seed，final UnaryOperator <T> f)
        // 遍历前10个偶数
        Stream.iterate(0, t -> t+2).limit(10).forEach(System.out::println);

        System.out.println();
        //生成
        //public static<T> Stream<T> generate(Supplier<T> s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);

    }

}

StreamAPITest1.java

package com.klvchen.java3;

import com.klvchen.java2.Employee;
import com.klvchen.java2.EmployeeData;
import org.junit.Test;

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

public class StreamAPITest1 {

    //1-筛选与切片
    @Test
    public void test1(){
        List<Employee> list = EmployeeData.getEmployees();
        //filter(Predicate p) —- 接收 Lambda ,从流中排除某些元素。
        Stream<Employee> stream = list.stream();
        stream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);
        System.out.println();

        //skip(n)一跳过元素;返回一个扔掉了前n个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
        list.stream().skip(3).forEach(System.out::println);

        //distinct()—-筛选，通过流所生成元素的hashCode()和equals()去除重复元素
        list.add(new Employee(1010, "刘强东", 40, 8000));
        list.add(new Employee(1010, "刘强东", 40, 8000));
        list.add(new Employee(1010, "刘强东", 40, 8000));
        list.add(new Employee(1010, "刘强东", 40, 8000));
        list.add(new Employee(1010, "刘强东", 40, 8000));

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

    }

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

        //获取员工姓名长度大于3的员工的姓名。
        List<Employee> employees = EmployeeData.getEmployees();
        Stream<String> namesStream = employees.stream().map(Employee::getName);
        namesStream.filter(name -> name.length() > 3).forEach(System.out::println);

        //
        Stream<Stream<Character>> streamStream = list.stream().map(StreamAPITest1::fromStringToStream);
        streamStream.forEach(s ->{
            s.forEach(System.out::println);
        });

        System.out.println();
        //flatMap(Function f)—接收一个函数作为参数，将流中的每个值都换成另一个流，
        Stream<Character> characterStream = list.stream().flatMap(StreamAPITest1::fromStringToStream);
        characterStream.forEach(System.out::println);

    }

    //将字符串中的多个字符构成的集合转换为对应的Stream的实例
    public static Stream<Character> fromStringToStream(String str){
        ArrayList<Character> list = new ArrayList<>();
        for (Character c : str.toCharArray()) {
            list.add(c);
        }
        return list.stream();
    }

    @Test
    public void test3(){
        ArrayList list1 = new ArrayList();

        list1.add(1);
        list1.add(2);
        list1.add(3);

        ArrayList list2 = new ArrayList();
        list2.add(4);
        list2.add(5);
        list2.add(6);

        //list1.add(list2);
        list1.addAll(list2);
        System.out.println(list1);
    }

    //3-排序
    @Test
    public void test4(){
        //sorted() -- 自然排序
        List<Integer> list = Arrays.asList(12, 43, 65, 34, 87, 0 - 98, 7);
        list.stream().sorted().forEach(System.out::println);

        //异常，原因:Employee 没实现 Comparable 接口
        //List<Employee> employees = EmployeeData.getEmployees();
        //employees.stream().sorted().forEach(System.out::println);

        //sorted(Comparator com)-—定制排序
        List<Employee> employees = EmployeeData.getEmployees();
        employees.stream().sorted( (e1, e2) -> {

            int ageValue = Integer.compare(e1.getAge(), e2.getAge());
            if (ageValue != 0) {
                return ageValue;
            }else {
                return Double.compare(e1.getSalary(), e2.getSalary());
            }
        }).forEach(System.out::println);
    }


}