Java8的新特性以及使用

1.  通过10个示例来初步认识Java8中的lambda表达式 

我个人对Java 8发布非常激动，尤其是lambda表达式和流API。越来越多的了解它们，我能写出更干净的代码。虽然一开始并不是这样。第一次看到用lambda表达式写出来的Java代码时，我对这种神秘的语法感到非常失望，认为它们把Java搞得不可读，但我错了。花了一天时间做了一些lambda表达式和流API示例的练习后，我开心的看到了更清晰的Java代码。这有点像学习泛型，第一次见的时候我很讨厌它。我甚至继续使用老版Java 1.4来处理集合，直到有一天，朋友跟我介绍了使用泛型的好处（才意识到它的好处）。所以基本立场就是，不要畏惧 lambda 表达式以及方法引用的神秘语法，做几次练习，从集合类中提取、过滤数据之后，你就会喜欢上它。下面让我们开启学习Java 8 lambda表达式的学习之旅吧~ 
本小节中先不说lambda表达的含义和繁琐的概念。我们先从最简单的示例来介绍java8中的lambda表达式 

例1、用lambda表达式实现Runnable 

// Java 8之前： 

new Thread(new Runnable() { 

 @Override 

 public void run() { 

System.out.println("Before Java8, too much code for too little to do"); 

 } 

}).start();

//Java 8方式： 

new Thread( () -> System.out.println("In Java8, Lambda expression rocks !!") ).start();

输出： 

too much code, for too little to do 

Lambda expression rocks !! 

这个例子向我们展示了Java 8 lambda表达式的语法。你可以使用lambda写出如下代码： 

(params) -> expression

(params) -> statement

(params) -> { statements } 

例如，如果你的方法不对参数进行修改、重写，只是在控制台打印点东西的话，那么可以这样写： 

() -> System.out.println("Hello Lambda Expressions"); 

如果你的方法接收两个参数，那么可以写成如下这样： 

(int even, int odd) -> even + odd 

顺便提一句，通常都会把lambda表达式内部变量的名字起得短一些。这样能使代码更简短，放在同一行。所以，

在上述代码中，变量名选用a、b或者x、y会比even、odd要好。 

例2、使用Java 8 lambda表达式进行事件处理 

如果你用过Swing API编程，你就会记得怎样写事件监听代码。这又是一个旧版本简单匿名类的经典用例，但现在可以不这样了。你可以用lambda表达式写出更好的事件监听代码，如下所示： 

// Java 8之前： 

JButton show =  new JButton("Show");

show.addActionListener(new ActionListener() { 

 @Override 

 public void actionPerformed(ActionEvent e) { 

 System.out.println("Event handling without lambda expression is boring"); 

 } 

});

// Java 8方式： 

show.addActionListener((e) -> {

 System.out.println("Light, Camera, Action !! Lambda expressions Rocks"); 

});

Java 开发者经常使用匿名类的另一个地方是为  Collections.sort() 定制  Comparator。在 Java  8 中，你可以用更可读的 lambda表达式换掉丑陋的匿名类。我把这个留做练习，应该不难，可以按照我在使用 lambda 表达式实现 Runnable 和  ActionListener 的过程中的套路来做。 

例3、使用Java 8 lambda表达式进行事件处理   使用lambda表达式对列表进行迭代 

如果你使过几年 Java，你就知道针对集合类，最常见的操作就是进行迭代，并将业务逻辑应用于各个元素，例如处理订单、交易和事件的列表。由于Java是命令式语言，Java 8之前的所有循环代码都是顺序的，即可以对其元素进行并行化处理。如果你想做并行过滤，就需要自己写代码，这并不是那么容易。通过引入lambda表达式和默认方法，将做什么和怎么做的问题分开了，这意味着Java集合现在知道怎样做迭代，并可以在API层面对集合元素进行并行处理。下面的例子里，我将介绍如何在使用 lambda或不使用lambda表达式的情况下迭代列表。你可以看到列表现在有了一个  forEach()  方法，它可以迭代所有对象，并将你的lambda代码应用在其中。 

