快速学习Java8新特性第三讲——函数式接口

心已赠人 2023-06-19 11:09 9阅读 0赞

不知你有没有想过，Lambda表达式默认找的是接口中哪个抽象方法来实现的呢？假设说接口中有多个抽象方法，Lambda表达式默认实现的是哪个呢？你可以带着这个疑问开始本讲的阅读之旅。

# 函数式接口是什么？ #

Lambda表达式可以很简洁的代替匿名内部类的代码编写，而匿名内部类往往是实现某一接口的一个抽象方法。所以，在使用Lambda表达式时，我们最应该关注的应该是接口的抽象方法，并且这个接口还必须只有一个抽象方法。我们称这种只有一个抽象方法的接口为"函数式接口"，而Lambda表达式恰好需要一个函数式接口的支持。  
知道了函数式接口是什么之后，我们就可以通过Lambda表达式来创建这种接口的对象了（若Lambda表达式抛出一个受检异常，那么该异常需要在目标接口的抽象方法上进行声明）。我们还可以在任意函数式接口上使用@FunctionalInterface注解，这样做可以检查它是否是一个函数式接口，同时javadoc也会包含一条声明，说明这个接口是一个函数式接口。下面我就用一个例子来说明一下函数式接口的用法，即简单使用一下Lambda表达式来对一个数进行运算（不管啥运算）。  
首先，创建一个函数式接口，例如MyFun.java。

package com.meimeixia.java8;
    
    @FunctionalInterface //说明这个接口必须是一个函数式接口，里面只能有一个抽象方法
    public interface MyFun { 
    	
    	public Integer getValue(Integer num);
    
    }

然后，编写一个对一个数进行运算的方法，并测试一把！  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]  
为了将Lambda表达式作为参数进行传递，接收Lambda表达式的参数类型必须是与该Lambda表达式兼容的函数式接口的类型。

## 练习 ##

了解了函数式接口之后，下面我们来做三道练习题，以巩固目前为止所学的知识。先看练习题一，调用Collertions.sort()方法，通过定制排序比较两个Employee（先按年龄比，年龄相同再按姓名比），并使用Lambda表达式作为参数传递。

package com.meimeixia.exer;
    
    import java.util.Arrays;
    import java.util.Collections;
    import java.util.List;
    
    import org.junit.Test;
    
    import com.meimeixia.java8.Employee;
    
    public class TestLambda { 
    	
    	List<Employee> emps = Arrays.asList(
    			new Employee(100, "张三", 18, 9999.99),
    			new Employee(101, "李四", 38, 5555.99),
    			new Employee(102, "王五", 50, 6666.66),
    			new Employee(103, "赵六", 16, 3333.33),
    			new Employee(104, "田七", 8, 7777.77)
    	);
    
    	/** * 练习一、调用Collertions.sort()方法，通过定制排序比较两个Employee（先按年龄比，年龄相同再按姓名比），使用Lambda表达式作为参数传递 */
    	@Test
    	public void test1() { 
    		Collections.sort(emps, (e1, e2) -> { 
    			if (e1.getAge() == e2.getAge()) { 
    				return e1.getName().compareTo(e2.getName());
    			} else { 
    				return Integer.compare(e1.getAge(), e2.getAge());
    			}
    		});
    		
    		for (Employee emp : emps) { 
    			System.out.println(emp);
    		}
    	}
    
    }

其中，Employee实体类的内容如下：

package com.meimeixia.java8;
    
    public class Employee { 
    
    	private int id;
    	private String name;
    	private int age;
    	private double salary;
    
    	public Employee() { 
    
    	}
    
    	public Employee(int id, String name, int age, double salary) { 
    		super();
    		this.id = id;
    		this.name = name;
    		this.age = age;
    		this.salary = salary;
    	}
    	
    	public int getId() { 
    		return id;
    	}
    
    	public void setId(int id) { 
    		this.id = id;
    	}
    
    	public String getName() { 
    		return name;
    	}
    
    	public void setName(String name) { 
    		this.name = name;
    	}
    
    	public int getAge() { 
    		return age;
    	}
    
    	public void setAge(int age) { 
    		this.age = age;
    	}
    
    	public double getSalary() { 
    		return salary;
    	}
    
    	public void setSalary(double salary) { 
    		this.salary = salary;
    	}
    
    	@Override
    	public String toString() { 
    		return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + "]";
    	}
    
    }

运行TestLambda类中的test1测试方法，你便可以在Eclipse控制台中看到如下打印信息。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]  
如果我们想按照年龄逆序排序呢？那么该怎么办？很简单，将test1测试方法修改成下面这个样子即可。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 2]  
运行以上test1测试方法，这时，你便可以在Eclipse控制台中看到如下打印信息了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 3]  
再来看一下练习题二，

1.  ①声明一个函数式接口，并在接口中声明一个抽象方法，即`public string getValue(String str);`；
2.  ②声明一个TestLambda类，在类中编写一个方法，该方法使用接口作为参数，然后将一个字符串转换成大写，并作为方法的返回值返回；
3.  ③再将一个字符串的第2个和第4个索引位置进行截取子串。

