Lambda表达式、函数式接口

一 Lambda表达式

1.1 概述

         Lambda表达式是一种没有名字的函数,也可称为闭包，是Java 8 发布的最重要新特性。

本质上是一段匿名内部类，也可以是一段可以传递的代码。

还有叫箭头函数的...

1.2 为什么使用Lambda表达式

Lambda表达式就是一个匿名内部类的简写方式

使程序更加简洁清晰,编程效率也得到了提高

1.3 常规遍历 实现类(匿名内部类) Lambda表达式比较

package _01_Lambda;


public class _01_Lambda {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] arr={1,2,3,4};
//		//增强for循环
//		 for (int i : arr) {
//				 System.out.println(i);
//				 }
        //1=========
        //2=========
        //3=========
        //4=========
//		// 1 实现类
//		forEach(arr, new A());
		//2 匿名内部类
		forEach(arr, new Array() {

			@Override
			public void m1(int i) {
				// TODO Auto-generated method stub
				System.out.println(i+"=========");
			}
		});
		//Lambda表达式
		forEach(arr, (i)->System.out.println(i+"+++++++++"));
	}
	//封装的功能,完成遍历操作,但是需要传递数组和要做的事情
	//该方法只是帮我们遍历而已
	public static void forEach(int[] arr,Array array){
		for (int i : arr) {
			array.m1(i);
		}
	}
}

//封装要做的事
interface  Array {
	void m1(int i);
}

class A implements Array {

	@Override
	public void m1(int i) {
		// TODO Auto-generated method stub
			System.out.println(i + "---");
	}
	
}

1.4 语法结构

可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。

可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。

可选的大括号：如果主体包含了一个语句，就不需要使用大括号。

如果不写{}  return 不能写  分号不能写

可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值

如果只有一条语句,并且是返回值语句,就可以不写return 不写 {}  

如果写上{}  就必须写return 和 ;

如果有 多条语句,必须写{}  return 和 ;  也必须写

eg:

1 不需要参数,返回值为5

()-> 5

2 接收一个参数(数字类型),返回其2倍的值  

x -> x*2

3 接受2个参数(数字),并返回他们的差值  

(x,y)-> x-y

二 函数式接口

2.1 概述

英文称为Functional Interface  

其本质是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。

核心目标是为了给Lambda表达式的使用提供更好的支持，进一步达到函数式编程的目标，可通过运用函数式编程极大地提高编程效率。

其可以被隐式转换为 lambda 表达式。

2.2 特点

函数式接口是仅制定一个抽象方法的接口

可以包含一个或多个静态或默认方法

专用注解即@FunctionalInterface 检查它是否是一个函数式接口，也可不添加该注解

// 函数式接口
@FunctionalInterface
interface MyFunctionInter {
	void printMessage();
}

如果有两个或以上 抽象方法,就不能当成函数式接口去使用,也不能添加@FunctionalInterface这个注解

如果只有一个抽象方法,那么@FunctionalInterface注解 加不加 都可以当做函数式接口去使用

2.3 构造方法

2.3.1 无参构造

//无参构造
		Supplier<Object> objSu=Object::new;
		System.out.println(objSu.get());

2.3.2 有参构造

//有参构造
		Function<String, Integer> function=Integer::new;
		System.out.println(function.apply("123"));//结果为整数123

2.4 JDK自带常用的函数式接口

2.4.1 Supplier<T>接口

Supplier<T>接口    代表结果供应商,所以有返回值,可以获取数据

有一个get方法,用于获取数据

package _02_Functions;

import java.util.function.Supplier;

/**
 * Supplier 代表供应商,有返回值,可以获取数据使用
 * 提供一个get方法
 * @author 黄泽锋
*@author 2021年11月2日下午9:03:14
 *
 */
public class _02_Functions {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String string = "张三";
		String result=	 getResult(()->"我叫"+string);
		System.out.println(result);//我叫张三
	}
public static  String getResult(Supplier<String> supplier){
	return supplier.get();
	
}
}

2.4.2 Consumer<T>接口

