Stream

package com.my.stream;

import org.junit.jupiter.api.Test;

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

/**
 * @author: creat
 * @date: 2021/6/18 0:28
 * @description:
 */
public class TestStream {
    @Test
    //stream创建
    public void test1(){
        List list=new ArrayList<>();
        Stream stream = list.stream();

        String[][] strings=new String[10][2];
        Stream<String[]> stream1 = Arrays.stream(strings);

        Stream<String> aa = Stream.of("aa", "dd", "ee");
        //无限流
        Stream.iterate(2,x->x+2).limit(100).forEach(System.out::println);
        Stream.generate(()->Math.random()).limit(50).forEach(System.out::println);
    }
    //中间操作
    /**
     * 筛选与切片
     * filter 接收lambda，从流中排除某些参数
     * limit 截断流 使元素不超过 指定数量
     * skip 跳过元素
     * distinct 筛选，通过流所生成元素的hashCode()和equals() 去除重复
     */
    @Test
    public void test2(){
        users.stream().filter(user -> {
            System.out.println("判断"+user.getAge()+"是否符合");
            return user.getAge()>18;
        }).skip(2).limit(2).forEach(System.out::println);
        System.out.println("---------------");
        users.stream().filter(user -> {
            System.out.println("判断"+user.getName()+"是否符合");
            return user.getAge()>18;
        }).limit(5).skip(2).forEach(System.out::println);
        System.out.println("================");
        users.stream().filter(user -> user.getAge()>18).distinct().forEach(System.out::println);
    }
    //中间操作
    /**
     * 映射
     * map 接收lambda，将元素转换成其他形式或者提取信息，接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
     * flatMap 接收一个函数作为参数，将流中的每个值都换成另外一个流，然后把所有流连接成一个流
     */
    @Test
    public void test3(){
        List<String> strings=Arrays.asList("aa","ss","dd","ff","cc","xx","zz","hh");
        strings.stream().map(str->str.toUpperCase()).limit(2).forEach(System.out::println);
        System.out.println("-----------------");
        users.stream().map(User::getName).forEach(System.out::println);
        System.out.println("-----------------");
        Stream<Stream<Character>> streamStream = strings.stream().map(TestStream::filterCharacter);
        streamStream.forEach(sm->{
            sm.forEach(System.out::println);
        });
        System.out.println("-----------------");
        strings.stream().flatMap(TestStream::filterCharacter).forEach(System.out::println);
    }
    @Test
    /**
     * 排序
     * sorted() 自然排序
     * sorted(Comparator com) 定制排序
     */
    public void test4(){
        List<String> strings=Arrays.asList("aa","ss","dd","ff","cc","xx","zz","hh");
        strings.stream().sorted().forEach(System.out::println);
        System.out.println("-----------------");
        users.stream().sorted((u1,u2)-> {
            if (u1.getAge().equals(u2.getAge())){
                return u1.getName().compareTo(u2.getName());
            }else {
                return u1.getAge().compareTo(u2.getAge());
            }
        }).forEach(System.out::println);
    }
    @Test
    /**
     * 规约
     * reduce(T identity,BinaryOperator)/reduce(BinaryOperator) 可以将流中元素反复结合起来，得到一个值
     */
    public void test5(){
        List<Integer> list=Arrays.asList(1,3,5,2,8,9,11,20);
        Integer reduce = list.stream().reduce(0, (x, y) -> x + y);
        System.out.println(reduce);
        Optional<Integer> reduce1 = users.stream().map(User::getAge).reduce(Integer::sum);
        System.out.println(reduce1.get());
    }
    public static Stream<Character> filterCharacter(String str){
        List<Character> list=new ArrayList<>();
        for (Character character:str.toCharArray()){
            list.add(character);
        }
        return list.stream();
    }
    List<User> users=Arrays.asList(
            new User(18,"张三"),
            new User(19,"李四"),
            new User(20,"王五"),
            new User(18,"张四"),
            new User(19,"王五")
    );
}
class User {
    private Integer age;
    private String name;

    public User(Integer age, String name) {
        this.age = age;
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return age.equals(user.age) && name.equals(user.name);
    }

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

    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}