Java8新特性Lambda、Stream、Optional

Lambda

Lambda 是一个匿名函数，我们可以把Lambda表达式理解为一段可以传递的代码（将代码像数据一样进行传递），可以写出更简洁、更灵活的代码。

Lambda 表达式语法

Lambda 表达式在Java 语言中引入了一个新的语法元素和操作符。这个操作符为 -> ， 该操作符被称为 Lambda 操作符或剪头操作符。它将 Lambda 分为两个部分：
左侧：指定了 Lambda 表达式需要的所有参数
右侧：指定了 Lambda 体，即 Lambda 表达式要执行的功能。

• 语法格式一：无参，无返回值，Lambda 体只需一条语句

Runnable runnable = () -> System.out.println("aa");

• 语法格式二：Lambda 需要一个参数

Consumer<String> consumer = x -> System.out.println(x);

• 语法格式三：Lambda 需要两个参数，并且有返回值

        Comparator<Integer> comparator = (x, y) -> {
            System.out.println("实现函数接口方法！");
            return x + y;
        };

Lambda 表达式语法

上述 Lambda 表达式中的参数类型都是由编译器推断得出的。Lambda 表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，在后台推断出了参数的类型。Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的“类型推断”

方法引用

当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！（实现抽象方法的参数列表，必须与方法引用方法的参数列表保持一致！）方法引用：使用操作符 :: 将方法名和对象或类的名字分隔开来。如下三种主要使用情况：

• 对象::实例方法
• 类::静态方法
• 类::实例方法

Stream流

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

注意：

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

创建Stream流

public static void main(String[] args) {
        // 1.可以通过 Collection 系列集合提供 stream()串行流 或 parallelStream()并行流
        List<String> list = new ArrayList<>();
        Stream<String> stringStream = list.stream();

        // 2.通过 Arrays 中的表态方法 stream() 获取数组流
        Integer[] integers = new Integer[10];
        Stream<Integer> integerStream = Arrays.stream(integers);

        // 3.通过 Stream 类中的静态方法 of()
        Stream<String> strStream = Stream.of("a", "b", "c");

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

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

中间操作

	String[] strings = new String[]{"a", "a", "b", "c", "d", "e", "f"};
	//中间操作：不会执行任何操作
    Stream<String> stringStream = Arrays.stream(strings)
                .filter((e) -> {
                    System.out.println("中间操作");
                    return "c".equals(e);
                });

	//终止操作：一次性执行全部内容，即"惰性求值"
    stringStream.forEach(System.out::println);

	String[] strings = new String[]{"a", "a", "b", "c", "d", "e", "f"};
	//中间操作：不会执行任何操作
    Stream<String> stringStream = Arrays.stream(strings)
                .filter((e) -> {
                    System.out.println("中间操作");
                    return !"c".equals(e);
                }).limit(3).distinct();

	//终止操作：一次性执行全部内容，即"惰性求值"
    stringStream.forEach(System.out::println);

	List<String> list = Arrays.asList("a", "b", "c", "d", "e", "f");
    list.stream().map(String::toUpperCase)
                 .forEach(System.out::println);

	public static void main(String[] args) {

        List<String> list = Arrays.asList("aa", "bb", "cc", "dd", "ee");

        list.stream().map(String::toUpperCase)
                .forEach(System.out::println);

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

		//flatMap里面返回又是一个Stream流
        list.stream().flatMap(Test::character)
                .forEach(System.out::println);
    }

    private static Stream<Character> character(String string) {
        List<Character> list = new ArrayList<>();
        for (char c : string.toCharArray()) {
            list.add(c);
        }
        return list.stream();
    }

	List<Integer> list = Arrays.asList(8, 4, 6, 2, 5, 1, 7);

    list.stream().sorted().forEach(System.out::println);
    System.out.println("-----------");

    list.stream().sorted((e1, e2) -> {
           return -e1.compareTo(e2);
    }).forEach(System.out::println);

终止操作

        List<Integer> list = Arrays.asList(8, 4, 6, 2, 5, 1, 7);
        boolean b = list.stream().allMatch((e) -> {
            return e == 5;
        });
        System.out.println(b);

        boolean b1 = list.stream().anyMatch((e) -> {
            return e == 5;
        });
        System.out.println(b1);

        boolean b2 = list.stream().noneMatch((e) -> {
            return e == 5;
        });
        System.out.println(b2);

        Optional<Integer> first = list.stream().findFirst();
        System.out.println(first.get());

        // 在串行的流中，findAny和findFirst返回的，都是第一个对象；
        // 而在并行的流中，findAny返回的是最快处理完的那个线程的数据
        Optional<Integer> any = list.stream().findAny();
        System.out.println(any.get());

        List<Integer> list = Arrays.asList(8, 4, 6, 2, 5, 1, 7);
        long count = list.stream().count();
        System.out.println(count);

        Optional<Integer> max = list.stream().max(Integer::compareTo);
        System.out.println(max.get());

        Optional<Integer> min = list.stream().min(Integer::compareTo);
        System.out.println(min.get());

        List<Integer> list = Arrays.asList(8, 4, 6, 2, 5, 1, 7);
        Long collect = list.stream().collect(Collectors.counting());
        System.out.println(collect);

        Double collect1 = list.stream().collect(Collectors.averagingInt(Integer::intValue));
        System.out.println(collect1);

        Integer collect2 = list.stream().collect(Collectors.summingInt(Integer::intValue));
        System.out.println(collect2);

Optional 类

Optional 类(java.util.Optional) 是一个容器类，代表一个值存在或不在，
原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。

常用方法：

• Optional.of(T t) : 创建一个 Optional 实例
• Optional.empty() : 创建一个空的 Optional 实例
• Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例
• isPresent() : 判断是否包含值
• orElse(T t) : 如果调用对象包含值，返回该值，否则返回t
• orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值
• map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()
• flatMap(Function mapper):与 map 类似，要求返回值必须是Optional