Consumer<T>接口    消费者接口所以不需要返回值

有一个accept(T)方法,用于执行消费操作,可以对给定的参数T 做任意操作

package _02_Functions;

import java.util.function.Consumer;

public class _01_Functions {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] arr = { 1, 2, 3, 4 };

		// 3 lambda表达式
		forEach(arr, (i) -> System.out.println(i + "++++++++++"));
	}
	// 封装的功能,完成遍历操作,但是需要传递数组,和要做的事
		// 该方法只是帮我们遍历而已
public static void forEach(int[] arr,Consumer<Integer> c){
	for(int i:arr){
		c.accept(i);
	}
}

}

2.4.3 Function<T,R>接口

Function<T,R>接口  表示接收一个参数并产生结果的函数

顾名思义,是函数操作的

有一个R apply(T)方法,Function中没有具体的操作，具体的操作需要我们去为它指定，因此apply具体返回的结果取决于传入的lambda表达式

package _02_Functions;

import java.util.function.Function;
/**
 * Function : 有参有返回值,提供了 apply方法
 */
public class _03_Functions {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String string = "123";
		int result = m1(string,s->Integer.parseInt(s)*10);
		System.out.println(result);
	}
	public static Integer m1(String string ,Function<String, Integer> fun){
		return fun.apply(string);
	}
}

2.4.4 Predicate<T>接口

Predicate<T>接口   断言接口

就是做一些判断,返回值为boolean

有一个boolean test(T)方法,用于校验传入数据是否符合判断条件,返回boolean类型

public class _06_JdkOwn_04 {
	// 自定义方法,并且 Predicate 接收String字符串类型
	public static void call(Predicate<String> predicate, String isOKMessage) {
		boolean isOK = predicate.test(isOKMessage);
		System.out.println("isOK吗：" + isOK);
	}

	public static void main(String[] args) {
		// 传入的参数
		String input = "ok";
		call((String message) -> {
			// 不区分大小写比较,是ok就返回true,否则返回false
			if (message.equalsIgnoreCase("ok")) {
				return true;
			}
			return false;
		}, input);
	}
}

三 方法引用和构造器调用  

3.1 对象引用::成员方法名

package _03_FunCall;

import java.util.function.Supplier;

/**
 * 对象引用::成员方法名
 * 要求:需要根据调用的方法的入参和出参去选择对应的函数式接口才行
 * @author 黄泽锋
*@author 2021年11月2日下午9:11:35
 *
 */
public class _01_FunCall {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Integer i1 = new Integer(123);
		// 常规lambda写法
		Supplier<String> su = () -> i1.toString();
		System.out.println(su.get());
		// 方法引用写法
		Supplier<String> su1=i1::toString;
		System.out.println(su1.get());
	}

}

3.2  类名::静态

package _03_FunCall;

import java.util.function.BiFunction;
import java.util.function.Function;

/**
 * 类名::静态
 * @author 黄泽锋
*@author 2021年11月2日下午9:15:48
 *
 */
public class _02_FunCall {
public static void main(String[] args) {
	Function<String, Integer> fun = Integer::parseInt;
	System.out.println(fun.apply("123"));
	fun = new Function<String, Integer>() {
		@Override
		public Integer apply(String t) {
			// TODO Auto-generated method stub
			return null;
		}
	};
	fun = x -> Integer.parseInt(x);
	fun = Integer::parseInt;
	// 前两个是入参,第三个是返回值
	BiFunction<Integer, Integer, Integer> bif = Integer::max;
	System.out.println(bif.apply(123, 323));
	test((B x) -> System.out.println(x));
}
public static void test(A a) {

}
}
interface A {
	public void m1(B b);
}

class B {

}

3.3 类名::成员方法名

package _03_FunCall;

import java.util.function.BiPredicate;

/**
 * 类名::成员方法名
 * @author 黄泽锋
*@author 2021年11月2日下午9:19:39
 *
 */
public class _03_FunCall {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BiPredicate<String, String> bp = String::equals;
		System.out.println(bp.test("abc", "abc"));
	}

}