// Java 8之前： 
List features = Arrays.asList("Lambdas", "Default Method", "Stream API", "Date and Time API"); for (String feature : features) { 

 System.out.println(feature); 

}

// Java 8之后： 
List features = Arrays.asList("Lambdas", "Default Method", "Stream API", "Date and Time API"); features.forEach(n -> System.out.println(n)); 

// 使用Java 8的方法引用更方便，方法引用由::双冒号操作符标示， 

// 看起来像C++的作用域解析运算符 

features.forEach(System.out::println); 

输出： 

Lambdas

Default Method

Stream API

Date and Time API

列表循环的最后一个例子展示了如何在Java 8中使用方法引用（method reference）。你可以看到C++里面的

双冒号、范围解析操作符现在在Java 8中用来表示方法引用。 

例4、使用lambda表达式和函数式接口Predicate

除了在语言层面支持函数式编程风格，Java 8也添加了一个包，叫做  java.util.function。它包含了很多类，用来

支持 Java 的函数式编程。其中一个便是 Predicate，使用  java.util.function.Predicate 函数式接口以及 lambda 表

达式，可以向API方法添加逻辑，用更少的代码支持更多的动态行为。下面是Java 8 Predicate 的例子，展示了过滤

集合数据的多种常用方法。Predicate接口非常适用于做过滤。 

public static void main(args[]){ 
 List languages = Arrays.asList("Java", "Scala", "C++", "Haskell", "Lisp"); 

 System.out.println("Languages which starts with J :"); 

 filter(languages, (str)->str.startsWith("J"));

 System.out.println("Languages which ends with a "); 

 filter(languages, (str)->str.endsWith("a"));

 System.out.println("Print all languages :"); 

 filter(languages, (str)->true);

 System.out.println("Print no language : "); 

 filter(languages, (str)->false);

 System.out.println("Print language whose length greater than 4:");  filter(languages, (str)->str.length() > 4);

}

public static void filter(List names, Predicate condition) {   for(String name: names)  { 

 if(condition.test(name)) { 

 System.out.println(name + " "); 

 } 

 } 

}

// filter更好的办法--filter方法改进 
public static void filter(List names, Predicate condition) { 
 names.stream().filter((name) -> (condition.test(name))).forEach((name) -> {  System.out.println(name + " "); 

 }); 

}

可以看到，Stream API 的过滤方法也接受一个Predicate，这意味着可以将我们定制的  filter() 方法替换成写在

里面的内联代码，这就是lambda表达式的魔力。另外，Predicate接口也允许进行多重条件的测试，下个例子将要讲

到。 

例5、如何在lambda表达式中加入Predicate 

上个例子说到，java.util.function.Predicate 允许将两个或更多的  Predicate 合成一个。它提供类似于逻辑操作

符AND和OR的方法，名字叫做and()、or()和xor()，用于将传入  filter() 方法的条件合并起来。例如，要得到所有

以J开始，长度为四个字母的语言，可以定义两个独立的  Predicate 示例分别表示每一个条件，然后用  Predicate.and()

方法将它们合并起来，如下所示： 

// 甚至可以用and()、or()和xor()逻辑函数来合并Predicate， 
// 例如要找到所有以J开始，长度为四个字母的名字，你可以合并两个Predicate并传入 Predicate<String> startsWithJ = (n) -> n.startsWith("J");

Predicate<String> fourLetterLong = (n) -> n.length() == 4;

names.stream()

 .filter(startsWithJ.and(fourLetterLong)) 
 .forEach((n) -> System.out.print("nName, which starts with 'J' and four letter long is : " + 

n));

类似地，也可以使用  or() 和  xor() 方法。本例着重介绍了如下要点：可按需要将  Predicate 作为单独条件然后

将其合并起来使用。简而言之，你可以以传统 Java 命令方式使用  Predicate 接口，也可以充分利用 lambda 表达式

达到事半功倍的效果。 

例6、Java 8中使用lambda表达式的Map和Reduce示例 

