JDK8的新特性——Lambda表达式,jdk8新特性lambda

澳门新葡亰网站注册 3

计算机专家在问题求解时非常重视表达式简洁性的价值。Unix的先驱者Ken
Thompson曾经说过非常著名的一句话:“丢弃1000行代码的那一天是我最有成效的一天之一。”这对于任何一个需要持续支持和维护的软件项目来说,都是一个当之无愧的目标。早期的Lisp贡献者Paul
Graham甚至将语言的简洁性等同为语言的能力。这种对能力的认识让可以编写紧凑、简介的代码成为许多现代软件项目选择语言的首要标准。

JDK8的新特性——Lambda表达式,jdk8新特性lambda

  JDK8已经发布快4年的时间了,现在来谈它的新特性显得略微的有点“不合时宜”。尽管JDK8已不再“新”,但它的重要特性之一——Lambda表达式依然是不被大部分开发者所熟练运用,甚至不被开发者所熟知。

  国内的开发环境大家都知道,有各种的老项目,有各种各样的发布风险,让公司以及项目组对新的技术往往望而却步,有公司甚至时至今日还在使用JDK6来进行项目开发,这导致了在很多技术的选择上受到了很大限制,进而不能跟随时代的脚步使得项目甚至公司一步一步走向衰落。

  本文简单认识JDK8的重要新特性之一——Lambda表达式。
在JDK8之前,Java是不支持函数式编程的,所谓的函数编程,即可理解是将一个函数(也称为“行为”)作为一个参数进行传递。通常我们提及得更多的是面向对象编程,面向对象编程是对数据的抽象(各种各样的POJO类),而函数式编程则是对行为的抽象(将行为作为一个参数进行传递)。在JavaScript中这是很常见的一个语法特性,但在Java中将一个函数作为参数传递这却行不通,好在JDK8的出现打破了Java的这一限制。

 

认识Lambda表达式

  首先来引入一个示例,不知给是否有在IDEA编写代码的经历,如果在JDK8的环境下如下所示按照Java传统的语法规则编写一个线程。

1 new Thread(new Runnable() {
2     @Override
3     public void run() {
4         System.out.println("Hello World!");
5     }
6 });

  IDEA会给出提示可以使用Lambda表达式替换。

澳门新葡亰网站注册 1

  使用Lambda表达式则只需要使用一句话就可代替上面使用匿名类的方式。

new Thread(() -> System.out.println("Hello World!"));

   在这个例子中,传统的语法规则,我们是将一个匿名内部类作为参数进行传递,我们实现了Runnable接口,并将其作为参数传递给Thread类,这实际上我们传递的是一段代码,也即我们将代码作为了数据进行传递,这就带来许多不必要的“样板代码”。

  Lambda表达式一共有三部分组成:

澳门新葡亰网站注册 2

  后面的示例中我们会详解这个结构,包括有无参数,有无返回值的问题。
那么这个看起来奇奇怪怪的不太像Java的语法规则,其本身含义到底什么呢?这也是开始困扰我的问题,什么时候在什么场景下可以使用Lambda表达式。

  能够接收Lambda表达式的参数类型,是一个只包含一个方法的接口。只包含一个方法的接口称之为“函数接口”。

  例如上面创建一个线程的示例,Runnable接口只包含一个方法,所以它被称为“函数接口”,所以它可以使用Lambad表达式来代替匿名内部类。根据这个规则,我们试着来写一个函数接口,并使用Lambda表达式作为参数传递。

1 package com.coderbuff.custom;
2 
3 /**
4  * 函数接口:只有一个方法的接口。作为Lambda表达式的类型
5  * Created by Kevin on 2018/2/17.
6  */
7 public interface FunctionInterface {
8     void test();
9 }

   测试:

 1 package com.coderbuff.custom;
 2 
 3 import org.junit.Test;
 4 
 5 /**
 6  * 函数接口测试
 7  * Created by Kevin on 2018/2/17.
 8  */
 9 public class FunctionInterfaceTest {
10 
11     @Test
12     public void testLambda() {
13         func(new FunctionInterface() {
14             @Override
15             public void test() {
16                 System.out.println("Hello World!");
17             }
18         });
19         //使用Lambda表达式代替上面的匿名内部类
20         func(() -> System.out.println("Hello World"));
21     }
22 
23     private void func(FunctionInterface functionInterface) {
24         functionInterface.test();
25     }
26 }

  可以看到,只要是一个接口中只包含一个方法,则可以使用Lambda表达式,这样的接口称之为“函数接口”。

  上面的函数接口比较简单不包含参数,也不包含返回值

  我们再来修改FunctionInterface函数接口逐步加大Lambda表达式的难度——包含参数,不包含返回值

