lambda表达式
函数式接口： 只有一个方法的接口
四大函数式接口
Function函数式接口：有一个输入参数，有一个输出
断定型接口：有一个输入参数，返回值只能是 布尔值！
Consumer 消费型接口：只有输入，没有返回值
Supplier 供给型接口：没有参数，只有返回值
Stream流式计算
流（Stream）是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。
集合讲的是数据，流讲的是计算
Stream自己不会存储数据元素
Stream不会改变原对象，相反，他们会返回一个持有结果的新Stream
Stream操作是延时执行的。
Stream的三个步骤
1.创建Steam
//1.可以通过Collection系列集合提供的stream（）或者parallelStream（）
ArrayList<String> list = new ArrayList<>();
Stream<String> stream = list.stream();
//2.通过Arrays中静态方法stream（）创建
int [] array=new int[6];
Arrays.stream(array);
//3.通过Stream中的静态方法of（）
Stream<String> stringStream = Stream.of("aa", "bb", "cc");
//4.创建无限流 迭代
Stream<Integer> iterate = Stream.iterate(0, (a) -> a + 2);
iterate.forEach(System.out::println);
2.中间操作
API
List<User> list = new ArrayList<User>(){
{
add(new User(1l,"张三",10, "清华大学"));
add(new User(2l,"李四",12, "清华大学"));
add(new User(3l,"王五",15, "清华大学"));
add(new User(4l,"赵六",12, "清华大学"));
add(new User(5l,"田七",25, "北京大学"));
add(new User(6l,"小明",16, "北京大学"));
add(new User(7l,"小红",14, "北京大学"));
add(new User(8l,"小华",14, "浙江大学"));
add(new User(9l,"小丽",17, "浙江大学"));
add(new User(10l,"小何",10, "浙江大学"));
}
}
filter--接受Lambda 从流中排除某些元素
System.out.println("学校是清华大学的user");
List<User> userList1 = list.stream().filter(user -> "清华大学".equals(user.getSchool())).collect(Collectors.toList());
userList1.forEach(user -> System.out.print(user.name + '、'));
学校是清华大学的user
张三、李四、王五、赵六、
limit（n）--截断流，使数量不超过给定值
System.out.println("年龄是偶数的前两位user");
List<User> userList3 = list.stream().filter(user -> user.getAge() % 2 == 0).limit(2).collect(Collectors.toList());
userList3.forEach(user -> System.out.print(user.name + '、'));
年龄是偶数的前两位user
张三、李四、
skip（n）--跳过前n个元素
System.out.println("跳过前面两个user的其他所有user");
List<User> userList5 = list.stream().skip(2).collect(Collectors.toList());
userList5.forEach(user -> System.out.print(user.name + '、'));
跳过前面两个user的其他所有user
王五、赵六、田七、小明、小红、小华、小丽、小何、
distinct--筛选 去重
System.out.println("所有user的年龄集合");
List<Integer> userAgeList = list.stream().map(User::getAge).distinct().collect(Collectors.toList());
System.out.println("userAgeList = " + userAgeList);
所有user的年龄集合
userAgeList = [10, 12, 15, 25, 16, 14, 17]
sorted--自然排序
System.out.println("按年龄从大到小排序");
List<User> userList4 = list.stream().sorted((s1,s2) -> s2.age - s1.age).collect(Collectors.toList());
userList4.forEach(user -> System.out.print(user.name + '、'));
按年龄从大到小排序
田七、小丽、小明、王五、小红、小华、李四、赵六、张三、小何、
sorted（）--定制排序
map--对每个元素进行操作
System.out.println("学校是清华大学的user的名字");
List<String> userList6 = list.stream().filter(user -> "清华大学".equals(user.school)).map(User::getName).collect(Collectors.toList());
userList6.forEach(user -> System.out.print(user + '、'));
学校是清华大学的user的名字
张三、李四、王五、赵六、
/**
* 题目要求：一分钟内完成此题，只能用一行代码实现！
* 现在有5个用户！筛选：
* 1、ID 必须是偶数
* 2、年龄必须大于23岁
* 3、用户名转为大写字母
* 4、用户名字母倒着排序
* 5、只输出一个用户！
*/
public static void main(String[] args) {
User u1 = new User(1,"a",21);
User u2 = new User(2,"b",22);
User u3 = new User(3,"c",23);
User u4 = new User(4,"d",24);
User u5 = new User(6,"e",25);
// 集合就是存储
List<User> list = Arrays.asList(u1, u2, u3, u4, u5);
// 计算交给Stream流
// lambda表达式、链式编程、函数式接口、Stream流式计算
list.stream()
.filter(u->{return u.getId()%2==0;})
.filter(u->{return u.getAge()>23;})
.map(u->{return u.getName().toUpperCase();})
.sorted((uu1,uu2)->{return uu2.compareTo(uu1);})
.limit(1)
.forEach(System.out::println);
}
3.终止操作
API
查找与匹配
allMatch--检查是否匹配所有元素
anyMatch--检查是否至少匹配一个元素
noneMatch--检查是否没有匹配所有元素
findFirst--返回第一个元素
findAny--返回当前流中的任意元素
count--返回流中的总个数
max--返回流中的最大值
min--返回流中的最小值
归纳
reduce（T identity ， BinaryOperator）--可以将流中元素反复结合起来得到一个值
收集
collect--将流转换为其他形式，接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
Optional类
Optional是一个容器类，代表一个值存在或者不存在，原来用null表示一个值不存在，现在Optional可以更好的表达这个概念，并且避免空指针异常
常用方法
Optional.of（T t）：创建一个Optional实例
Optional.empty（）：创建一个空的Optional实例
Optional.ofNullable（T t）：若t不为null 创建Optional实例 否则创建空实例
isPresent（）：判断是否包含值
orElse（T t）：如果调用对象包含值，返回该值，否则返回t
orElseGet（Supplier s）：如果调用对象包含值，返回该值 否则返回s的值
map（Function f）：如果有值对其处理 并返回处理后的Optional 否则返回Optional.empty（）
flatMap（Function f）： 于map相似 要求返回值必须是Optional