本例介绍最广为人知的函数式编程概念map。它允许你将对象进行转换。例如在本例中，我们将  costBeforeTax

列表的每个元素转换成为税后的值。我们将  x -> x*x lambda表达式传到  map() 方法，后者将其应用到流中的每一

个元素。然后用  forEach() 将列表元素打印出来。使用流API的收集器类，可以得到所有含税的开销。有  toList() 这

样的方法将  map 或任何其他操作的结果合并起来。由于收集器在流上做终端操作，因此之后便不能重用流了。你甚

至可以用流API的  reduce() 方法将所有数字合成一个，下一个例子将会讲到。 

// 不使用lambda表达式为每个订单加上12%的税 
List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500); for (Integer cost : costBeforeTax) { 

 double price = cost + .12*cost; 

 System.out.println(price); 

}

// 使用lambda表达式 
List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
costBeforeTax.stream().map((cost) -> cost + .12*cost).forEach(System.out::println);

在上面例子中，可以看到map将集合类（例如列表）元素进行转换的。还有一个  reduce() 函数可以将所有值合

并成一个。Map和Reduce操作是函数式编程的核心操作，因为其功能，reduce 又被称为折叠操作。另外，reduce 

并不是一个新的操作，你有可能已经在使用它。SQL 中类似  sum()、avg() 或者  count() 的聚集函数，实际上就是 

reduce 操作，因为它们接收多个值并返回一个值。流API定义的  reduceh() 函数可以接受lambda表达式，并对所

有值进行合并。IntStream 这样的类有类似  average()、count()、sum() 的内建方法来做  reduce 操作，也有

mapToLong()、mapToDouble() 方法来做转换。这并不会限制你，你可以用内建方法，也可以自己定义。在这个Java 

8的Map Reduce示例里，我们首先对所有价格应用  12% 的VAT，然后用  reduce() 方法计算总和。 

// 为每个订单加上12%的税 

// 老方法： 
List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500); double total = 0;

for (Integer cost : costBeforeTax) { 

 double price = cost + .12*cost; 

 total = total + price;

}

System.out.println("Total : " + total); 

// 新方法： 
List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500); 
double bill = costBeforeTax.stream().map((cost) -> cost + .12*cost).reduce((sum, cost) -> sum + cost).get();

System.out.println("Total : " + bill); 

例7、通过过滤创建一个String列表 

过滤是 Java 开发者在大规模集合上的一个常用操作，而现在使用 lambda 表达式和流 API 过滤大规模数据集合

是惊人的简单。流提供了一个  filter() 方法，接受一个  Predicate 对象，即可以传入一个lambda表达式作为过滤逻

辑。下面的例子是用lambda表达式过滤Java集合，将帮助理解。 

// 创建一个字符串列表，每个字符串长度大于2
List costBeforeTax = Arrays.asList("abc","bcd","defg","jk");
List<String> filtered = strList.stream().filter(x -> x.length()> 2).collect(Collectors.toList()); System.out.printf("Original List : %s, filtered list : %s %n", strList, filtered); 

输出： 
Original List : [abc, , bcd, , defg, jk], filtered list : [abc, bcd, defg] 

另外，关于  filter() 方法有个常见误解。在现实生活中，做过滤的时候，通常会丢弃部分，但使用filter()方法则是获得一个新的列表，且其每个元素符合过滤原则。 

例8、对列表的每个元素应用函数 

我们通常需要对列表的每个元素使用某个函数，例如逐一乘以某个数、除以某个数或者做其它操作。这些操作都

很适合用  map() 方法，可以将转换逻辑以lambda表达式的形式放在  map() 方法里，就可以对集合的各个元素进行

转换了，如下所示。 

// 将字符串换成大写并用逗号链接起来 
List<String> G7 = Arrays.asList("USA", "Japan", "France", "Germany", "Italy", "U.K.","Canada"); String G7Countries = G7.stream().map(x -> x.toUpperCase()).collect(Collectors.joining(", ")); System.out.println(G7Countries); 

