stream、lamda、optional

---

Lambda

---

Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。
Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。
可以理解lambda表达式为方法接口，具体中只有一个方法

Lambda 好处：
简化我们匿名内部类的调用。
Lambda + 方法引入 代码变得更加精简。
Lambda 表达式（lambda expression）是一个匿名函数，简化我们调用匿名函数的过程。

我们也可以使用@FunctionalInterface修饰为函数接口

@FunctionalInterface
public interface MyFunctionalInterface {
    void add();

    default void get(){

    }

    String toString();
}

---

Lambda语法

//无参数，无返回值。 () -> { }
Runnable runnable = () -> System.out.print("Hello Lambda");

//有一个参数，并且无返回值。 (x) ->{ }
Consumer<String> consumer = (x) -> System.out.print("Hello Lambda");

//有两个以上参数，有返回值， 并且Lambda式中有多条语句。
Comparator<Integer> comparator = (x, y) -> {
    System.out.print("Hello Lambda");
    return Integer.compare(x,y);
};

Stream流

---

​ Java8中的Stream是对容器对象功能的增强，它专注于对容器对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作 (bulk data operation)。Stream API借助于同样新出现的Lambda表达式，极大的提高编程效率和程序可读性。同时，它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使用fork/join并行方式来拆分任务和加速处理过程。通常，编写并行代码很难而且容易出错, 但使用Stream API无需编写一行多线程的代码，就可以很方便地写出高性能的并发程序。所以说，Java8中首次出现的 java.util.stream是一个函数式语言+多核时代综合影响的产物。

---

parallelStream为并行流采用多线程执行
Stream采用单线程执行
parallelStream效率比Stream要高。
注意：数据量比较少的情况下，不要使用并行流。

Optional

---

Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。
Optional 类的引入很好的解决空指针异常。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。

判断参数是否为空

ofNullable(可以传递一个空对象)
of(不可以传递空对象，传null会报NullPointerException)
Integer a = 1;
Optional<Integer> result = Optional.ofNullable(a);
System.out.println(result.isPresent());

isPresent true 不为空
isPresent返回 false 为空。

参数为空可以设定默认值

Integer a = 1;
Optional<Integer> result = Optional.ofNullable(a);
System.out.println(result.get());
System.out.println(result.isPresent());
a = null;
Integer rs = Optional.ofNullable(a).orElse(2);
System.out.println(rs);

参数实现过滤

Integer val = 16;
Optional<Integer> result = Optional.ofNullable(val);
boolean isPresent = result.filter(a2 -> a2 > 17).isPresent();
System.out.println(isPresent);

---

与Lambda表达式结合使用，优化代码

---

优化方案1

Optional<String> name2 = Optional.ofNullable(name);
//name2.ifPresent(s -> System.out.println(s));
name2.ifPresent(System.out::print);

优化方案2

public class Test26 {
    private static User user = null;

    public static void main(String[] args) {
        User user = Test26.getUser();
        System.out.println(user);

    }

    public static User getUser() {

    
//        return Optional.ofNullable(user).orElseGet(new Supplier<User>() {
//            @Override
//            public User get() {
//                return createUser();
//            }
//        });

        return Optional.ofNullable(user).orElseGet(() -> createUser());
    }


    private static User createUser() {
        return new User("java", 25);
    }
}

优化方案3
map中获取的返回值自动被Optional包装,即返回值 -> Optional<返回值>

flatMap中返回值保持不变,但必须是Optional类型,即Optional<返回值> -> Optional<返回值>

public class Test27 {
    public static void main(String[] args) {
        String name = Test27.getName();
        System.out.println(name);
    }

    public static String getName() {
        User user = new User("Java521", 66);

        return Optional.ofNullable(user).map(user1 -> {
            return user1.getName();
        }).map(name -> {
            return name.toLowerCase();
        }).orElse(null);
    }
}