1.敲了三遍复制交班志信息的代码，现在按照注释勉强能够完成编写

 

2.复习巩固lamda表达式

(参数)->{实现体}
没错，就是这么简单，甚至()和{}有时还可以省略。

当lambda只有一行的时候。大括号可以省略。

可以把lambda表达式理解为简洁的匿名函数
Lambda表达式和方法引用最主要的功能是为stream服务

 

3.学习了java stream流的方法，

stream.filter过滤出满足条件的元素  ,

Stream<T> filter(Predicate<? super ?> predicate); 过滤出满足条件的元素

参数Predicate：函数式接口，抽象方法：boolean test （T t)

Predicate接口：是一个判断接口

// 获取stream流
Stream<String> stream = Stream.of("张老三", "张小三", "李四", "赵五", "刘六", "王七");
// 需求：过去出姓张的元素
stream.filter((String name)->{
return name.startsWith("张");
}).forEach((String name)->{
System.out.println("流中的元素" + name);
});
————————————————

foreach逐一处理其中的元素，

注意：

1.此方法并不保证元素的逐一消费动作在流中是有序进行的（元素可能丢失）

2.Consumer是一个消费接口（可以获取流中的元素进行遍历操作，输出出去），可以使用Lambda表达式

List<String> list = new ArrayList<>();
list.add("张老三");
list.add("张小三");
list.add("李四");
list.add("赵五");
list.add("张六");
list.add("王八");

// 函数模型：获取流 --> 注意消费流中的元素
list.stream().forEach((String name)->{
System.out.println(name);
});

输出结果：
张老三
张小三
李四
赵五
张六
王八
————————————————

 

cout统计流中的元素，

long count (); 统计流中的元素，返回long类型数据

List<String> list = new ArrayList<>();
list.add("张老三");
list.add("张小三");
list.add("李四");
list.add("赵五");
list.add("张六");
list.add("王八");

long count = list.stream().count();
System.out.println("集合中的元素个数是：" + count);

输出结果：
集合中的元素个数是：6
————————————————

limit 取用前几个元素

// 获取流的长度
Stream<String> stream1 = Stream.of("张老三", "张小三", "李四", "赵五", "刘六", "王七");
// 需求：保留前三个元素
stream1.limit(3).forEach((String name)->{
System.out.println("流中的前三个元素是：" + name);
});

输出结果：
流中的前三个元素是：张老三
流中的前三个元素是：张小三
流中的前三个元素是：李四
————————————————

map方法

<r> Stream <R> map(Function<? super T,? exception R> mapper;
参数Function<T,R>：函数式接口，抽象方法：R apply(T t);
Function<T,R>：其实就是一个类型转换接口（T和R的类型可以一致，也可以不一致）

// 获取Stream流
Stream<String> stream1 = Stream.of("11","22","33","44","55");
// 需求：把stream1流中的元素转换为int类型
stream1.map((String s)->{
return Integer.parseInt(s); // 将String类型的s进行转换为Integer类型的元素，并返回
}).forEach((Integer i)->{
System.out.println(i); // 将转换后的int类型的元素逐一输出
});

输出结果：
11
22
33
44
55
————————————————
skip方法

Stream<T> skip(long n); 跳过前几个元素
注意：
如果流的当前长度大于n，则跳过前n个，否则将会得到一个长度为0的空流

// 获取stream流
Stream<String> stream = Stream.of("张老三", "张小三", "李四", "赵五", "刘六", "王七");

stream.skip(3).forEach((String name)->{
System.out.println("跳过前三个，打印剩下的" + name);
});

输出结果：
跳过前三个，打印剩下的赵五
跳过前三个，打印剩下的刘六
跳过前三个，打印剩下的王七
————————————————
concat

public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
--> 合并两个流

Stream<String> stream1 = Stream.of("11","22","33","44","55");
Stream<String> stream2 = Stream.of("张颜宇", "张三", "李四", "赵五", "刘六", "王七");

// 需求：合并两个流
Stream<String> stream = Stream.concat(stream1,stream2);
stream.forEach((String name)->{
System.out.print(name);
});

输出结果：
1122334455张颜宇张三李四赵五刘六王七
————————————————

 

收集Stream流
Stream流中提供了一个方法，可以把流中的数据收集到单例集合中

<R, A> R collect(Collector<? super T, A, R> collector); 把流中的数据手机到单列集合中
返回值类型是R。R指定为什么类型，就是手机到什么类型的集合
参数Collector<? super T, A, R>中的R类型，决定把流中的元素收集到哪个集合中
参数Collector如何得到 ？，可以使用 java.util.stream.Collectors工具类中的静态方法：
- public static <T> Collector<T, ?, List<T>> toList()：转换为List集合
- public static <T> Collector<T, ?, Set<T>> toSet() ：转换为Set集合

List<String> list2 = new ArrayList<>();
list2.add("张老三");
list2.add("张小三");
list2.add("李四");
list2.add("赵五");
list2.add("张六");
list2.add("王八");

// 需求：过滤出姓张的并且长度为3的元素
Stream<String> stream = list2.stream().filter((String name) -> {
return name.startsWith("张");
}).filter((String name) -> {
return name.length() == 3;
});

// stream 收集到单列集合中
List<String> list = stream.collect(Collectors.toList());
System.out.println(list);

// stream 手机到单列集合中
Set<String> set = stream.collect(Collectors.toSet());
System.out.println(set);
————————————————

stream流详情请参考

(17条消息) Java Stream流（详解）_m0_60489526的博客-CSDN博客_java steam流

 

4.看了几集springmvc拦截器的内容，有点打瞌睡hhh