输出： 

USA, JAPAN, FRANCE, GERMANY, ITALY, U.K., CANADA

例9、复制不同的值，创建一个子列表 

本例展示了如何利用流的  distinct() 方法来对集合进行去重 

// 用所有不同的数字创建一个正方形列表 
List<Integer> numbers = Arrays.asList(9, 10, 3, 4, 7, 3, 4); 
List<Integer> distinct = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList()); System.out.printf("Original List : %s,  Square Without duplicates : %s %n", numbers, distinct); 

输出： 
Original List : [9, 10, 3, 4, 7, 3, 4],  Square Without duplicates : [81, 100, 9, 16, 49] 

例10、计算集合元素的最大值、最小值、总和以及平均值 

IntStream、LongStream 和  DoubleStream 等流的类中，有个非常有用的方法叫做  summaryStatistics() 。可

以返回  IntSummaryStatistics、LongSummaryStatistics 或者  DoubleSummaryStatistic s，描述流中元素的各种

摘要数据。在本例中，我们用这个方法来计算列表的最大值和最小值。它也有  getSum() 和  getAverage() 方法来获

得列表的所有元素的总和及平均值。 

//获取数字的个数、最小值、最大值、总和以及平均值 
List<Integer> primes = Arrays.asList(2, 3, 5, 7, 11, 13, 17, 19, 23, 29);

IntSummaryStatistics stats = primes.stream().mapToInt((x) -> x).summaryStatistics(); System.out.println("Highest prime number in List : " + stats.getMax()); 
System.out.println("Lowest prime number in List : " + stats.getMin());
System.out.println("Sum of all prime numbers : " + stats.getSum()); 
System.out.println("Average of all prime numbers : " + stats.getAverage()); 

输出： 

Highest prime number in List : 29 

Lowest prime number in List : 2 

Sum of all prime numbers : 129 

Average of all prime numbers : 12.9 

Java  8 的10 个 lambda 表达式，这对于新手来说是个合适的任务量，你可能需要亲自运行示例程序以便掌握。

试着修改要求创建自己的例子，达到快速学习的目的。 

补充：从例子中我们可以可以看到，以前写的匿名内部类都用了 lambda 表达式代替了。那么，我们简单谈谈

“lambda表达式&匿名内部类” 

两者不用： 

1.  关键字this 

(1)  匿名内部类中的this代表匿名类 

(2)  Lambda表达式中的this代表lambda表达式的类 

2.  编译方式不同 

(1)  匿名内部类中会编译成一个.class文件，文件命名方式为：主类+$+(1,2,3.......)

(2)  Java 编译器将 lambda 表达式编译成类的私有方法。使用了 Java 7 的  invokedynamic 字节码指

令来动态绑定这个方法 

2.  Java8中的lambda表达式要点（2017-12-02-wl） 

通过面10个小示例中学习，我们下面说下lambda表达式的6个要点 

要点1：lambda表达式的使用位置 

预定义使用了  @Functional 注释的函数式接口，自带一个抽象函数的方法，或者SAM（Single Abstract Method 单个抽象方法）类型。这些称为lambda表达式的目标类型，可以用作返回类型，或lambda目标代码的参数。例如，若一个方法接收Runnable、Comparable或者  Callable 接口，都有单个抽象方法，可以传入lambda表达式。类似的，如果一个方法接受声明于  java.util.function 包内的接口，例如  Predicate、Function、Consumer 或  Supplier，那么可以向其传lambda表达式。 

要点2：lambda表达式和方法引用 

lambda 表达式内可以使用方法引用，仅当该方法不修改 lambda 表达式提供的参数。本例中的 lambda 表达式可以换为方法引用，因为这仅是一个参数相同的简单方法调用。 

list.forEach(n -> System.out.println(n)); 

list.forEach(System.out::println);  // 使用方法引用 

然而，若对参数有任何修改，则不能使用方法引用，而需键入完整地lambda表达式，如下所示： 

list.forEach((String s) -> System.out.println("*" + s + "*"));

