JDK 8的新特性-Lambda表达式 精品文章总结java谭青海-

一. 前言

JDK8已经发布快4年的时间了，现在来谈它的新特性显得略微的有点“不合时宜”。尽管JDK8已不再“新”，但它的重要特性之一——Lambda表达式依然是不被大部分开发者所熟练运用，甚至不被开发者所熟知。
　　国内的开发环境大家都知道，有各种的老项目，有各种各样的发布风险，让公司以及项目组对新的技术往往望而却步，有公司甚至时至今日还在使用JDK6来进行项目开发，这导致了在很多技术的选择上受到了很大限制，进而不能跟随时代的脚步使得项目甚至公司一步一步走向衰落。
　　本文简单认识JDK8的重要新特性之一——Lambda表达式。 在JDK8之前，Java是不支持函数式编程的，所谓的函数编程，即可理解是将一个函数（也称为“行为”）作为一个参数进行传递。通常我们提及得更多的是面向对象编程，面向对象编程是对数据的抽象（各种各样的POJO类），而函数式编程则是对行为的抽象（将行为作为一个参数进行传递）。在JavaScript中这是很常见的一个语法特性，但在Java中将一个函数作为参数传递这却行不通，好在JDK8的出现打破了Java的这一限制。

1.2 认识Lambda表达式

 @Test public void test01(){ // JDK 1.8之前用法         Runnable r1 = new Runnable() { @Override public void run() {                 System.out.println("JDK 8之前用法"); } };         r1.run(); // Lambda表达式用法         Runnable r2 = ()->System.out.println("JDK 8 用法--Lambda表达式用法");         r2.run(); } 

说明:

1. 在这个例子中,传统的语法规则,我们是讲一个匿名内部内作为参数进行传递,我们实现了Runnable接口,并且将其作为参数传递给Thread类. 实际上我们传递的是一段代码, 即 我们将代码作为数据进行传递,这就带来了需要不必要的”样板代码”
2. Lambda表达式一共分为三个部分:
   1. 左边: 代表参数列表
   2. 右边:表示Lambda体
   3. ‘->’ 箭头操作符

二. Lambda 表达式的格式

2.1 语法格式一: 无参数,无返回值,Lambda体只有一条语句

()->System.out.println(“hello Lambda!”);

 /**      * 语法格式一: 无参数,无返回值      */ @Test public void test01(){ int num = 0 ; // JDK 1.7 前, 必须是final         Runnable r  = new Runnable() { @Override public void run() {                 System.out.println("Hello world! "+ num); } };         r.run();          System.out.println("-----------------------");         Runnable r1 = ()->System.out.println("hello World");         System.out.println(r1); } 

2.2 语法格式二: 有一个参数,并且无返回值

(x)->System.out.println(x);
只有一个参数时,小括号”()” 可以省略

 /**      * 语法格式二: 有一个参数,无返回值      */ @Test public void test02(){         Consumer<String> con = (x)->System.out.println(x);         con.accept("hello Consumer");                   System.out.println("-----------------------");         Consumer<String> con1 = x->System.out.println(x);         con1.accept("hello Consumer"); } 

2.3 语法格式三: 有两个以上的参数,并且有返回值,并且Lambda体有多条语句

1. 两个以上的参数,左侧的”小括号()” 不能省略
2. Lambda 体有多条语句是,{} 不能省略
3. Lambda 体存在多条语句是return不能省略

 /**      * 语法格式四: 有两个以上的参数,有返回值,并且Lambda体有多条语句时      *  大括号"{}" 不可以省略,并且参数的小括号"()"也不能省略      */ @Test public void test04(){         Comparator<Integer> com = (x,y)->{             System.out.println("函数式接口"); return x.compareTo(y); }; int compare = com.compare(3, 4);         System.out.println(compare); } 

2.4 语法格式四:若Lambda体中只有一条语句,return和大括号{}都可以省略

2.5 语法格式五:Lambda表达式的参数列表数据类型可以省略不写,因为JVM编译器通过上下文推断出,数据类型,即:“类型推断”

(Integer x, Integer y) -> Integer.compare(x, y); 

总结:
上联：左右遇一括号省
下联：左侧推断类型省
横批：能省则省

三. 函数式接口

3.1 什么是函数式接口?

1. 只包含一个包含一个抽象方法的接口,称为函数式接口
2. 可以通过Lambda表达式来创建爱你改接口的对象.(若Lambda表达式抛出一个受检异常,那么该异常需要在目标接口的抽象方法上声明).
3. 可以在任意函数式接口上使用@FunctionIntrerace注解,这样做可以检查他是否是一个函数式接口,同时,Javadoc也会包含一条声明,说明这个接口是一个函数式接口

3.2 自定义的函数式接口

@FunctionInterface public interface MyNumber{ public double getValue(); } // 函数式接口中使用泛型 @FunctionInterface public interface MyFunc<T>{ public T getValue(T t); } // 作为参数传递Lambda表达式 public String toUpperString(MyFunc<String> mf, String str){ return mf.getValue(str); } // 作为参数传递给Lambda表达式: String newStr = toUpperString( (str) -> str.toUpperCase(), "abcdef"); System.out.println(newStr); /* 作为参数传递Lambda表达式:   为了将Lambda表达式作为参数传递,接受Lambda 表达式的参数类型必须与该Lambda  表达式兼容的函数接口的类型 */ 

3.3 Java内置的四大核心函数式接口

package com.atguigu.java8; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.function.Consumer; import java.util.function.Function; import java.util.function.Predicate; import java.util.function.Supplier; import org.junit.Test; /*  * Java8 内置的四大核心函数式接口  *   * Consumer<T> : 消费型接口  *   void accept(T t);  *   * Supplier<T> : 供给型接口  *   T get();   *   * Function<T, R> : 函数型接口  *   R apply(T t);  *   * Predicate<T> : 断言型接口  *   boolean test(T t);  *   */ public class TestLambda3 { //Predicate<T> 断言型接口： @Test public void test4(){   List<String> list = Arrays.asList("Hello", "Dreamhai", "Lambda", "www", "ok");   List<String> strList = filterStr(list, (s) -> s.length() > 3); for (String str : strList) {    System.out.println(str); } } //需求：将满足条件的字符串，放入集合中 public List<String> filterStr(List<String> list, Predicate<String> pre){   List<String> strList = new ArrayList<>(); for (String str : list) { if(pre.test(str)){     strList.add(str); } } return strList; } //Function<T, R> 函数型接口： @Test public void test3(){   String newStr = strHandler("ttt 我大青海威武   ", (str) -> str.trim());   System.out.println(newStr);      String subStr = strHandler("我大青海威武", (str) -> str.substring(2, 4));   System.out.println(subStr); } //需求：用于处理字符串 public String strHandler(String str, Function<String, String> fun){ return fun.apply(str); } //Supplier<T> 供给型接口 : @Test public void test2(){   List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100)); for (Integer num : numList) {    System.out.println(num); } } //需求：产生指定个数的整数，并放入集合中 public List<Integer> getNumList(int num, Supplier<Integer> sup){   List<Integer> list = new ArrayList<>(); for (int i = 0; i < num; i++) {    Integer n = sup.get();    list.add(n); } return list; } //Consumer<T> 消费型接口 : @Test public void test1(){ happy(10000, (m) -> System.out.println("你们海哥喜欢大宝剑，每次消费：" + m + "元")); } public void happy(double money, Consumer<Double> con){   con.accept(money); } } 

四. 方法引用与构造器的引用

4.1 方法引用

1. 当要传递给Lambda体的操作,已经有实现的方法了,可以试用方法引用!(实现抽象方法的参数列表,必须与方法引用方法的参数列表保持一致!)
2. 方法引用: 使用操作符”::“将方法名和对象或类的名字分割开来
3. 主要有以下三种情况:
   3.1 对象::实例方法
   3.2 类::静态方法
   3.3 类::实例方法

// 例如: (x)->System.out.println(x); <=>  System.out::println  // 例如: BinaryOperator<Double> bo = (x,y)-> Math.pow(x,y); <=> BinaryOperator<Double> bo = Math::pow; // 例如: Compare((x,y)->x.equals(y),"abcdef","abcdef"); <=> Compare(String::equals,"abcdef","abcdef"); // 注意: 当需要引入方法的第一个参数是调用对象,并且第二个参数是需要引用方法的第二个参数(或无参数)时: ClassName::methodName 

4.2 构造器引用

格式: ClassName::new
与函数式接口相结合,自动与函数式接口中的方法兼容.
可以吧构造器引用赋值给定义的方法. 与构造器参数列表要与接口中抽象方法的参数列表一直!

Function<Integer,MyClass> fun = (n)->new MyClass(n); <=> Function<Integer,MyClass> fun = MyClass::new ; 

4.3 数组引用

格式: type[] :: new

Function<Integer,Integer[]> fun = (n)->new Integer[n]; <=> Function<Integer,Integer[]> fun = MyClass[]::new ;