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

一. 前言

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内置的四大核心函数式接口

函数式接口	参数类型	返回类型	用途
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> 断言型接口：
	@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("\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> 供给型接口 :
	@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);
	}
}

函数式接口	参数类型	返回类型	用途
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 方法引用

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 ;