事实上，可以省略这里的lambda参数的类型声明，编译器可以从列表的类属性推测出来。 

要点3：lambda表达式内部引用资源 

lambda内部可以使用静态、非静态和局部变量，这称为lambda内的变量捕获。 

要点4：lambda表达式也成闭包 

Lambda表达式在Java中又称为闭包或匿名函数，所以如果有同事把它叫闭包的时候，不用惊讶。 

要点5：lambda表达式的编译方式 

Lambda方法在编译器内部被翻译成私有方法，并派发  invokedynamic 字节码指令来进行调用。可以使用JDK中的  javap 工具来反编译class文件。使用  javap -p 或  javap -c -v 命令来看一看lambda表达式生成的字节码。

大致应该长这样： 

private static java.lang.Object lambda$0(java.lang.String); 

要点6：lambda表达式的限制 

lambda 表达式有个限制，那就是只能引用  final 或  final 局部变量，这就是说不能在 lambda 内部修改定义在域外的变量。 

List<Integer> primes = Arrays.asList(new Integer[]{2, 3,5,7}); 

int factor = 2;

primes.forEach(element -> { factor++; }); 

Error： 

Compile  time  error  :  "local  variables  referenced  from  a  lambda  expression  must  be  final  or 

effectively final"

另外，只是访问它而不作修改是可以的，如下所示： 

List<Integer> primes = Arrays.asList(new Integer[]{2, 3,5,7}); 

int factor = 2;

primes.forEach(element -> { System.out.println(factor*element); }); 

输出： 

4

6

10

14

因此，它看起来更像不可变闭包，类似于Python。 

3.  Java8中的Optional类的解析（2017-12-02-wl） 

身为一名Java程序员，大家可能都有这样的经历：调用一个方法得到了返回值却不能直接将返回值作为参数去调用别的方法。我们首先要判断这个返回值是否为 null，只有在非空的前提下才能将其作为其他方法的参数。这正是一些类似Guava 的外部API试图解决的问题。一些JVM编程语言比如Scala、Ceylon等已经将对在核心API中解决了这个问题。在我的前一篇文章中，介绍了Scala 是如何解决了这个问题。 

新版本的Java，比如Java 8 引入了一个新的Optional 类。Optional类的Javadoc描述如下： 

这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。 

下面会逐个探讨Optional类包含的方法，并通过一两个示例展示如何使用。 

方法1：Optional.of() 

作用：为非null的值创建一个Optional。 

说明：of方法通过工厂方法创建Optional类。需要注意的是，创建对象时传入的参数不能为null。如果传入参数为null，则抛出NullPointerException 。 

//调用工厂方法创建Optional实例 

Optional<String> name = Optional.of("Sanaulla"); 

//传入参数为null，抛出NullPointerException.

Optional<String> someNull = Optional.of(null); 

方法2：Optional.ofNullable() 

作用：为指定的值创建一个Optional，如果指定的值为null，则返回一个空的Optional。 说明：ofNullable与of方法相似，唯一的区别是可以接受参数为null的情况。 

//下面创建了一个不包含任何值的Optional实例 

//例如，值为'null'

Optional empty = Optional.ofNullable(null); 

方法3：Optional.isPresent() 

作用：判断预期值是否存在 

说明：如果值存在返回true，否则返回false。 

//isPresent方法用来检查Optional实例中是否包含值 

Optional<String> name = Optional.of("Sanaulla"); 

if (name.isPresent()) {

 //在Optional实例内调用get()返回已存在的值 

 System.out.println(name.get());//输出Sanaulla 

}

方法4：Optional.get() 

作用：如果Optional有值则将其返回，否则抛出NoSuchElementException。 

说明：上面的示例中，get方法用来得到Optional实例中的值。下面我们看一个抛出NoSuchElementException的例子 

//执行下面的代码会输出：No value present

try {

 Optional empty = Optional.ofNullable(null);

 //在空的Optional实例上调用get()，抛出NoSuchElementException

 System.out.println(empty.get()); 

} catch (NoSuchElementException ex) { 

 System.out.println(ex.getMessage()); 

}

