函数式接口

小灰灰 2023-01-02 12:22 202阅读 0赞

# 函数式接口 #

## 概述： ##

有且只有一个抽象方法的接口就是函数式接口 jdk中熟悉的函数式接口 ：Runnable

## 注解： ##

@FunctionalInterface

定义函数接口的时候需要在接口上面增加这个注解，方便编译的时候判断该接口是不是函数式接口

## 由来： ##

java中想要体现现实数学中的函数式，函数式本质是定义一个运算规则通过运算操作得到的一个数值，Java中单独的数值又不能存在，但是定义规则的时候可以使用接口实现，所以采用接口来定义，但是一个函数式就只能表示一种运算规则，所以定义函数的接口就只能拥有一个抽 象方法来表示数学中的具体的运算规则。java中这种接口出现后遵循普通的接口使用方式，但是由于它是函数式的体现，使用传统的使用方式效率比较慢，不太符合函数式的特点，所以就出现了lambda表达式来使用函数式接口提升了效率，也符合函数式的特点

# jdk 内置的函数式接口 #

## 消费型接口：【Consumer】 ##

### accept(T t)： ###

> 消费使用掉任意的一个数据

### 场景： ###

我现在有个资源但是我自己不知道怎么用，找Consumer帮助我们使用掉

### 作用 ###

1、当某个函数可以接收一个数据，并且处理这个数据，处理完之后，不需要返回任何数据，**这个函数需要当作数据进行传递**，就要使用消费型接口  
2、以前只能传递要处理的数据，现在也可以传递处理数据的方式。

**代码示例：**

import java.util.function.Consumer;
    
    public class ConsumerDemo {
        
    	public static void main(String[] args) {
        
    		//现有100元不知道怎么用
    		int salary = 100;
    		//想要消费100，电泳useSalary方法
    		useSalary(salary, (Integer a) -> {
        
    			System.out.println("用" + a + "吃顿饭");
    		});
    	}
    	
    	public static void useSalary(int salary, Consumer<Integer> c) {
        
    		System.out.println("我有" + salary + "元");
    		//接口调用消费功能，消费salary
    		c.accept(salary);
    		System.out.println(salary + "已经消费完");
    	}
    
    }
    
    结果：
    我有100元
    用100吃顿饭
    100已经消费完

## 供给型接口：【Supplier】 ##

### T get()： ###

> 提供返回任意类型数据的规则

### 使用场景： ###

想要使用一个数据自己没有也不知道如何获取，找Supplier接口，可以返回一个想要的数据

### 作用： ###

1、如果需要定义函数，可以生产一个需要的数据，这个**函数需要当作数据来进行传递**，那么就可以使用供给型接口  
2、以前我们只能传递数据，现在可以传递生产数据的方式

**代码示例：**

import java.util.function.Supplier;
    
    public class SupplierDemo2 {
        
    	public static void main(String[] args) {
        
    		
    		//Supplier<String> s = () -> {return "java";};
    		//调用方法
    		//supp(s);
    		supp(() -> {
        return "java";});
    	}
    	
    	public static void supp(Supplier<String> s) {
        
    		
    		String str = s.get();
    		
    		System.out.println(str + "是最好的语言");
    	}
    
    }
    
    输出结果：
    java是最好的语言

## 函数型接口【转换型接口】Function<T,R> ##

### R apply(T t)： ###

> 抽象方法提供把一个数据类型转换为另一个数据类型规则

### andThen(Function f)： ###

> 默认方法

> **连接两个Function对象的不同转换规则，执行的时候按照连接顺序依次执行**

### 注意事项： ###

1、同时调用andThen方法和apply方法时andThen方法必须在前apply方法必须在最后

2、多个andThen方法连接转换规则时，上一个规则的转换结果的数据类型一定要和下一个规则要转换的数据类型一致

**代码示例1：**

import java.util.ArrayList;
    import java.util.List;
    import java.util.function.Function;
    
    public class FunctionDemo {
        
    	
    	public static void main(String[] args) {
        
    		//定义数组
    		Integer[] arr = {
        10,20,30,40};
    		// lambda表达式 【Function接口的实现类对象】可以传递转换规则进来
    		// 方法借助于Function接口完成数组的转换集合的过程
    		List<Integer> list2 = exChange(arr, (m)->{
        
    			List<Integer> list = new ArrayList<Integer>();
    			for (Integer it : arr) {
        
    				list.add(it);
    			}
    			return list;
    		});
    		
    		System.out.println(list2);
    	}
    	
    
    	public static List<Integer> exChange(Integer[] arr, Function<Integer[], List<Integer>> f) {
        
    		//函数式接口 转换数据
    		List<Integer> list = f.apply(arr);
    		//返回数据
    		return list;
    	}
    	
    
    }

