一)Lambda表达式简介
Lambda表达式是一个匿名函数,也可以称为闭包,是Java8中一个新特性。
Lambda表达式语法格式:
(parameters) -> expression;
或
(parameters) -> { statements; }
Lambda表达式特征:
1)可选类型声明:不需要声明参数类型,编译器可以统一识别参数值类型。
2)可选的参数圆括号:一个参数无需定义圆括号,但多个参数需要定义圆括号。
3)可选的大括号:如果主体只包含了一个语句,可省略大括号。
4)可选的返回关键字:如果主体只有一个表达式返回值,则编译器会自动返回值,否则大括号中需要指定表达式返回值。
Lamdba优点:
1)代码简洁。
2)容易学习和使用,可快速开发。
3)维护方便,比如当jdk对Lambda进行升级优化或调整时,不需要修改代码。
@FunctionalInterface:函数式接口,有以下几个特点。
1)接口中有且仅有一个抽象方法。
2)可允许定义静态方法和默认方法。
3)允许java.lang.Object中的public方法。
4)该注解不是必须的,只要符合“函数式接口”即可,加上该注解能让编译器更好检查。如不符合规则,又添加该注解,编译器就会报错。
二)自定义Lambda表达式
在Java中,每一个方法可以看作一个函数,那怎么把一个函数赋值给一个变量,如下图。
如果直接用“=”号方式赋值肯定会报错,可以把一些方法类型去除,如下图:
把一些方面修饰符和参数去除,如下图:
Lambda表达式处理好,但printFunction参数的类型还需要处理一下,printFunction参数类型需要声明成函数式接口。
如果有返回值的话,把函数接口中方法修改一下,然后在Lambda表达式中大括号尾部添加返回值代码。
自定义Lambdm表达式案例:
public class LambdaTest {
// 计算函数
interface Calculate {
int operate(int a, int b);
}
// 函数参数
public int operate(int a, int b, Calculate calc) {
return calc.operate(a, b);
}
public static void main(String[] args) {
LambdaTest lambdaTest = new LambdaTest();
// 有参数类型
Calculate add = (int a, int b) -> a + b;
System.out.println("30 + 5 = " + lambdaTest.operate(30, 5, add));
// 无参数类型
Calculate subtract = (a, b) -> a - b;
System.out.println("30 - 5 = " + lambdaTest.operate(30, 5, subtract));
// 有参数类型并且有返回值
Calculate multiply = (int a, int b) -> { return a * b; };
System.out.println("30 x 5 = " + lambdaTest.operate(30, 5, multiply));
// 无大括号和返回值
Calculate div = (int a, int b) -> a / b;
System.out.println("30 / 5 = " + lambdaTest.operate(30, 5, div));
}
}
三)原生态Lambda表达式
第一步:自定义一个JavaBean
public class User {
public User(String name, Integer age) {
this.name = name;
this.age = age;
}
private String name; // 姓名
private Integer age; // 年龄
public void setAge(Integer age) {
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public String getName() {
return name;
}
}
第二步:定义一个函数式接口,该函数判断是否符合条件,再定义一个静态方法处理数据。
@FunctionalInterface
public interface CheckUser {
boolean check(User user);
}
public static List<User> checkAndAddUser(List<User> userList,
CheckUser checkUser) {
List<User> list = new ArrayList<User>();
for (User user : userList) {
if (checkUser.check(user)) {
System.out.println("name: " + user.getName() + ", age: " +user.getAge());
list.add(user);
}
}
return list;
}
第三步:初始化一些用户数据,并添加一个main方法测试
public static void main(String[] agrs) {
List<User> userList = Arrays.asList(
new User("ouyangjun", 27),
new User("oysept", 17),
new User("zhangsanfeng", 107),
new User("yewen", 37),
new User("zhangzhang", 7)
);
// 函数式接口测试
List<User> list = checkAndAddUser(userList,
u -> u.getName().startsWith("zhang")); // 以zhang开头的用户数据
}
第四步:对函数式接口进行优化
List<User> list = userList.stream().filter(u -> u.getName().startsWith("zhang")).collect(Collectors.toList());
list.forEach(user -> System.out.println("name: " + user.getName() + ", age: " +user.getAge()));
把foreach转换成stream(),把过滤添加转换成filter,最后再打印到控制台。
原生态Lambdm表达式案例(java.util.Stream):
1):boolean allMatch(Predicate<? super T> predicate):返回此流的所有元素是否与提供的谓词匹配。
// 匹配所有用户是否都是以“zhang”开头
boolean allMatch = userList.stream().allMatch(u->u.getName().startsWith("zhang"));
System.out.println(allMatch); // false
2)boolean anyMatch(Predicate<? super T> predicate):返回此流的任何元素是否与提供的谓词匹配。
// 匹配姓名以“zhang”开头并且年龄>100的用户
Predicate<User> p1 = u -> u.getName().startsWith("zhang");
Predicate<User> p2 = u -> u.getAge() > 100;
boolean anyMatch = userList.stream().anyMatch(p1.and(p2));
System.out.println(anyMatch); // true
3)Stream<T> filter(Predicate<? super T> predicate):返回由与此给定谓词匹配的此流的元素组成的流。
// 匹配姓名以“zhang”开头并且年龄>100的用户
List<User> filterList = userList.stream()
.filter(u -> u.getName().startsWith("zhang"))
.filter(u -> u.getAge() > 100)
.collect(Collectors.toList()); // 把Stream转换成List
4)long count():返回此流中的元素数。
// 返回数量
long count = userList.stream().count();
System.out.println(count);
5)Stream<T> distinct():返回由该流的不同元素(根据 Object.equals(Object) )组成的流。
// 对数据去重并打印
List<String> strList = Arrays.asList("AA", "BB", "AA", "CC");
strList.stream().distinct().forEach(s -> System.out.println(s)); // AA BB CC
// distinct只能通过equals的方式去重, 所以先把姓名转换成map string, 再对数据去重
// 如果不自己转换, 就需要自己重写User类的equals方法
List<String> distinctList = userList.stream().map(u->u.getName()).distinct().collect(Collectors.toList());
6)void forEach(Consumer<? super T> action):对此流的每个元素执行操作。
userList.forEach(u -> System.out.println("name: " + u.getName() + ", age: " + u.getAge()));
7)<R> Stream<R> map(Function<? super T,? extends R> mapper):返回由给定函数应用于此流的元素的结果组成的流。
List<String> mapList = userList.stream().map(u->u.getName()).collect(Collectors.toList());
mapList.forEach(s -> System.out.println(s));
// 函数
Function<Integer, Integer> name = e -> e * 2;
Function<Integer, Integer> square = e -> e * e;
System.out.println(name.andThen(square).apply(3)); // 36
Function<User, String> funName = n -> n.getName();
List<String> functionList = userList.stream().map(funName).collect(Collectors.toList());
functionList.forEach(s -> System.out.println(s));
8)Stream<T> limit(long maxSize):返回由此流的元素组成的流,截短长度不能超过 maxSize。
// 获取前几条数据
List<User> limitList = userList.stream().limit(3).collect(Collectors.toList());
limitList.forEach(u -> System.out.println("name: " + u.getName() + ", age: " + u.getAge()));
9)Stream<T> skip(long n):在丢弃流的第一个 n元素后,返回由该流的 n元素组成的流。
// 丢去前几条数据
List<User> skipList = userList.stream().skip(3).collect(Collectors.toList());
skipList.forEach(u -> System.out.println("name: " + u.getName() + ", age: " + u.getAge()));
10)Stream<T> sorted():返回由此流的元素组成的流,根据自然顺序排序。
List<Integer> nums = Arrays.asList(7, 4, 6, 9, 3, 5);
List<Integer> numsList = nums.stream().sorted().collect(Collectors.toList());
numsList.forEach(n -> System.out.println(n));
11)Stream<T> sorted(Comparator<? super T> comparator):返回由该流的元素组成的流,根据提供的 Comparator进行排序。
// 逆序排序, 去掉reversed()就是正序排序
Function<User, Integer> funAge = n -> n.getAge();
List<User> sortedList = userList.stream().sorted(Comparator.comparing(funAge).reversed()).collect(Collectors.toList());
sortedList.forEach(u -> System.out.println("name: " + u.getName() + ", age: " + u.getAge()));
// 对象方式排序, User::getName表示User类中getName的方法名
List<User> objList = userList.stream().sorted(Comparator.comparing(User::getName).reversed()).collect(Collectors.toList());
objList.forEach(u -> System.out.println("name: " + u.getName() + ", age: " + u.getAge()));
识别二维码关注个人微信公众号
本章完结,待续,欢迎转载!
本文说明:该文章属于原创,如需转载,请标明文章转载来源!