java常用函数式接口 /Supplier供给型接口/Consumer消费者接口/Predicate断言型接口/Function函数接口

函数式接口在Java中是指：有且仅有一个抽象方法的接口。

函数式接口，适用于函数式编程场景的接口。
而Java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。

格式

// 只要确保接口中有且仅有一个抽象方法即可：
修饰符 interface 接口名称 {
public abstract 返回值类型 方法名称(可选参数信息);
// 其他非抽象方法内容
//由于接口当中抽象方法的 public abstract 是可以省略的，所以定义一个函数式接口很简单：
}

常用函数式接口

• Supplier接口：
• Consumer接口
• Predicate接口
• Function接口

接下来，我们一一介绍：

Supplier供给型接口：

Supplier接口是不需要传入值，返回一个泛型类T

Consumer消费者接口

Consumer接口是传入一个泛型类T，无返回值

Predicate断言型接口

Predicate接口是传入一个泛型类T，返回要一个布尔类型的值

Function函数接口

Function接口是传入一个泛型类T，返回一个泛型类R

最后上代码：

public class LambdaTest {
     
	
	//Predicate : 断言型接口
	@Test
	public void test4(){
     
		List<String> list = Arrays.asList("hello", "atguigu", "world", "aaa", "ok");
		
		List<String> newList = filterStr(list, (s) -> s.length() > 3);
		
		newList.forEach(System.out::println);
	}
	
	public List<String> filterStr(List<String> list, Predicate<String> pre){
     
		List<String> newList = new ArrayList<>();
		
		for (String s : list) {
     
			if(pre.test(s)){
     
				newList.add(s);
			}
		}
		
		return newList;
	}
	
	
	//Function : 函数型接口
	@Test
	public void test3(){
     
		String newStr = strHandler("abcdef", (s) -> s.toUpperCase());
		System.out.println(newStr);
	}
	
	//字符串转大写
	public String strHandler(String str, Function<String, String> fun){
     
		return fun.apply(str);
	}
	
	//Supplier : 供给型接口
	@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 count, Supplier<Integer> sup){
     
		List<Integer> list = new ArrayList<>();
		
		for (int i = 0; i < count; i++) {
     
			Integer n = sup.get();
			list.add(n);
		}
		
		return list;
	}
	
	//Consumer : 消费型接口
	@Test
	public void test1(){
     
		
		int num = 0;//jdk1.8前，若局部内部类中使用的同级别的局部变量，必须使用 final修饰，jdk1.8，默认使用 final
		
		Consumer<Double> con = new Consumer<Double>() {
     

			@Override
			public void accept(Double t) {
     
				System.out.println(num);
			}
		};
		
		
		
		happy(10000, (h) -> System.out.println("明州刷了大宝剑, 消费" + h + "元" + num));
	}
	
	public void happy(double money, Consumer<Double> con){
     
		con.accept(money);
	}

}

上几个demo：

题目

给定一个数字列表，如何返回一个由每个数的平方构成的列表呢？
例如，给定【1，2，3，4，5】， 应该返回【1，4，9，16，25】。

Leetcode : IO流 / lambda表达式
Diffculty：java8特性

思路分析：

首先要打开流，处理流，结束流

打开流，就是.stream（）
打开流之后我们处理list流中的数据要把list中的所有数据进行平方，那我们对数据平方就是，处理流。
那打开流之后得到的是一个Stream类，这个类有一个map方法，可以对lit中的每一个数据做你想做的事情。那我们就调用.map（）那.map的（）中就是写你想做的事情，里面是传入，四个典型的函数式接口中的Function接口
因为我们要对list中的数据做平方，所以要传入一个值，然后对这个值做平方操作，然后操作完再返回给我们。

那接下来就可以写函数值接口的lambda表达式（x） -> // 一顿操作然后返回这个值，就可以写成 .map（(x) -> x * x）写到这里就做了个处理流~

.toList()是Collector帮助类Collectors 的方法

我们首先是要收集数据，那.map完还是一个流，这个流中有一个.collect()方法，就是收集的方法

那collect方法中需要接收一个 Collector接口的实现
然后我们需要一个list方法collect（）方法中用来保存我们处理完的数据，那！要么我们就建一个list，放进到（）中取，要么我们就利用Collectors 这个帮助类的.toList返回一个list

上demo（写的有点多了）

public class ReturnNumRquare {
     
	public static void main(String[] args) {
     
		List<Integer> list = Arrays.asList(1,2,3,4,5);
		
		List<Integer> list2 = list.stream()
			.map((x) -> x * x)
			.collect(Collectors.toList());
		
		list2.forEach(System.out::println);
	}

}

文章持续更新：欢迎各位小伙伴关注我的公众号：菜丸的程序屋。希望将我的不足之处给予指点，谢谢大家。喜欢Java，热衷学习的小伙伴可以加我微信: CaiWan_Y