java-函数式接口

Function接口
	根据一个类型的数据的到另一类型的数据，前者称之为前置条件，后者称之为后置条件
	这个接口有两个泛型，可以K这个类型转换为L这个类型
	抽象方法： apply
		R apply(T t) 根据类型T的参数获取类型R的结果
		将String类型转换为Integer类型
		=====================

public class FunctionCls {
   

	// 定义一个方法，方法的参数传递一个字符串类型的整数
	// 方法的参数传递一个function接口
	// 泛型 apply 把String -> Integer
	public static void change(String s, Function<String, Integer> fun) {
   
		Integer in = fun.apply(s);// 把字符串的s转换为Integer类型
		System.out.println(in);
	}

	public static void main(String[] args) {
   
		// 定义字符串
		String s = "1323455";
		// 调用change方法传递字符串类型的整数，和lambda表达式
		change(s, (String str) -> {
   
			// 把字符串转换为 Integer类型的整数返回
			return Integer.parseInt(str);
		});

	}

}

---

import java.util.function.Function;

/*
 * 	Function接口中的默认方法andThen,用来组合操作
 * 		案列： 把String的123转换为Integer类型
 * 			 把转换后的结果加上10，再把增加之后Integer类型的数据转换为String类型
 * 		分析： 一共转换了两次
 * 			 类型转换
 * 		可以 使用andThen方法把两次这组合在一起	
 */
public class FunctionAndThen {
   
	//定义一个方法，参数传递字符串类型的整数
	//参数再传递两个Function接口
	public static void change(String s, Function<String,Integer> fun1,Function<Integer, String> fun2) {
   
		String ss = fun1.andThen(fun2).apply(s);
		System.out.println(ss);
	}
	public static void main(String[] args) {
   
		//定义一个字符串 类型 的整数、
		String s = "123";
		//调用change传递字符串和两个Lambda表达式
		//只有一行参数，数据类型和括号 可以去掉，只有一行代码return和大括号可以 去掉。
		change(s,(String str)->{
   
			//把字符串转换为 整数，结果增加1
			return Integer.parseInt(str)+10;
		},(Integer i)->{
   
			//把整数转换为 字符串
			return i+"";
		});
	}
}

------------------------------
import java.util.function.Function;

/*
 * 	使用function进行函数自定义模型的拼接：
 * 		
 */
public class FunctionTest {
   
	//定义一个方法参数传递包含姓名和年龄的字符串，参数 再传递三个function接口用于类型转换
	public static int change(String s,Function<String,String> fun1,Function<String, 
			Integer> fun2, Function<Integer, Integer> fun3) {
   
		//使用andThen把莎安娜个转换组合到一起
		return fun1.andThen(fun2).andThen(fun3).apply(s);
	}
	public static void main(String[] args) {
   
		//定义一个字符串，
		String str = "赵丽颖,20";
		//调用change，参数传递字符串和三个Lambda表达式
		int end = change(str,(String s)->{
   
			return s.split(",")[1];
		},(String s)->{
   
			return Integer.parseInt(s);
		},(Integer i)->{
   
			return i + 10;
		});
		System.out.println(end);
	}
}

===============

函数式接口： 有且仅有一个抽象方法的接口，叫做函数式接口

Java中函数式就是Lambda
当然接口中可以办函其他的方法（默认，静态，私有）

有些场景的代码执行之后，结果不一定会使用，从而造成性能的浪费而Lambda表达式是延迟执行的，这正好可以解决这种问题
	日志可以帮助我们快速定位问题，记录程序运行过程中的情况，以便项目的监控和优化。

函数式接口的使用：
	一般可以作为方法的参数和返回值类型

===================

public class HanShuShiJieKou {
   
	//定义一个方法，参数是用参数是用函数式接口，MyFunctionalInterface
	public static void show(MyFunctionalInterface myInter) {
   
		myInter.method();
	}
	public static void main(String[] args) {
   
		//调用show方法的参数，传递接口的实现类
		show(new MyFunctionalInterfaceImpl());
		//传递接口的匿名内部类
		show(new MyFunctionalInterface() {
   
			
			@Override
			public void method() {
   
				// TODO Auto-generated method stub
				System.out.println("匿名内部类重写接口中的抽象方法");
			}
		});
		
		//调用show()方法，方法的参数是一个函数式接口所以我们可以Lambda表达式
		show(()->{
   
			System.out.println("使用Lambda表达式，重写接口中的抽象方法");
		});
		//简化，花括号中有且只有一行语句，可以省略掉花括号。
		show(()->System.out.println("简化书写的格式"));
	}
}

----------------------------