Lambda表达式详解，Optional类的使用

本文主要是介绍Lambda表达式详解，Optional类的使用，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

前言

大家对lambda表达式都不陌生，也都使用过lambda表达式，但是这篇文章并不是交你简单的使用，而是更深入的区理解lambda表达式。此外还会了解Optional类的使用对空指针异常的避免

---

序言

lambda表达式及其相关特是 JDK8 中增加的特性，显著增强了Java，原因有两点：首先 ，添加了新的语法元素，是Java语言的表达能力得以提升，并简化了一些常用结构的实现方式。 其次 ，lambda表达式的加入也导致 API 库中添加了一些新的功能，使程序员能更容易地 利用多核环境的并行处理功能 (尤其是在处理 for-each 风格的操作时)，并且能使用支持对数据执行管道操作的新的流API 。 lambda表达式的引入也催生了其他新的Java功能，包括 默认方法 和 方法引用。

Lambda 表达式

简介(重要)

理解lambda表达式有两个结构非常重要：lambda表达式自身 ， 函数式接口。

• lambda表达式自身：本质上是一个匿名方法(更确切的说应该是函数式接口的实现类)。这个匿名方法不是独立执行的。而是用于实现函数式接口定义的另一个方法(很像方法重写)。因此，lambda表达式会导致一个匿名内类的生成(所以我会说 lambda应该是函数式接口的实现类)。lambda表达式也常被称为闭包(closure)

关于闭包的解释有很多，大概意思就是：隐式的使用了另一个地方的资源，导致其不能被垃圾回收，占用空间资源。

• 函数式接口：仅包含一个抽象方法的接口。大家对函数式接口都不陌生，但是 JDK8 以后的接口 和以前的接口 以有所不同。前言中我提到了 默认方法 ，默认方法是在接口中定义的方法，使用 default 修饰且可以包含方法体(这与原始接口的方法定义有很大的区别)，其实现类可重写可不重写，可直接调用。
  以 Consumer接口为例：

  @FunctionalInterface
  public interface Consumer<T> {void accept(T t);default Consumer<T> andThen(Consumer<? super T> after) {Objects.requireNonNull(after);return (T t) -> { accept(t); after.accept(t); };}
  }
  

  可以看出在 Consumer接口中 包含一个 默认方法和一个抽象方法，但仍被称为函数式接口
  所以，一个接口中无论包含多少个方法，只要 只有一个 抽象方法，该接口就可被称为函数式接口

基础知识

->：lambda操作符 或 箭头操作符
左侧：指定了lambda表达式的所有参数(没有则为空)
右侧：指定了lambda体，即lambda表达式所要执行的动作

Java定义了两种lambda体：一种包含单个表达式，另一种包含一个代码块

单个表达式：( ) -> xxx 如，() -> 123.4 单个表达式即为返回值
代码块：( ) -> { }

详解

例一：

上述我说 lambda是函数式接口实现类，为什么这样说呢？看下面的例子

