java8_Stream流

流（Stream）到底是什么？
是数据渠道，用于操作数据源（集合、数组等）所产生的元素序列
集合讲的是数据，流讲的是运算

java内置四大核心函数式接口

class User {
    private int id;
    private String name;
    private int age;

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

/**
 * 请按照给出的数据，找出同时满足以下条件的用于，
 * 也即以下条件全部满足偶数ID、且年龄大于24、且用户名转为大写、且用户名字母倒排序、只输出一个用户名字
 */
public class StreamDemo {
    public static void main(String[] args) {
        User user1 = new User(11, "a", 23);
        User user2 = new User(12, "b", 29);
        User user3 = new User(13, "c", 22);
        User user4 = new User(14, "d", 28);
        User user5 = new User(16, "e", 26);

        List<User> list = Arrays.asList(user1, user2, user3, user4, user5);

        list.stream().filter(u -> {
            return u.getId() % 2 == 0;
        }).filter(user -> {
            return user.getAge() > 24;
        }).map((T) -> {
            return T.getName().toUpperCase();
        }).sorted((o1, o2) -> {
            return o2.compareTo(o1);
        }).limit(1).forEach(System.out::println);

    }
}

如下这种接口里面只有一个方法的声明，可以使用lambda表达式，这种接口称为函数式接口（可以加注解@FunctionalInterface，手动不加程序也会在后台自动加）。

1、原来的写法

interface Foo {
    public void sayHello();
}

public class LambdaExpressDemo {
    public static void main(String[] args) {
        Foo foo = new Foo()
        {
            @Override
            public void sayHello() {
                System.out.println("第一种方法");
            }
        };
        foo.sayHello();
    }
}

2、使用了Lambda之后的写法

public class LambdaExpressDemo {
    public static void main(String[] args) {
        Foo foo = ()->{ System.out.println("第二种写法"); };
        foo.sayHello();
    }
}

口诀：拷贝小括号，写死右箭头，落地大括号，skr

image.png

如上，先将小括号拷贝一个，然后右箭头是一定有的，最后将本来大括号里面的业务逻辑方法复制过去

3、带传入参数的方法

interface Foo {
    public int sum(int a, int b);
}

public class LambdaExpressDemo {
    public static void main(String[] args) {

        Foo foo = (int a, int b) -> {
            System.out.println("到这了");
            return a + b;
        };
        System.out.println(foo.sum(1, 2));
    }
}

4、java8以后接口中可以写方法的实现

如下所示，java8以后接口中可以写方法的实现，要加default来修饰，也可以写静态方法的实现。如下所示：

interface Foo {
    int sum(int a, int b);

    default int div(int a, int b) {
        return a / b;
    }

    default int reduce(int a, int b) {
        return a - b;
    }

