Java8新特性（二）-Lambda表达式与函数式接口

前言

要是对Lambda表达式的语法格式不太清楚的可以去看看上一篇文章Java8新特性（一）-Lambda表达式

目录

1、介绍什么是函数式接口
2、一个正确的函数式接口的演示
3、lambda和函数式接口的使用
4、JDK1.8中四大内置核心函数式接口
5、对四大内置函数式接口进行举例

简介

在Java8更新的新特性中，Lambda和Stream可以说是更新的最重要的部分，而Lambda表达式常和函数式接口一起使用。所以本文就一起谈谈Lambda表达式与函数式接口。

一、首先需要介绍一下什么是函数式接口

其实在我们常见得Comparator、Callable、Runnable等其实都是函数式接口。在JDK8中这些接口上也都加上了@FunctionalInterface的注解。
下面我们看一下官方对@FunctionalInterface的注释。

在其官方注释中写非常清楚的说明了什么是函数式接口，总结一下就是

1.1、函数式接口就是一个接口，并且只有一个抽象方法。

1.2、在Java8接口中的静态方法和默认方法，不算是抽象方法

1.3、接口默认继承java.lang.Object，所以从object类继承过来的方法也不包括在内

1.4、该注解不是必须的，如果接口符合函数式接口标准，加不加无所谓，但是如果加了该注解，编译器会对该接口进行检查，如果不是函数式接口会报错

二、正确的函数式接口

// 正确的函数式接口
@FunctionalInterface
public interface TestInterface {
    // 抽象方法
    void test();
 
    // java.lang.Object中的方法不是抽象方法
    boolean equals(Object obj);
 
    // default不是抽象方法
    default void defaultMethod(){
 	 	//do something 
    }
 
    // static不是抽象方法
   static void staticMethod(){
   		//do something 
  }
}

三、lambda和函数式接口的使用

下面以java8中的forEach函数作为演示

可以看到forEach函数接受一个Consumer的函数式接口。

		String[] people = {"张三", "李四","王五","赵六","钱七", "孙八"};
        List<String> employees =  Arrays.asList(people);
        //使用匿名内部类，比较笨拙
        employees.forEach(new Consumer<String>() {
            @Override
            public void accept(String employee) {
                System.out.println(employee);
            }
        });
        // 以前的循环方式
        for (String employee : employees) {
            System.out.print(employee + "; ");
        }
        
        // 使用 lambda 表达式作为函数式接口的实例
        employees.forEach((employee) -> System.out.print(employee + "; "));
        
        // 在 Java 8 中使用双冒号操作符，这种写法称为方法引用
        employees.forEach(System.out::println);

函数式接口的一大特性就是可以被lambda表达式和方法引用代替。也就是说声明这样的接口，是可以灵活的以方法来传参。

四、JDK1.8新增的四大内置核心函数式接口

4.1、断言型接口

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
    ....
}

4.2、供给型接口

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

4.3、函数型接口

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
    ....
}

4.4、消费型接口

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
	.....
}

五、对四大函数式接口进行举例演示

5.1、断言型接口，该接口抽象方法为返回一个boolean。所以用在过滤比较多

//Predicate<T> 断言型接口：
	@Test
	public void test4(){
		List<String> list = Arrays.asList("Hello", "2dfire", "functional", "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);//将符合条件的字符串放入list
			}
		}
		
		return strList;
	}

5.2、函数型接口。跟名字一样，主要就是将此函数应用于给定的参数。

//Function<T, R> 函数型接口：
	@Test
	public void test3(){
		String newStr = strHandler("\t\t\t 开店就用2dfire   ", (str) -> str.trim());
		System.out.println(newStr);
		
		String subStr = strHandler("开店就用二维火，生意一定更红火", (str) -> str.substring(2, 5));
		System.out.println(subStr);
	}
	
	//需求：用于处理字符串
	public String strHandler(String str, Function<String, String> fun){
		return fun.apply(str);
	}

5.3、供给型接口。

//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;
	}

5.4、消费型接口。该函数型接口的抽象方法为void。没有返回值。所以一般用在无返回的操作，比如最简单的打印（print）

//Consumer<T> 消费型接口 :
	@Test
	public void test1(){
		happy(10000, (m) -> System.out.println("程序员要注意养生，每礼拜洗脚消费：" + m + "元"));
	} 
	
	public void happy(double money, Consumer<Double> con){
		con.accept(money);
	}

函数式接口可以干什么？

到这里，你应该也大致明白了什么是函数式接口以及函数式接口可以干什么了。

一般函数式接口同lambda表达式一起使用，它允许你直接以内联的形式为函数式接口的抽象方法提供实现，并把整个表达式作为函数式接口的实例。（具体说来，是函数式接口一个具体实现的实例）。用匿名内部类也可以完成同样的事情，只不过比较笨拙。

水平有限，如有哪些地方有所错误的地方欢迎指正。