interface MyInterface {void get();
}@Test
public void Text() {//父类引用指向子类对象MyInterface my = () -> {System.out.println("你好Lambda");};my.get();  //输出：你好Lambda
}//MyInterface my = () -> {System.out.println("你好Lambda");};
//这种方式的书写是不是很熟悉，等价如下：
@Test
public void Text() {MyInterface my = new MyInterface {  //父类引用指向子类对象@Overridevoid get(){System.out.println("你好Lambda");}}my.get();  //输出：你好Lambda
}

所以：lambda表达式就是函数式接口的实现类，其书写形式( () -> {} )就是在重写接口中的方法
而且前面也说过，lambda表达式会导致一个匿名类的生成，该匿名类就是接口实现类。这个结论很重要，在接下来的讨论中我会多次用到这个结论

例二：

用上述结论与大家讨论一下我们用的最多的 for-each 循环。
forEach 是 Iterable接口中的一个默认方法，Iterable接口包含三个方法，但是一个函数式接口，只包含一个 Iterator() 抽象方法。forEach方法描述如下

default void	forEach(Consumer<? super T> action)

大家可能都写过这样的forEach

    @Testpublic void demo1(){ArrayList<Object> objects = new ArrayList<>();objects.add("a");objects.add("b");objects.add("c");objects.add("d");objects.forEach(item -> {System.out.println(item); //打印集合中的元素});}

那么，forEach内部是如何进行的，换句话说，为什么一条lambda表达式就可以进行打印操作。我们自己就可进行一个简单的实现：

public class ForEachDemo<E> implements Iterable<E>{private int size = 0;  //数组中元素的个数E[] array;public ArrayStack() {array = (E[]) new Object[10];  }//我们自己进行forEach的简单实现@Overridepublic void forEach(Consumer<? super E> action) {for (int i = 0; i < size; i++) {action.accept(array[i]); //调用抽象方法，将数组元素传入}}//添加元素，最多为10public boolean add(E value) {if (isFull()) {return false;}array[size++] = value;return true;}public boolean isFull() {return size == array.length;}//Iterable 为函数式接口，必须实现该方法，这里不是重点@Overridepublic Iterator<E> iterator() {return new Iterator<E>() {@Overridepublic boolean hasNext() {return false;}@Overridepublic E next() {return null;}};}
}

测试一下：

@RunWith(JUnit4.class)
public class Test1 {@Testpublic void demo2(){ForEachDemo<String> array = new ForEachDemo<>();array.add("a");array.add("b");array.add("c");array.add("d");array.forEach(item -> {System.out.println(item);});}
}

解释代码：
在重写forEach里面简单的用了一个for循环，并调用了Comsumer接口的accept()方法，在测试类中实现了简单的遍历，前面说过lambda是函数式接口的实现类，测试类中的lambda表达式就是在重写Consumer接口中的accept()方法(accept() 包含一个参数无返回值)，在执行时调用了这个方法，而这个方法就是打印数组元素。看下面对比，更加清晰。

/自定义
public void forEach(Consumer<? super E> action) {for (int i = 0; i < size; i++) {action.accept(array[i]); //调用抽象方法，将数组元素传入}
}
//方法调用
array.forEach(item -> {System.out.println(item);
}); 
//匿名内部类实现
array.forEach(new Consumer<String>() {@Overridepublic void accept(String item) {System.out.println(item);}
});

可以看出，lambda表达式就是 new了一个Consumer接口的实现类，只不过这个过程是隐式的，并重写了accept()方法

我们的结论正不正确，来看一下 ArrayList类中的forEach源码：

@Override
public void forEach(Consumer<? super E> action) {Objects.requireNonNull(action);  		 //判空//modCount相当于一个计数器，再增加或删除操作中会加一或减一。//在AbstractList抽象类中定义final int expectedModCount = modCount;final Object[] es = elementData;  //elementDate保存元素的数组final int size = this.size;		  //元素个数//这里就是为什么在forEach中不能做增加或删除操作/**lambda重写accept()方法，在其中执行增加或删除操作会使modCount != expectedModCount  */for (int i = 0; modCount == expectedModCount && i < size; i++)//重点：同样调用了Consumer接口的accept()方法//执行lambda表达式action.accept(elementAt(es, i));   if (modCount != expectedModCount)throw new ConcurrentModificationException();
}

可以发现，我们定义的forEach与源码是很相似的，同样使用了普通for，并调用了accept()方法。
至此：我们论证了我们的结论。
注意：虽然lambda是函数式接口的实现类，但lambda并没有自己的this参数，这与匿名内部类不同。在lambda中调用this实则使调用其外层类的this参数。

接下来带大家看一下lambda一些有趣的地方。

lambda的变量捕获

lambda：可以调用表达式外部类的实例 或 静态变量以及 final的局部变量。
而调用 final的局部变量 时会形成变量捕获 ------ 就是，如果lambda内部要想访问外部类中的局部变量，那该变量必须是 final 的，不能修改。

访问静态变量：

public class Test{static int a = 10;public static void main(String[] args) {ArrayList<String> array = new ArrayList<>();array.add("a");array.add("b");array.add("c");array.add("d");array.forEach(item -> {a = 100;System.out.print(item);System.out.println(a);});}
}//a100//b100//c100//d100

访问 final的局部变量

public class Test{public static void main(String[] args) {ArrayList<String> array = new ArrayList<>();array.add("a");array.add("b");array.add("c");array.add("d");int a = 10;array.forEach(item -> {int b = a + 90;System.out.print(item);System.out.println(b);});}
}//a100//b100//c100//d100

a实质上是final变量，素以可以在，lambda内部使用，但如在内部修改了a的值，不管是lambda内部还是外部，a都会丢失实质上的final状态，会报错，无法通过编译 ---- 即lambda内部不能修改局部变量。
但是真的不能修改吗？ 是可以的，只不过性质发生了改变，该值不再是 final变量，而是variable易变的，只需要使用 java.util.concurrent 并发工具包中的 atomic 子包中的类即可。如下：

public class Test {public static void main(String[] args) {ArrayList<String> array = new ArrayList<>();array.add("a");array.add("b");array.add("c");array.add("d");AtomicInteger a = new AtomicInteger(10);array.forEach(item -> {a.set(100);System.out.print(item);System.out.println(a);});}
}//a100//b100//c100//d100

总：lambda可以访问外部变量(很水的总结)

后面的其实我不想说了，该聊的其实都聊的差不多了，后面的就是lambda的另一种写法，你肯定写过，如: System.out::ptintln(item);,预定义接口呢？你也见过，Consumer我们已将聊过了。
map()都用过吧，该方法需要的函数式接口参数就是：Function<T,R>;后面的有时间再写吧。

方法引用

静态方法引用

实例方法引用

泛型中的方法引用

构造函数引用

预定义函数接口

Optional类的使用

这篇关于Lambda表达式详解，Optional类的使用的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---