方法5：Optional.ifPresent()

作用：如果Optional实例有值则为其调用consumer，否则不做处理 
说明：要理解ifPresent方法，首先需要了解Consumer类。简答地说，Consumer类包含一个抽象方法。该抽象方法对传入的值进行处理，但没有返回值。Java8 支持不用接口直接通过lambda表达式传入参数，如果Optional实例有值，调用ifPresent()可以接受接口段或lambda表达式 

//ifPresent方法接受lambda表达式作为参数。 

//lambda表达式对Optional的值调用consumer进行处理。 

Optional<String> name = Optional.of("Sanaulla"); 

name.ifPresent((value) -> { 

 System.out.println("The length of the value is: " + value.length()); 

});

方法7：Optional.orElse() 

作用：如果有值则将其返回，否则返回指定的其它值。 

说明：如果Optional实例有值则将其返回，否则返回orElse方法传入的参数。示例如下： 

Optional<String> name = Optional.of("Sanaulla"); 

Optional<String> someNull = Optional.of(null); 

//如果值不为null，orElse方法返回Optional实例的值。 

//如果为null，返回传入的消息。 

//输出：There is no value present! 

System.out.println(empty.orElse("There is no value present!")); 

//输出：Sanaulla

System.out.println(name.orElse("There is some value!")); 

方法8：Optional.orElseGet()

作用：如果有值则将其返回，否则返回指定的其它值。 

说明：orElseGet与orElse方法类似，区别在于得到的默认值。orElse方法将传入的字符串作为默认值，orElseGet

方法可以接受Supplier接口的实现用来生成默认值 

Optional<String> name = Optional.of("Sanaulla"); 

Optional<String> someNull = Optional.of(null);

//orElseGet与orElse方法类似，区别在于orElse传入的是默认值， 

//orElseGet可以接受一个lambda表达式生成默认值。 

//输出：Default Value

System.out.println(empty.orElseGet(() -> "Default Value"));

//输出：Sanaulla

System.out.println(name.orElseGet(() -> "Default Value"));

方法9：Optional.orElseThrow() 

作用：如果有值则将其返回，否则抛出supplier接口创建的异常。 

说明：在orElseGet方法中，我们传入一个Supplier接口。然而，在orElseThrow中我们可以传入一个lambda

表达式或方法，如果值不存在来抛出异常 

try {

Optional<String> empty= Optional.of(null); 

 //orElseThrow与orElse方法类似。与返回默认值不同， 

 //orElseThrow会抛出lambda表达式或方法生成的异常  

 empty.orElseThrow(ValueAbsentException::new); 

} catch (Throwable ex) {

 //输出: No value present in the Optional instance

 System.out.println(ex.getMessage()); 

}

ValueAbsentException定义如下： 

class ValueAbsentException extends Throwable { 

 public ValueAbsentException() { 

 super();

 }

 public ValueAbsentException(String msg) { 

 super(msg);

 }

 @Override

 public String getMessage() { 

 return "No value present in the Optional instance"; 

 }

} 

方法10：Optional.map()

作用：如果有值，则对其执行调用mapping函数得到返回值。如果返回值不为null，则创建包含mapping返回

值的Optional作为map方法返回值，否则返回空Optional。 

说明：map 方法用来对 Optional 实例的值执行一系列操作。通过一组实现了 Function 接口的 lambda 表达式

传入操作。 

Optional<String> name = Optional.of("Sanaulla"); 

//map方法执行传入的lambda表达式参数对Optional实例的值进行修改。 

//为lambda表达式的返回值创建新的Optional实例作为map方法的返回值。 

Optional<String> upperName = name.map((value) -> value.toUpperCase()); System.out.println(upperName.orElse("No value found")); 

方法11：Optional.flatMap() 

作用：如果有值，为其执行mapping函数返回Optional类型返回值，否则返回空Optional。flatMap与map

（Funtion）方法类似，区别在于flatMap中的mapper返回值必须是Optional。调用结束时，flatMap不会对结果

