你有多久没有在十点之前睡觉了?
函数式思想
面向对象思想: 强调通过对象做事情
函数式思想: 尽量忽略面向对象的复杂语法:“强调做什么,而不是以什么方式去做”,Lambda表达式就是函数式思想的体现
Lambda表达式
标准格式
格式:(形式参数)->{代码块}
本质:一个匿名函数(匿名方法);把方法的名字省掉(诞生于JDK8),在Java中主要作用是简化匿名内部类的写法
使用前提
有一个接口,接口中有且仅有一个抽象方法
省略模式
1.参数类型可省略,多个参数要么同时省略要么都不省略
2.如果参数有且仅有一个,那么包裹参数的小括号可省略
3.如果参数代码块语句只有一条,可以省略大括号和分号,如果有return,return也要省略
注意事项
1.Java可以推导的就是可以省略的
2.必须要有接口,有且仅有一个抽象方法
3.必须有上下文环境，才能推导出Lambda对应的接口
区别对比
举例说明
public class Test01 {
public static void main(String[] args) {
//1: Thread实现的匿名内部类
new Thread(){
@Override
public void run() {
System.out.println("线程启动");
}
}.start();
//2: Runnable实习匿名内部类
Runnable runnable = new Runnable(){
@Override
public void run() {
System.out.println("线程启动");
}
};
new Thread(runnable).start();
//lambda创建线程
new Thread(() -> System.out.println("线程启动")).start();
new Thread(() -> println("线程启动")).start();
}
}
Stream流的相关操作
特性
不是数据结构，没有内部存储。
不支持索引访问。
延迟计算
支持并行
很容易生成数据或集合
支持过滤，查找，转换，汇总，聚合等操作。
机制
1.Stream分为创建操作，中间操作，终止操作。
2.流的源可以是一个数组，集合，生成器方法，I/O通道等等
3.一个流可以有零个或多个中间操作，每一个中间操作都会返回一个新的流，供下一个操作使用，一个流只会有一个终止操作。
4.Stream只有遇到终止操作，它的源才会开始执行遍历操作。
创建操作
数组:Stream.of()
集合:stream()
通过Stream.generate方法来创建
通过Stram.iterate方法
其他
中间操作
1.distinct去重
List<Integer> list = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
List<Integer> newList = list.stream().distinct().collect(Collectors.toList());
2.filter 过滤
list.stream().filter(i -> i % 2 == 0).collect(Collectors.toList());
3.sorted 排序
list.stream().sorted().collect(Collectors.toList());//默认自然排序从小到大
list.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());//倒序
list.stream().sorted(Comparator.comparing(User::getAge)).collect(Collectors.toList());
limit && skip
list.stream().limit(1).collect(Collectors.toList());
list.stream().skip(1).collect(Collectors.toList());
map归纳
list.stream().map(object::getName).collect(Collectors.toList());
终止操作
collect收集
list.stream().limit(2).collect(Collectors.toList());
list.stream().limit(2).collect(Collectors.toSet());
list.stream().limit(2).collect(Collectors.toMap(Object::getName, Object::getAge));
循环 forEach
计算 min、max、count、average
Optional<Integer> min = list.stream().reduce(Integer::min);
Optional<Integer> max = list.stream().reduce(Integer::max);
anyMatch 匹配任意一个
boolean b = list.stream().anyMatch(Object::isDel);
allMatch 匹配所有
boolean b = list.stream().allMatch(o -> o.getAge() < 30);
noneMatch 都不匹配
boolean b = list.stream().noneMatch(o -> o.getAge() > 30);
findFirst
Optional<Object> optional = list.stream().filter(Object::isDel).findFirst();
findAny
Optional<Object> optional = list.stream().filter(Object::isDel).findAny();
reduce 规约
List<Integer> list = Arrays.asList(1, 2, 3, 6, 8);
Integer reduce = list.stream().reduce(0, (a, b) -> a + b);
Collectors 收集器
计算总和: int i = list.stream().collect(Collectors.summingInt(Object::getMath));
Comparator<Object> 比较器 = Comparator.comparingInt(Object::getAge);
流中最大值: Optional<Object> optional = list.stream().collect(Collectors.maxBy(比较器));
流中最小值: Optional<Object> optional = list.stream().collect(Collectors.minBy(比较器));
summingInt 汇总
int collect = list.stream().collect(Collectors.summingInt(Object::getNum));
averagingInt 平均数
Double average = list.stream().collect(Collectors.averagingInt(Object::getNum));
joining连接字符串
String names = dish.stream().map(Object::getName).collect(Collectors.joining());
String names = dish.stream().map(Object::getName).collect(Collectors.joining(","));
counting 总数
long sum = list.stream().collect(Collectors.counting());
grouping By 分组
Map<Object.Type, List<Dish>> collect = list.stream().collect(Collectors.groupingBy(Object::getType));3
//自定义分组条件
Map<String, List<Person>> collect = list.stream().collect(Collectors.groupingBy(Person->{
if (Person.getAge() <= 18) {
return "未成年";
} else if (Person.getAge() <= 40) {
return "中年";
} else {
return "老年";
}
}));
多级分组
Map<Person.Type, Map<String, List<Person>>> collect = list.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(p -> {
if (p.getAge() <= 18) {
return "未成年";
} else if (p.getAge() <= 40) {
return "中年";
} else {
return "老年人";
}
})));
如有疑问或不同见解,欢迎留言共同交流,博主看到后会在第一时间回复哦