为了解决该练习题，首先，要创建如下一个函数式接口。

package com.meimeixia.exer;
    
    @FunctionalInterface
    public interface MyFunction { 
    
    	public String getValue(String str);
    	
    }

然后，在TestLambda类中编写一个用于处理一个字符串的方法，接着再对该方法进行测试。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 4]  
最后，看一下练习题三，

1.  ①声明一个带两个泛型的函数式接口，泛型类型为`<T，R>`，其中T为参数，R为返回值；
2.  ②接口中声明对应抽象方法；
3.  ③在TestLambda类中声明一个方法，使用接口作为参数，计算两个long型参数的和；
4.  ④再计算两个long型参数的乘积。

为了解决该练习题，首先，要创建如下一个函数式接口。

package com.meimeixia.exer;
    
    @FunctionalInterface
    public interface MyFunction2<T, R> { 
    	
    	public R getValue(T t1, T t2);
    	
    }

然后，在TestLambda类中编写一个对两个Long型数据进行处理的方法，接着再对该方法进行测试。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 5]  
经过以上三道练习题的磨练，你有没有什么感想呢？现在你应该体会到了一个非常不好的地方，那就是使用Lambda表达式往往离不开函数式接口的支持，但是如果每次使用Lambda表达式都要自定义一个函数式接口的话，那么Lambda表达式就没有完全起到简化代码的作用了，相反还变得很麻烦了。实际上没有关系，Java 8给我们内置了通常使用到的函数式接口，这些接口不需要我们自己建，人家Java 8已经给我们提供好了。

# Java 8中内置的四大核心函数式接口 #

Java 8中内置了一些函数式接口来供开发者们调用，这样就不需要开发者们重复定义函数式接口了。Java 8中提供了四大核心函数式接口，它们分别是：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 6]  
下面我会一一介绍以上Java 8中提供的四大核心函数式接口。

## `Consumer<T>`：消费型接口 ##

Java 8中消费型接口的定义如下图所示。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 7]  
何谓消费呢？消费就是有去无回。通过观察以下例子，你就应该知道该接口该如何使用了吧！

//Consumer<T>：消费型接口，消费就是有去无回
    @Test
    public void test1() { 
    	happy(10000, (m) -> System.out.println("咱们东哥喜欢大学生，每次消费：" + m + "元"));//使用Lambda表达式对接口进行实现
    }
    
    public void happy(double money, Consumer<Double> con) { 
    	con.accept(money);
    }

## `Supplier<T>`：供给型接口 ##

Java 8中供给型接口的定义如下图所示。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 8]  
供给型接口主要就是给你产生一些对象，并返回给你。例如，产生一些指定个数的整数，并放入集合中。

//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<Integer>();
    	for (int i = 0; i < num; i++) { 
    		Integer n = sup.get();
    		list.add(n);
    	}
    	return list;
    }

## `Function<T, R>`：函数型接口 ##

Java 8中函数型接口的定义如下图所示。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 9]  
如果你想要处理字符串的话，那么就可以使用该接口了。你可以在类中编写一个专门用于处理字符串的方法，然后再对该方法进行测试。

@Test
    public void test3() { 
    	String newStr = strHandler("\t\t\t 我是美美侠啊 ", (str) -> str.trim());
    	System.out.println(newStr);
    	
    	String subStr = strHandler("我是美美侠啊", (str) -> str.substring(2, 5));
    	System.out.println(subStr);
    }
    
    //Function<T, R>：函数型接口
    //需求：专门用于处理字符串
    public String strHandler(String str, Function<String, String> fun) { 
    	return fun.apply(str);
    }

## `Predicate<T>`：断言型接口 ##

Java 8中断言型接口的定义如下图所示。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 10]  
断言型接口可以用于做一些判断操作，例如处理字符串时，将满足指定条件的字符串放入集合中去。

@Test
    public void test4() { 
    	List<String> list = Arrays.asList("Hello", "meimeixia", "Lambda", "www", "ok");
    	List<String> strList = filterStr(list, (s) -> s.length() > 3);
    	for (String str : strList) { 
    		System.out.println(str);
    	}
    }
    
    //Predicate<T>：断言型接口，用于做一些判断操作
    //需求：还是处理字符串，将满足指定条件的字符串放入集合中去
    public List<String> filterStr(List<String> list, Predicate<String> pre) { 
    	List<String> strList = new ArrayList<String>();
    	for (String str : list) { 
    		if (pre.test(str)) { 
    			strList.add(str);
    		}
    	}
    	return strList;
    }

# 其他接口 #

除了Java 8中内置的四大核心函数式接口，还有一些其他的接口，如下列表所示。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 11]  
从中可以看出很多接口都是Java 8中内置的四大核心函数式接口的子接口。既然我们都已经会使用四大核心函数式接口了，那这些子接口还不是分分钟就会用了。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191206110538704.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2019120611054639.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191206110555719.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20191206110602155.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20191206110609780.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20191206110618205.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/2019120611565043.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/2019120612212065.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/2019120612212843.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20191206122132588.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20191206122145564.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 11]: https://img-blog.csdnimg.cn/20191206140934145.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9saWF5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70