用Optional封装。 

说明：flatMap方法与map方法类似，区别在于mapping函数的返回值不同。map方法的mapping函数返回值可以是任何类型T，而flatMap方法的mapping函数必须是Optional。 

Optional<String> name = Optional.of("Sanaulla"); 
//flatMap与map（Function）非常类似，区别在于传入方法的lambda表达式的返回类型。 //map方法中的lambda表达式返回值可以是任意类型，在map函数返回之前会包装为Optional。 //但flatMap方法中的lambda表达式返回值必须是Optionl实例。 

upperName = name.flatMap((value) -> Optional.of(value.toUpperCase())); System.out.println(upperName.orElse("No value found"));//输出SANAULLA

方法12：Optional.filter()

作用：如果有值并且满足断言条件返回包含该值的Optional，否则返回空Optional。 

说明：filter个方法通过传入限定条件对Optional实例的值进行过滤。这里可以传入一个lambda 表达式。对于

filter函数我们应该传入实现了Predicate接口的lambda表达式。 

Optional<String> name = Optional.of("Sanaulla"); 

//filter方法检查给定的Option值是否满足某些条件。 

//如果满足则返回同一个Option实例，否则返回空Optional。 

Optional<String> longName = name.filter((value) -> value.length() > 6);
System.out.println(longName.orElse("The name is less than 6 characters"));//输出Sanaulla

//另一个例子是Optional值不满足filter指定的条件。 

Optional<String> anotherName = Optional.of("Sana"); 
Optional<String> shortName = anotherName.filter((value) -> value.length() > 6); //输出：name长度不足6字符 
System.out.println(shortName.orElse("The name is less than 6 characters")); 

总结：Optional方法 

以上，我们介绍了Optional类的各个方法。下面通过一个完整的示例对用法集中展示。 

1 public class OptionalDemo { 

2

3  public static void main(String[] args) {

4  //创建Optional实例，也可以通过方法返回值得到。 

5  Optional<String> name = Optional.of("Sanaulla");

6

7  //创建没有值的Optional实例，例如值为'null'

8  Optional empty = Optional.ofNullable(null); 

9

10  //isPresent方法用来检查Optional实例是否有值。 

11  if (name.isPresent()) { 

12  //调用get()返回Optional值。 

13  System.out.println(name.get());

14  }

15

16  try {

17  //在Optional实例上调用get()抛出NoSuchElementException。 

18  System.out.println(empty.get());

19  } catch (NoSuchElementException ex) {

20  System.out.println(ex.getMessage());

21  }

22

23  //ifPresent方法接受lambda表达式参数。 

24  //如果Optional值不为空，lambda表达式会处理并在其上执行操作。 

25  name.ifPresent((value) -> { 

26  System.out.println("The length of the value is: " + value.length()); 

27  });

28

29  //如果有值orElse方法会返回Optional实例，否则返回传入的错误信息。 

30  System.out.println(empty.orElse("There is no value present!")); 

31  System.out.println(name.orElse("There is some value!")); 

32

33  //orElseGet与orElse类似，区别在于传入的默认值。 

34  //orElseGet接受lambda表达式生成默认值。 

35  System.out.println(empty.orElseGet(() -> "Default Value"));

36  System.out.println(name.orElseGet(() -> "Default Value"));

37

38  try {

39  //orElseThrow与orElse方法类似，区别在于返回值。 

40  //orElseThrow抛出由传入的lambda表达式/方法生成异常。 

41  empty.orElseThrow(ValueAbsentException::new); 

42  } catch (Throwable ex) { 

43  System.out.println(ex.getMessage());

44  }

45

46  //map方法通过传入的lambda表达式修改Optonal实例默认值。  

47  //lambda表达式返回值会包装为Optional实例。 

48  Optional<String> upperName = name.map((value) -> value.toUpperCase());

49  System.out.println(upperName.orElse("No value found")); 

50

51  //flatMap与map（Funtion）非常相似，区别在于lambda表达式的返回值。