JavaSE基础day26 lambda表达式、消费型接口Consumer、供给性接口Supplierr
作者：互联网
一、 Lambda表达式
2.1 概述
1. 本质：
Lambda表达式是java对数学函数表达式的一种体现形式，本质是一个值，在java中主要是体现在对特殊的匿名内部类对象的一种表示，代表匿名内部类的对象
2. 使用前提：
函数式接口：只有一个抽象方法的接口(可以有其他非抽象方法)
可以在接口声明之上, 使用注解: @FunctionalInterface标识验证这个函数式接口
3. 好处：
对匿名内部类对象的格式简化，大幅提升开发效率
注: Lambda表达式代表的匿名内部类的对象，在编译的时候不需要生成对应类的字节码文件，而匿名内部类在编译的时候需要编译生成对应的字节码文件，所以Lambda表达式可以提高效率
2.2 格式详解
1. 格式：
(参数列表) -> {方法体}
2. 详细说明：
(1) (参数列表): 表示要实现的接口中，抽象方法的参数
(2) -> : 箭头运算符，或者称为Lambda运算符，用于分隔前后两部分
(3) {方法体}: 也称为Lambda体，表示重写抽象方法的具体实现
@FunctionalInterface
public interface MyFunctionalInterface {
public abstract void fun();
}
class Test{
public static void main(String[] args) {
// 1. 使用匿名内部类实现MyFunctionalInterface接口
new MyFunctionalInterface(){
@Override
public void fun() {
System.out.println("我是重写的fun,匿名内部类对象方法");
}
}.fun();
// 2. 使用lambda表达式实现MyFunctionalInterface接口
// (参数列表)->{方法体}
MyFunctionalInterface my = ()->{ System.out.println("lambda表达式重写的fun"); };
my.fun();
}
}
2.3 特殊情况
1. 有且只有一个参数，可以省略小括号
x -> {int result = x * x; System.out.println(x + “的平方为：” + result);}
2. Lambda体只有一句，且没有返回值，可以省略大括号
x -> System.out.println(x * x);
3. Lambda体只有一句，且有返回值，则return和大括号可以一起省略
(x, y) -> {return x + y;} 等价于 (x, y) -> x + y
注意：要么一起省略，要么都不省略
@FunctionalInterface
public interface MyFunctionalInterface {
public abstract void fun();
}
@FunctionalInterface
interface Inter2{
public abstract void print(int n);
}
@FunctionalInterface
interface InterOther{
public abstract boolean equal(double d, double d1);
}
class Test{
public static void main(String[] args) {
// 1. 使用匿名内部类实现MyFunctionalInterface接口
new MyFunctionalInterface(){
@Override
public void fun() {
System.out.println("我是重写的fun,匿名内部类对象方法");
}
}.fun();
// 2. 使用lambda表达式实现MyFunctionalInterface接口
// (参数列表)->{方法体}
MyFunctionalInterface my = ()->{ System.out.println("lambda表达式重写的fun"); };
my.fun();
// 3. 使用lambda表达式实现参数列表只有一个的抽象方法
Inter2 i2 = (x) -> {
for(int i = 1; i <= x; i++){
System.out.println(i);
}
};
i2.print(5);
// 特殊情况1: 如果使用lambda表达式作为一个函数式接口的实现类对象, 需要实现的唯一抽象方法
// 参数列表只有一个参数, 那么lambda表达式的小括号可以省略
Inter2 i3 = n -> {
System.out.println(n);
};
i3.print(8);
// 特殊情况2: 如果lambda表达式实现的抽象方法对应的方法体逻辑只有一句,并且没有返回值结果
// 那么大括号可以省略
Inter2 i4 = x -> System.out.println("x的值为:" + x);
// 4. 使用lambda变道时实现参数列表有多个,有返回值抽象方法
// 特殊情况3: 如果lambda表达式实现的抽象方法有返回值结果,并且逻辑只有一句,这一句逻辑正好对应方法
// 的返回值, 那么return和大括号可以同时省略
InterOther other = (x,y)->{return x == y;};
System.out.println(other.equal(5.6,5.7));// false
InterOther other3 = (x,y) -> x==y;
System.out.println(other3.equal(4.1,4.1));// true
}
}
二 、 函数式接口
2.1 概述
1、定义：如果在接口中，只有一个抽象方法，那么这个接口就是函数式接口,比如：jdk中熟悉的函数式接口 ：Runnable
2、格式说明：
使用注解来检查当前接口是否是一个函数式接口
@FunctionalInterface
如果不是函数式接口，则编译报错
3、理解：
(1) 函数：想表达的是一个方法的内容，由于方法不在任何类中，所以称为函数
(2) 函数式接口：其实想表达的就是一个抽象函数的声明
4、作用：
使用函数式接口表达函数的声明；使用函数式接口的实现类对象表达函数的实现
5、使用原因：
Java中不支持将函数作为一个数据，也就不能将这个函数进行各种传递，也就不能作为对象的成员变量存在
只能在方法外加一层接口的声明，将来可以传递方法所在接口的实现类对象，来间接的传递方法实现内容
举例 : 客户要求定义出一个方法功能, 对两个整数进行任意操作
1) 两数求和
2) 两数求差
3) 两数乘积 * 2
4) ... 无数需求, 都需要在同一个方法中完成
public int useTwoInt(int x, int y, 对于x和y两数的操作思想,这个思想可以是一个抽象方法){
}
2.2 常用内置函数式接口
1、说明：
Java8中提供了一些常用的函数式接口，在使用类似功能的时候，不需要额外定义接口，直接使用jdk中提供的即可
2、罗列：
Consumer<T>：消费型接口
void accept(T t): 需要传进进来参数，进行消费，没有返回值。【有进无出】
3、 Supplier<T>：供给型接口
T get(): 不需要传递参数，返回创建一个数据的接口 【无进有出】
4、 Function<T, R>：函数型接口
R apply(T t): 需要传递一个参数，把传递进来的参数进行一些操作，然后再返回一个参数【有进有出】
5、 Predicate<T>：断言型接口
boolean test(T t): 需要参数，返回一个boolean类型的值【有进有出，出来的结果一定是boolean类型】
2.3 消费型接口
1、Consumer<T> : 消费型接口
2、抽象方法：void accept(T t) 消费使用掉任意的一个数据
3、作用：
定义一个方法，这个方法需要传递进来数据，还需要传递进来处理这个数据的方式，并且还不需要返回值类型，就可以使用Consumer接口来当做数据处理方式的传递。
有了Consumer接口接口以后，不仅仅可以传递数据，还可以传递消费处理数据的方式。
案例 : 定义出一个方法功能, 客户预计消费500元现金, 每一个客户对于500元的消费都不同, 将客户的消费方式实现出来
1) 客户1 : 花了500元, 买了一把大宝剑
2) 客户2 : 花了500元, 买了一堆化妆品
3) 客户3 : 花了500元, 买了一双球鞋
4) .... 还有无限的客户有不同种消费方式
import java.util.function.Consumer;
public class ConsumerInterfaceUse {
public static void main(String[] args) {
Consumer<Double> con1 = x -> System.out.println("花了" + x + "元买了一把大宝剑");
// 1)客户1 : 花了500元, 买了一把大宝剑
testConsumer(500,con1);
// 2)客户2 : 花了500元, 买了一堆化妆品
Consumer<Double> con2 = x -> {
if(x >= 500){
System.out.println("消费超出了500元,无法购物");
}else{
System.out.println("花了" + x + "元买了一堆化妆品");
}
};
testConsumer(500,con2);
}
/*案例 : 定义出一个方法功能, 客户预计消费500元现金, 每一个客户对于500元的消费都不同, 将客户的消费方式实现出来
1)客户1 : 花了500元, 买了一把大宝剑
2)客户2 : 花了500元, 买了一堆化妆品
3)客户3 : 花了500元, 买了一双球鞋
4).... 还有无限的客户有不同种消费方式
参数列表分析:
1. 参数1表示客户需要花费的预期金额
2. 参数2需要对于double类型的参数1,消费(使用)方式,因此提供Consumer<Double> con, 就是为了传递
accept(T t): 对于double类型数据进行消费(使用)
*/
public static void testConsumer(double money, Consumer<Double> con){
con.accept(money);
}
}
2.4 供给型接口
1、Supplier<T>：供给型接口
2、抽象方法：T get() 提供返回任意类型数据的规则
3、作用：
当一个方法需要去生产一些数据，并且生产数据的方式不确定，就可以在方法的形参列表位置传递一个 Supplier接口，将来让调用该方法的调用者把如何生产数据的方式传递进来。有了供给型接口之后，不仅仅可以传递生产数据的数量等信息，也可以传递生产数据的方式。
案例 : 定义出一个方法功能, 能给客户返回出一个ArrayList<Integer>类型容器, 容器中装几个数据由客户决定, 容器中承装的数据有什么规律, 由客户决定, 方法主要给客户返回一个符合客户要求的容器
1) 客户1 : 5个数据, 都是30-80之间的随机数
2) 客户2 : 8个数据, 1-100之间的随机偶数
3) ...
import java.util.ArrayList;
import java.util.Random;
import java.util.function.Supplier;
public class SupplierInterfaceUse {
public static void main(String[] args) {
// 1)客户1 : 5个数据, 都是30-80之间的随机数
// (0-50) + 30 -->30--80
Supplier<Integer> sup = ()->new Random().nextInt(51) + 30;
ArrayList<Integer> list = getArrayList(5,sup);
System.out.println(list);
// 2)客户2 : 8个数据, 1-100之间的随机偶数
Supplier<Integer> sup2 = ()->{
Random ran = new Random();
int number = ran.nextInt(100)+1;
while(number % 2 != 0){
number = ran.nextInt(100)+1;
}
return number;
};
list = getArrayList(8,sup2);
System.out.println(list);
}
/* 案例 : 定义出一个方法功能, 能给客户返回出一个ArrayList<Integer>类型容器,
容器中装几个数据由客户决定, 容器中承装的数据有什么规律, 由客户决定,
方法主要给客户返回一个符合客户要求的容器
1)客户1 : 5个数据, 都是30-80之间的随机数
2)客户2 : 8个数据, 1-100之间的随机偶数
3)...
分析参数列表:
1. 需要客户提供目标存储的数据个数
2. 需要客户提供容器中存储的数据对应的规则,需要Integer类型数据, 因此提供一个Supplier<Integer>,
实际上提供的就是 Integer get()
*/
public static ArrayList<Integer> getArrayList(int count, Supplier<Integer> sup){
ArrayList<Integer> list = new ArrayList<>();
if(count > 0){// 存储数据到list集合
for(int i = 1; i <= count; i++){
list.add(sup.get());
}
}else{// 直接返回list即可
return list;
}
return list;
}
}
标签：day26,Supplierr,接口,客户,println,方法,public,500 来源： https://www.cnblogs.com/lw1095950124/p/16093811.html