    static int mv(int a, int b) {
        return a * b;
    }
}

public class LambdaExpressDemo {
    public static void main(String[] args) {

        Foo foo = (int a, int b) -> {
            System.out.println("come in here");
            return a + b;
        };
        System.out.println(foo.sum(1, 2));
        System.out.println(foo.div(10, 2));
        System.out.println(foo.reduce(10, 2));
        System.out.println(Foo.mv(1, 10));
    }
}

public class StreamMethod {
    public static void main(String[] args) {

        //=======================中间操作符============================
        //filter()通过设置的条件过滤出元素
        List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
        List<String> filtered = strings.stream()
                .filter(u -> !u.isEmpty()).collect(Collectors.toList());
        System.out.println(filtered);

        System.out.println("==========forEach+distinct==========");
        //distinct()将返回元素去重
        List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
        numbers.stream().filter(i -> i % 2 == 0).distinct().forEach(System.out::println);
        System.out.println("limit");

        System.out.println("==========limit==========");
        //limit()返回前几个元素
        List<String> stringss = Arrays.asList("abc", "abc", "bc", "efg", "abcd", "jkl", "jkl");
        stringss.stream().limit(3).forEach(System.out::println);

        System.out.println("==========skip==========");
        //skip跳过前几个元素
        List<String> skipString = Arrays.asList("abc", "abc", "bc", "efg", "abcd", "jkl", "jkl");
        skipString.stream().skip(3).forEach(System.out::println);

        System.out.println("==========map==========");
        //map接受一个函数作为参数。这个函数会被应用到每个元素上，并将其映射成一个新的元素
        List<String> mapString = Arrays.asList("abc", "abc", "bc", "efg", "abcd", "jkl", "jkl");
        mapString.stream().map(str -> str + "-itcast").forEach(System.out::println);

        System.out.println("==========sorted==========");
        //sorted
        List<String> stringSort = Arrays.asList("abc", "abd", "aba", "efg", "abcd", "jkl", "jkl");
        List<String> sorted = stringSort.stream().sorted().collect(Collectors.toList());
        System.out.println(sorted);

        System.out.println("===========anyMatch=========");
        //终止操作符,检查是否至少匹配一个元素，返回boolean
        List<String> stringAnyM = Arrays.asList("abc", "abd", "aba", "efg", "abcd", "jkl", "jkl");
        boolean bAny = stringAnyM.stream().anyMatch(s -> s == "abc");


        System.out.println("===========allMatch=========");
        //检查是否匹配所有元素，返回boolean
        List<String> stringAllM = Arrays.asList("abc", "abd", "aba", "efg", "abcd", "jkl", "jkl");
        boolean bAll = stringAllM.stream().allMatch(s -> s == "abc");


        System.out.println("===========noneMatch=========");
        //检查是否匹配所有元素，返回boolean
        List<String> stringNoM = Arrays.asList("abc", "abd", "aba", "efg", "abcd", "jkl", "jkl");
        boolean bNoM = stringNoM.stream().noneMatch(s -> s == "abc");


        System.out.println("===========findAny=========");
        //将返回当前流中的任意元素。
        List<String> stringAny = Arrays.asList("cv", "abd", "aba", "efg", "abcd", "jkl", "jkl");
        Optional<String> any = stringAny.stream().findAny();

        System.out.println("===========findFirst=========");
        //findFirst(),返回第一个元素
        List<String> stringsFirst = Arrays.asList("aa", "bb", "cc", "df", "dd");
        Optional<String> first = stringsFirst.stream().findFirst();
        System.out.println(first.get());
        //直接获取数组下标为0的元素不就行了吗
        System.out.println(stringsFirst.get(0));

        System.out.println("===========forEach=========");
        //forEach(),遍历流
        List<String> stringForEach = Arrays.asList("cv", "abd", "aba", "efg", "abcd", "jkl", "jkl");
        stringForEach.stream().forEach(System.out::println);

        System.out.println("===========collect=========");
        //collect(),收集器，将流转换为其他形式。
        List<String> stringCollect = Arrays.asList("cv", "abd", "aba", "efg", "abcd", "jkl", "jkl");
        Set<String> set = stringCollect.stream().collect(Collectors.toSet());
        List<String> list = stringCollect.stream().collect(Collectors.toList());
        Map<String, String> map = stringCollect.stream().
                collect(Collectors.toMap(v -> v.concat("_name"), v1 -> v1, (v1, v2) -> v1));


        System.out.println("===========reduce=========");
        //reduce(),可以将流中元素反复结合起来，得到一个值。
        List<String> stringReduce = Arrays.asList("cv", "abd", "aba", "efg", "abcd", "jkl", "jkl");
        Optional<String> reduce = stringReduce.stream().reduce((old, item) -> {
            return old + item;
        });
        if (reduce.isPresent()) System.out.println(reduce.get());


        System.out.println("===========count=========");
        //count(),返回流中元素总数。
        List<String> stringCount = Arrays.asList("cv", "abd", "aba", "efg", "abcd", "jkl", "jkl");
        long count = stringCount.stream().count();
        System.out.println(count);

    }

}