Java中Lambda表达式定义及应用实例(常见的函数接口+方法引用)
作者：就叫_这个吧
Lambda是一个匿名函数,我们可以把Lambda表达式理解为是一段可以传递的代码,可以写出更简洁、更灵活的代码,这篇文章主要介绍了Java中Lambda表达式定义及应用(常见的函数接口+方法引用)的相关资料,需要的朋友可以参考下
1 什么是Lambda表达式
是一种新型的方法传递参数的方式，又称之为箭头函数，可以简化代码的编写 ->：是Lambda表达式固定格式，被称之为Lambda表达式核心符号 ->左侧：通过Lambda表达式改造的方法的参数部分 ->右侧：通过Lambda表达式改造的方法的方法体 改造的前提：方法传递的参数必须是接口，接口中有且仅有一个抽象方法
2 Lambda表达式代码演示
2.1 语法格式
(参数) -> {方法体}
-其中如果没有参数需要传递，需要保留空括号()
-当被改造的方法体中有且仅有一条语句时，{}和()都可以省略；当被改造的方法具有多条代码则不能省略
-被改造的方法仅有一条语句且是返回语句，return关键字可以省略；如果有多条语句，按照原样进行编写2.2 函数接口
Lambda表达式通过@FunctionalInterface注解，实现接口只有一个抽象方法，这种接口称之为函数接口
//限制接口中有且仅有一个抽象方法，这种接口称之为函数接口
@FunctionalInterface
public interface MyPredicate {
//判断传入的商品是否满足指定条件
boolean test(Product product);
// void fun();
}
2.3 代码实现1
需求：创建多线程并执行打印（可以看到使用Lambda表达式简化了代码编写）
public class OOPDemo {
public static void main(String[] args) {
//通过匿名类的方式，完成需求，打印一句话
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("实现多线程操作-匿名内部类");
}
}).start();
//通过Lambda表达式实现
new Thread(()->System.out.println("实现多线程操作-Lambda表达式")).start();
}
}
2.4 代码实现2
需求：创建商品Product实体类，通过MyPredicate 函数接口，实现查询商品名包含“手机”的商品信息；实现商品价格大于4000的商品
- Product实体类：
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@NoArgsConstructor
@Data
@AllArgsConstructor
public class Product {
private long id;
private String proName;
private Integer price;
private String brand;
}
- 实现类
import java.util.ArrayList;
import java.util.List;
public class ProductLambdaTest {
//初始化几条数据
private static final List<Product> products = new ArrayList<>();
static {
products.add(new Product(1L,"电视1",3000,"HW"));
products.add(new Product(2L,"电视2",4000,"HW"));
products.add(new Product(3L,"手机3",5000,"HW"));
products.add(new Product(4L,"手机4",6000,"RY"));
products.add(new Product(5L,"电脑4",7000,"RY"));
products.add(new Product(6L,"电脑4",8000,"RY"));
}
public static void main(String[] args) {
//展示商品中带有手机两个字的商品信息
/* findProductByPredicate(new MyPredicate() {
@Override
public boolean test(Product product) {
return product.getProName().contains("手机");
}
});*/
findProductByPredicate(p->p.getProName().contains("手机"));
//显示商品单价不小于4000的商品信息
/* findProductByPredicate(new MyPredicate() {
@Override
public boolean test(Product product) {
return product.getPrice()>=2000;
}
});*/
findProductByPredicate(p->p.getPrice()>=4000);
}
private static void findProductByPredicate(MyPredicate predicate) {
List<Product> prices = new ArrayList<>();
for (Product product : products) {
if (predicate.test(product)) {
prices.add(product);
}
}
System.out.println(prices);
}
}
3 常见的函数接口
| 函数式接口 | 参数类型 | 返回值类型 | 说明 |
|---|---|---|---|
| Consumer-消费型接口 | T | void | void accept(T t)只进不出 |
| Supplier-供给型接口 | 无 | T | T get();只出不进，可用作工厂 |
| Function<T,R>-函数型接口 | T | R | R apply(T t) 返回结果Java中的任意一种数据类型 |
| Predicate-断言型接口 | T | boolean | boolean test(T t) |
3.1 函数接口实际应用
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
public class FunctionTest {
public static void main(String[] args) {
//Consumer 消费型接口应用实现
shop(200,i -> System.out.println("消费了"+i+"元"));
//Supplier供给型接口应用实现
System.out.println(getCode(4,()->(int) (Math.random()*10)));
//Function<T,R>函数型接口应用实现
System.out.println(getStringLength(" 12w ",s -> s.trim().length()));
//Predicate 断言型接口应用实现
List<String> list = Arrays.asList("a","bsdfg","c2222","e");
System.out.println(getStrings(list,s->s.length()>3));
}
//shop方法 统计消费多少元，应用Consumer 消费型接口
public static void shop(int money, Consumer<Integer> consumer) {
consumer.accept(money);
}
//生成指定长度的验证码，应用Supplier供给型接口
public static String getCode(int length, Supplier<Integer> supplier) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < length; i++) {
sb.append(supplier.get());
}
return sb.toString();
}
//获取字符串真实长度，应用Function<T,R>函数型
接口
public static int getStringLength(String s, Function<String, Integer> function) {
return function.apply(s);
}
//返回长度大于3 的字符串，应用Predicate 断言型接口
public static List<String> getStrings(List<String> s, Predicate<String> predicate) {
List<String> list = new ArrayList<>();
for (String string : s) {
if (predicate.test(string)){
list.add(string);
}
}
return list;
}
}
4方法引用
4.1 使用前提
· 必须是Lambda表达式改造之后的方法
· 引用的方法必须是定义好的 (不是抽象)
4.2 使用格式：::(引用运算符)
:: 左侧 – 通过什么方式引用方法 , 对象名 或
类名
:: 右侧 – 表示调用方法的名 不能写 ()
4.3 代码演示
import java.util.Arrays;
import java.util.List;
import java.util.function.Function;
import java.util.function.Supplier;
public class MethodQuoteTest {
public static void main(String[] args) {
System.out.println("对象::方法名");
fun1();
System.out.println("类名::静态方法");
fun2();
System.out.println("类名::实例方法");
fun3();
System.out.println("类名::new");
fun4();
}
private static void fun4() {
//使用供给型接口实现，返回一个字符串
Supplier<String> supplier = new Supplier<String>() {
@Override
public String get() {
return new String();
}
};
//使用Lambda表达式实现
Supplier<String> supplier1 = () -> new String();
//使用接口引用实现
Supplier<String> supplier2 = String::new;
}
private static void fun3() {
//使用函数型接口实现
Function<String,Integer> fun = new Function<String,Integer>() {
@Override
public Integer apply(String s) {
return s.length();
}
};
//使用Lambda表达式实现
Function<String,Integer> fun1 = s->s.length();
//使用方法引用实现
Function<String,Integer> fun2 = String::length;
}
private static void fun2() {
//使用供给型接口实现
/* Supplier<Integer> supplier = new Supplier<Integer>() {
@Override
public Integer get() {
return (int)(Math.random()*10);
}
};*/
//方法调用的局限性：只能调用定义好的方法本身
//Supplier<Double> supplier = () -> Math.random();
//Lambda表达式可以使用方法引用替代
Supplier<Double> supplier = Math::random;
}
private static void fun1() {
List<String> list = Arrays.asList("aa","ab","ac");
//list.forEach((String s)-> System.out.println(s));
//Lambda表达式可以使用方法引用替代
list.forEach(System.out::println);
}
}
总结
到此这篇关于Java中Lambda表达式定义及应用实例的文章就介绍到这了,更多相关Java中Lambda表达式内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！