1 package com.coderbuff.custom;
2 
3 /**
4  * 函数接口:只有一个方法的接口。作为Lambda表达式的类型
5  * Created by Kevin on 2018/2/17.
6  */
7 public interface FunctionInterface {
8     void test(int param);
9 }

  测试:

 1 package com.coderbuff.custom;
 2 
 3 import org.junit.Test;
 4 
 5 /**
 6  * 函数接口测试
 7  * Created by Kevin on 2018/2/17.
 8  */
 9 public class FunctionInterfaceTest {
10 
11     @Test
12     public void testLambda() {
13         //使用Lambda表达式代替匿名内部类
14         func((x) -> System.out.println("Hello World" + x));
15     }
16 
17     private void func(FunctionInterface functionInterface) {
18         int x = 1;
19         functionInterface.test(x);
20     }
21 }

  关注Lambda表达式“(x) -> Sysout.out.println(“Hello World” +
x)”,左边传递的是参数,此处并没有指明参数类型,因为它可以通过上下文进行类型推导,但在有些情况下不能推导出参数类型(在编译时不能推导通常IDE会提示),此时则需要指明参数类型。我个人建议,任何情况下指明函数的参数类型

  哪种情况不能推导出参数类型呢?就是函数接口是一个泛型的时候。

1 package com.coderbuff.custom;
2 
3 /**
4  * 函数接口:只有一个方法的接口。作为Lambda表达式的类型
5  * Created by Kevin on 2018/2/17.
6  */
7 public interface FunctionInterface<T> {
8     void test(T param);
9 } 

  测试:

 1 package com.coderbuff.custom;
 2 
 3 import org.junit.Test;
 4 
 5 /**
 6  * 函数接口测试
 7  * Created by Kevin on 2018/2/17.
 8  */
 9 public class FunctionInterfaceTest {
10 
11     @Test
12     public void testLambda() {
13         //使用Lambda表达式代替匿名内部类
14         func((Integer x) -> System.out.println("Hello World" + x));
15     }
16 
17     private void func(FunctionInterface<Integer> functionInterface) {
18         int x = 1;
19         functionInterface.test(x);
20     }
21 }

  上面的示例提到了Lambda表达式的两种情况:

  无参数,无返回值;

  有参数,无返回值。

  接下来就是有参数,有返回值这种较为复杂的情况。

1 package com.coderbuff.custom;
2 
3 /**
4  * 函数接口:只有一个方法的接口。作为Lambda表达式的类型
5  * Created by Kevin on 2018/2/17.
6  */
7 public interface FunctionInterface<T> {
8     boolean test(T param);
9 }

   测试:

 1 package com.coderbuff.custom;
 2 
 3 import org.junit.Test;
 4 
 5 /**
 6  * 函数接口测试
 7  * Created by Kevin on 2018/2/17.
 8  */
 9 public class FunctionInterfaceTest {
10 
11     @Test
12     public void testLambda() {
13         //使用Lambda表达式代替匿名内部类
14         func((Integer x) -> true);
15     }
16 
17     private void func(FunctionInterface<Integer> functionInterface) {
18         int x = 1;
19         functionInterface.test(x);
20     }
21 }

  此时的Lambda表达式“(Integer x) ->
true”,右边是表达式的主体,直接返回true,如果有多行代码,则可以直接使用花括号表示,例如:

func((Integer x) -> {
    System.out.println("Hello World" + x);
    return true;
});

  Lambda表达式基本的语法规则:

  无参数,无返回值;

  有参数,无返回值;

  有参数,有返回值。

