Java8新特性:Stream流

package com.wuya.lianxi.stream;

import com.wuya.lianxi.Student;
import org.junit.Test;

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


public class TestStreamApi1 {
    //第一步：创建Stream---四种方法
    @Test
    public void test01(){
        //1.可以通过Collection系列提供的stream()或parallelStream()
        List list = new ArrayList<>();
        Stream stream1 = list.stream();

        //2.通过Arrays中的静态方法stream()获取数组流
        Student[] stu = new Student[8];
        Stream stream2 = Arrays.stream(stu);

        //3.通过Stream类中的静态方法of()
        Stream stream = Stream.of(stu);//static Stream of(T t)
        Stream stream3 = Stream.of("小胡", "小王", "花花");//static Stream of(T... values)

        //4.创建无限流
        //TODO 迭代的方式创建无限流
        //static Stream iterate(final T seed, final UnaryOperator f)
        //其中，UnaryOperator是函数式接口,继承自Function
        Stream stream4 = Stream.iterate(0, x -> x + 2);
        //TODO 生成的方式创建无限流
        Stream.generate(() -> Math.random())
                .limit(5) //选5条数据，若没有这一行就看到了无限流的效果
                .forEach(consumer -> System.out.println(consumer));

    }
}

package com.wuya.lianxi.stream;

import com.wuya.lianxi.entity.Employee;
import org.junit.Test;

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


public class TestStreamApi2 {
    List empList = Arrays.asList(
            new Employee("张三", 38, 8939.0),
            new Employee("李四", 23, 3768.88),
            new Employee("王五", 30, 3782.9),
            new Employee("赵六", 48, 6282.36),
            new Employee("刘琦", 28, 10238.6),
            new Employee("刘琦", 28, 10238.6)
    );
    

    @Test
    public void test04(){
        empList.stream()
                .filter(e -> e.getSalary()>5000)
                .skip(1)
                .distinct() //需要在Employee类中重写 hashCode()和equals()才能去重
                .forEach(System.out::println);
    }

    @Test
    public void test03(){
        empList.stream()
                .filter(e -> {
                    System.out.println("短路!"); //类似 && ||
                    return e.getSalary()>5000;
                })
                .limit(2)
                .forEach(System.out::println);//输出4个"短路!"
    }

