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

文章目录

一. 前言
- 1.2 认识Lambda表达式
二. Lambda 表达式的格式
- 2.1 语法格式一: 无参数,无返回值,Lambda体只有一条语句
- 2.2 语法格式二: 有一个参数,并且无返回值
- 2.3 语法格式三: 有两个以上的参数,并且有返回值,并且Lambda体有多条语句
- 2.4 语法格式四:若Lambda体中只有一条语句,`return`和大括号`{}`都可以省略
- 2.5 语法格式五:Lambda表达式的参数列表数据类型可以省略不写,因为JVM编译器通过上下文推断出,数据类型,即:"类型推断"
三. 函数式接口
- 3.1 什么是函数式接口?
- 3.2 自定义的函数式接口
- 3.3 Java内置的四大核心函数式接口
四. 方法引用与构造器的引用
- 4.1 方法引用
- 4.2 构造器引用
- 4.3 数组引用

一. 前言

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

1.2 认识Lambda表达式

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

说明:

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

Lambda表达式一共分为三个部分:
左边: 代表参数列表

右边:表示Lambda体

‘->’ 箭头操作符

二. Lambda 表达式的格式

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

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

      /*** 语法格式一: 无参数,无返回值*/@Testpublic void test01(){int num = 0 ; // JDK 1.7 前, 必须是finalRunnable r  = new Runnable() {@Overridepublic 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);
只有一个参数时,小括号"()" 可以省略

    /*** 语法格式二: 有一个参数,无返回值*/@Testpublic 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体有多条语句

两个以上的参数,左侧的"小括号()" 不能省略

Lambda 体有多条语句是,{} 不能省略

Lambda 体存在多条语句是return不能省略

    /*** 语法格式四: 有两个以上的参数,有返回值,并且Lambda体有多条语句时*  大括号"{}" 不可以省略,并且参数的小括号"()"也不能省略*/@Testpublic 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 什么是函数式接口?

只包含一个包含一个抽象方法的接口,称为函数式接口
可以通过Lambda表达式来创建爱你改接口的对象.(若Lambda表达式抛出一个受检异常,那么该异常需要在目标接口的抽象方法上声明).
可以在任意函数式接口上使用@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内置的四大核心函数式接口

函数式接口	参数类型	返回类型	用途
Consumer 消费型接口	T	void	对类型为T的对象应用操作,包含方法: void accept(T t)
Supplier 供给型接口	无	T	返回类型为T的对象,包含方法:T get();
Function<T,R> 函数式接口	T	R	对类型为T的对象应用操作,并返回结果. 结果是R类型的对象. 包含的方法有: R apply (T t)
Predicate 断定型接口	T	boolean	确定类型为T的对象是否满足某约束,并且返回boolean值. 包含方法: boolean test(T t) ;

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> 断言型接口：@Testpublic 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> 函数型接口：@Testpublic void test3(){String newStr = strHandler("\t\t\t 我大青海威武   ", (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> 供给型接口 :@Testpublic 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> 消费型接口 :@Testpublic void test1(){happy(10000, (m) -> System.out.println("你们海哥喜欢大宝剑，每次消费：" + m + "元"));} public void happy(double money, Consumer<Double> con){con.accept(money);}
}

函数式接口	参数类型	返回类型	用途
BiFunction<T,U,R>	T,U	R	对类型为T,U 参数应用操作,返回R类型的结果. 包含的方法为: R apply(T t , U u);
UnaryOperator (Function子接口)	T	T	对类型为T的对象进行一元运算, 并返回T类型的结果. 包含方法: T apply(T t);
BinaryOperator (BiFunction子接口)	T,T	T	对类型为T 的对象进行二元运算,并且返回T类型的结果. 包含方法为: T apply(T t1 , T t2) ;
BiConsumer<T,U>	T,U	void	对类型为T,U 参数应用操作. 包含方法为 void accept(T t,U u);
ToIntFunction	T	int	计算int值的函数
ToLongFunction	T	long	计算long值的函数
ToDoubleFunction	T	double	计算double值的函数
IntFunction	int	R	参数为int类型的函数
LongFunction	long	R	参数为long类型的函数
DoubleFunction	double	R	参数为double类型的函数

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

4.1 方法引用

当要传递给Lambda体的操作,已经有实现的方法了,可以试用方法引用!(实现抽象方法的参数列表,必须与方法引用方法的参数列表保持一致!)
方法引用: 使用操作符"::"将方法名和对象或类的名字分割开来
主要有以下三种情况:
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 ;