澳门新葡亰网站注册,  这三种基本情况已经大致清楚了,特别是需要弄清,什么时候可以使用Lambda表达式代替匿名内部类,也就是Lambda表达式的应用场景是函数接口。Lambda表达式这一新特性在JDK8中的引入,更大的好处则是集合API的更新,新增的Stream类库,使得我们在遍历使用集合时不再像以往那样不断地使用for循环。

 

JDK8使用集合的正确姿势

  示例:计算来自“chengdu”的学生数量有多少。

  在JDK8前的代码:

for (Student student : studentList) {
    if (student.getCity().equals("chengdu")) {
        count++;
    }
}

  JDK8使用集合的正确姿势:

count = studentList.stream().filter((student -> student.getCity().equals("chengdu"))).count();

  API的使用“难度”恰似提高了,实际只是不熟悉而已。传统迭代的方式需要阅读完整个循环才能明白代码逻辑,JDK8通过流的方式则可以望文生义且代码量大大减小。

  其中最为重要的是——Stream流。Stream的是通过函数式编程方式实现的在集合类上进行复杂操作的工具。若要详细讲解Stream的实现方式我相信再写一篇博客也不为过,所以此处不再考查Stream的内部实现。这里是想告诉大家,如果有幸使用JDK8的开发环境进行开发,尽量学习使用新的集合操作API。

  上面对于Lambda表达式以及函数式编程仅仅只是到了一个“认识”的地步,似乎只是感受到了缩小代码量,本文对于Lambda式的认识不深入更多的是对于后面更多的知识做一个铺垫或者作为一个扫盲贴,有关Lambda表达式的应用太多,并发编程、响应式编程等等。如果你有关于Lambda表达式或者函数式编程有更好的见解不妨留下评论。

 

 

这是一个能给程序员加buff的公众号 

澳门新葡亰网站注册 3

JDK8已经发布快4年的时间了,现在来谈它的新特性显得略微的有点不合时宜。尽管JDK8已不再新…

任何程序都可以通过重构,去除多余的代码或无用的占位符,如空格,变得更加简短,不过某些语言天生就善于表达,也就特别适合于简短程序的编写。认识到这一点之后,Perl程序员普及了代码高尔夫竞赛;其目标是用尽可能短的代码量解决某一特定的问题或者实现某个指定的算法。APL语言的设计理念是利用特殊的图形符号让程序员用很少量的代码就可以编写功能强大的程序。这类程序如果实现得当,可以很好地映射成标准的数学表达式。简洁的语言在快速创建小脚本时非常高效,特别是在目的不会被简洁所掩盖的简洁明确的问题域中。

相比于其他程序设计语言,Java语言的冗长已经名声在外。其主要原因是由于程序开发社区中所形成的惯例,在完成任务时,很多情况下,要更大程度地考虑描述性和控制。例如,长期来看,长变量名会让大型代码库的可读性和可维护性更强。描述性的类名通常会映射为文件名,在向已有系统中增加新功能时,会显得很清晰。如果能够一直坚持下去,描述性名称可以极大简化用于表明应用中某一特定的功能的文本搜索。这些实践让Java在大型复杂代码库的大规模实现中取得了极大的成功。

对于小型项目来说,简洁性则更受青睐,某些语言非常适于短脚本编写或者在命令提示符下的交互式探索编程。Java作为通用性语言,则更适用于编写跨平台的工具。在这种情况下,“冗长Java”的使用并不一定能够带来额外的价值。虽然在变量命名等方面,代码风格可以改变,不过从历史情况来看,在一些基本的层面上,与其他语言相比,完成同样的任务,Java语言仍需更多的字符。为了应对这些限制,Java语言一直在不断地更新,以包含一些通常称为“语法糖”的功能。用这些习语可以实现更少的字符表示相同功能的目标。与其对应的更加冗长的配对物相比,这些习语更受程序开发社区的欢迎,通常会被社区作为通用用法快速地采用。

本文将着重介绍编写简洁Java代码的最佳实践,特别是关于JDK8中新增的功能。简而言之,Java
8中Lambda表达式的引入让更加优雅的代码成为可能。这在用新的Java Streaming
API处理集合时尤其明显。