    //内部迭代：迭代由Stream API 来完成
    @Test
    public void test01(){
        //TODO 中间操作
        Stream stream = empList.stream()
                .filter(employee -> {
                    System.out.println("这是Stream API 的中间操作");
                    return employee.getAge() > 35;
                });
        //如果没有下面这一行，进行单元测试时，没有任何结果输出
        //有了下面这行后，进行单元测试时，中间操作一次性处理！！
        //TODO 终止操作
//        stream.forEach(con -> System.out.println(con));
        stream.forEach(System.out::println);//效果与上一行相同
    }
    //外部迭代:
    @Test
    public void test02(){
        Iterator it = empList.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

package com.wuya.lianxi.stream;

import com.wuya.lianxi.entity.Employee;
import org.junit.Test;

import java.sql.SQLOutput;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;


public class TestStreamApi3 {
    List empList = Arrays.asList(
            new Employee("张三", 38, 8939.0),
            new Employee("李四", 23, 3768.88),
            new Employee("王五", 30, 3782.9),
            new Employee("赵六", 48, 6282.36),
            new Employee("刘琦", 28, 10238.6),
            new Employee("刘琦", 28, 10238.6)
    );
    
    @Test
    public void test05(){
        List list = Arrays.asList("aaa", "bBb", "CCc", "ddd");
        list.stream()
                .map(str -> str.toUpperCase())
                .forEach(System.out::println);
        System.out.println("--------------------------------------");
        empList.stream()
                .map(Employee::getName)
                .forEach(System.out::println);
        System.out.println("--------------------------------------");
      
        System.out.println("--------------------------------------");
        //结果同上面注释调的
        Stream stream1 = list.stream()
                .flatMap(TestStreamApi3::filterCharacter);
        stream1.forEach(System.out::println);
    }

    public static Stream filterCharacter(String str){
        List list = new ArrayList<>();
        for (Character ch : str.toCharArray()) {
            list.add(ch);
        }
        return list.stream();
    }
}

package com.wuya.lianxi.stream;

import com.wuya.lianxi.entity.Employee;
import org.junit.Test;

import java.util.Arrays;
import java.util.List;


public class TestStreamApi4 {
    List empList = Arrays.asList(
            new Employee("张三", 38, 8939.0),
            new Employee("李四", 23, 3768.88),
            new Employee("王五", 30, 3782.9),
            new Employee("赵六", 48, 6282.36),
            new Employee("刘琦", 28, 10238.6),
            new Employee("刘琦", 28, 10238.6)
    );
    
    //TODO 延伸:字符串可以自然排序,因为 String实现了Comparable
    @Test
    public void test06(){
        List list = Arrays.asList("aaa", "bBb", "CCc", "dDd");
        list.stream()
                .sorted()  //自然排序
                .forEach(System.out::println);
        System.out.println("--------------------------------------");

        empList.stream()
                .sorted((e1,e2) -> {
                    if(e1.getAge().equals(e2.getAge())){
                        return e1.getName().compareTo(e2.getName());
                    } else {
//                        return e1.getAge().compareTo(e2.getAge());//升序
                        return -e1.getAge().compareTo(e2.getAge());//这个打印输出的按年龄降序排
                    }
                }).forEach(System.out::println);
    }
}

package com.wuya.lianxi.entity;

import java.util.Objects;
//增加了Status的枚举值
public class Employee {
    private String name;
    private Integer age;
    private Double salary;
    private Status Status;

    public Employee() {
    }

    public Employee(String name, Integer age, Double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public Employee(String name, Integer age, Double salary, Employee.Status status) {
        this.name = name;
        this.age = age;
        this.salary = salary;
        Status = status;
    }

    public Employee.Status getStatus() {
        return Status;
    }

    public void setStatus(Employee.Status status) {
        Status = status;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Double getSalary() {
        return salary;
    }

    public void setSalary(Double salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + ''' +
                ", age=" + age +
                ", salary=" + salary +
                ", Status=" + Status +
                '}';
    }

    public enum Status{
        BUSY,
        FREE,
        VOCATION;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return Objects.equals(name, employee.name) &&
                Objects.equals(age, employee.age) &&
                Objects.equals(salary, employee.salary);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age, salary);
    }
}

package com.wuya.lianxi.stream;

import com.wuya.lianxi.entity.Employee;
import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;


public class TestStreamApi5 {
    List empList = Arrays.asList(
            new Employee("张三", 38, 8939.0, Employee.Status.BUSY),
            new Employee("李四", 23, 3768.88, Employee.Status.FREE),
            new Employee("王五", 30, 3782.9, Employee.Status.VOCATION),
            new Employee("赵六", 48, 6282.36, Employee.Status.BUSY),
            new Employee("刘琦", 28, 10238.6, Employee.Status.FREE)
    );
    
    @Test
    public void test01(){
        boolean b = empList.stream()
                .allMatch(e -> e.getStatus().equals(Employee.Status.BUSY));
        System.out.println(b);//false
        boolean b1 = empList.stream()
                .anyMatch(employee -> employee.getAge() > 40);
        System.out.println(b1);//true
        boolean b3 = empList.stream()
                .noneMatch(e -> e.getStatus().equals(Employee.Status.BUSY));
        System.out.println(b3);//false

        Optional optional = empList.stream()
                .sorted((e1, e2) -> -Double.compare(e1.getSalary(), e2.getSalary()))
                .findFirst();
        System.out.println(optional.get());

        Optional anyEmp = empList.parallelStream() //并行
                .filter(e -> e.getStatus().equals(Employee.Status.FREE))
                .findAny();
        System.out.println(anyEmp);
    }
    @Test
    public void test02(){
        long count = empList.stream()
                .count();
        System.out.println(count);

        Optional max = empList.stream()
                .max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(max);

        Optional min = empList.parallelStream()
                .filter(e -> e.getAge() > 30)
                .min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(min);

        //TODO 获取最高的工资是多少
        Optional max1 = empList.stream()
                .map(Employee::getSalary)
                .max(Double::compareTo);
        System.out.println(max1.get());
    }
}