**代码示例2**

import java.util.ArrayList;
    import java.util.List;
    import java.util.function.Function;
    
    /**
     *	将Integer类型数组先转换为list集合，在转换为字符串
     */
    public class FunctionDemo2 {
        
    	public static void main(String[] args) {
        
    		Integer[] arr =  {
        10,20,30,40,50};
    		
    		String str = fun(arr, (a)->{
        
    			//创建集合对象
    			List<Integer> list = new ArrayList<Integer>();
    			//遍历数组添加进集合
    			for (Integer num : arr) {
        
    				list.add(num);
    			}
    			return list;
    		},(n) ->{
        
    			return n.toString();
    		});
    		
    		System.out.println(str);
    	}
    	
    //	public static List<Integer> fun(Integer[] arr, Function<Integer[] , List<Integer>> f) {
        
    //		
    //		List<Integer> list = f.apply(arr);
    //		
    //		return list;
    //	}
    //	public static String fun(List<Integer> list, Function<List<Integer> , String> f) {
        
    //		
    //		String str = f.apply(list);
    //		
    //		return str;
    //	}
    	public static String fun(Integer[] arr, Function<Integer[] , List<Integer>> f, Function<List<Integer> , String> f2) {
        
    		
    		//List<Integer> list = f.apply(arr);
    		//String str = f2.apply(list);
    			
    		String str = f.andThen(f2).apply(arr); //效果和上边一样
    		
    		return str;
    	}
    
    }

## 断言型接口【Predicate】 ##

### 作用 ###

1、如果需要定义一个函数，接收一个数据，判断数据是否合法，返回boolean结果，就可以使用断言型接口  
2、以前我们只能传递过滤好的而数据，而现在即可以传递原始数据，也可以传递过滤条件

### boolean test(T t)：抽象方法 ###

> 判断对给定的数据是否符合某个条件

### Predicate and (Predicate p)： ###

> 把两个断言型接口的判断规则判断的结果进行逻辑且【与】的处理

### Predicate or (Predicate p)： ###

> 把两个断言型接口的判断规则判断的结果进行逻辑或的处理

### Predicate negate()： ###

> 取判断结果的反向结果

**代码示例1**：

import java.util.function.Predicate;
    
    public class PredicateDemo {
        
    	public static void main(String[] args) {
        
    		//通过Predicate判断一个字符串是不是以"str" 开头
    		boolean boo2 = isElement("abcdef", (a)->{
        
    			boolean boo = a.startsWith("str");
    			return boo;
    		});
    		
    		System.out.println(boo2);
    	}
    
    	public static boolean isElement(String str, Predicate<String> s) {
        
    		return s.test(str);
    	}
    }

**代码示例2**

import java.util.function.Predicate;
    
    public class PredicateDemo2 {
        
    	// 有一个方法判断一个字符串是不是以"str" 开头 但是自己不会判断 找Predicate判断
    	public static  boolean isElement(String str,Predicate<String> p) {
        
    		// return p.test(str);
    		return p.negate().test(str);
    	}
    	
    	public static  boolean isElement(String str,Predicate<String> p1,Predicate<String> p2) {
        
    		// return p.test(str);
    		// return p1.and(p2).negate().test(str);
    		return p1.or(p2).negate().test(str);
    	}
    	
    	public static void main(String[] args) {
        
    		// 别人要使用isElement
    		boolean b = isElement("fjkdaljfjea", (s)->{
        
    			return s.startsWith("a");
    		});
    		
    		System.out.println(b);// false  [取反]true
    		
    		boolean c = isElement("fjkdaljfjea",s-> s.startsWith("a"),s-> s.endsWith("a"));
    		System.out.println(c);// true[与关系]   false 【或】
    		 
    	}
    }

## 总结： ##

可以把函数式接口当做一个数值进行传递，但是函数式接口中定义的对数据一种操作规则， 所以传递是一种规则【当做方法的参数】实现了数据传递到规则传递的转换