1、Stream 流 ----------------> 重点:操作容器类型的数据(数组或集合),代码比较简单
2、方法引用 -----------------> 了解:方法引用省略太多,把之前的Lambda表达式最简化的版本,都省略了
A. 代码的层面对比
a. 传统的集合遍历方式,代码量多
b. 流式思想的方式,代码量少
B. 操作的层面对象
a. 传统的集合遍历方式,关注过程和格式写法
b. 流式思想的方式,关注的是结果
A.集合的获取流方式
a.List集合
List<String> mList = new ArrayList<>();
mList.add("Hello");
mList.add("World");
//获取流 Stream
Stream<String> sm = mList.stream();
b.Set集合
Set<String> mSet = new HashSet<>();
mSet.add("Hello");
mSet.add("World");
//获取流 Stream
Stream<String> sm = mSet.stream();
B. 数组的获取流方式
String[] arr = {"Hello","World"};
//获取流 Stream
Stream<String> sm = Stream.of(arr);
C.直接获取流的方式
//直接获取流Stream 采用of方法的可变参数
Stream<Integer> sm = Stream.of(11, 33, 22, 44);
A. 延迟方法: 操作完毕还是流Stream,可以使用链式编程,继续打点调用
B. 终结方法: 操作完毕不是流Stream,一般不能继续下一步的操作
A. void forEach(Consumer<? super T> action)
a.分类:"终结方法"(操作完毕,不能继续打点调用)
b.用途:用于遍历数据,查看结果
B. Stream<T> filter(Predicate<? super T> predicate);
a.分类:"延迟方法"(操作完毕,可以继续打点调用)
b.用途:用于过滤数据,筛选数据
C. <R> Stream<R> map(Function<? super T, ? extends R> mapper);
a.分类: "延迟方法"(操作完毕,可以继续打点调用)
b.用途: 用于转换数据类型,Function函数可以转换类型
D. long count();
a.分类: "终结方法"(操作完毕,不能继续打点调用)
b.用途: 统计最后 Stream 流当中有多少个数据,计数
E. Stream<T> limit(long maxSize);
a.分类: "延迟方法"(操作完毕,可以继续打点调用)
b.用途: 截取前半段
F. Stream<T> skip(long n);
a.分类: "延迟方法"(操作完毕,可以继续打点调用)
b.用途: 截取后半段,跳过前面几个不要,只要后面的
G. public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
a.分类: "延迟方法"(操作完毕,可以继续打点调用)
b.用途: 合并两个 Stream 流,成为一个新的 Stream 流
理解: 方法引用就是对 Lambda 表达式的简化。比Lambda表达式的代码更简单。
A. 对象名称引用成员方法
B. 类名称引用静态方法
C. super 引用父类成员方法
D. this 引用本类成员方法
E. 类的构造方法引用
F. 数组创建的应用
A.对象名称引用成员方法 格式:
a.需要创建对象
类名称 对象名称 = new 类名称();
b.进行方法引用
对象名称::方法名称
c.本质:
实际上就是在创建对象,调用成员方法
B.类名称引用静态方法 格式:
a.直接引用
类名称::静态方法名称
b.本质:
类名称调用静态方法
C.父类方法引用
a.直接引用
super::方法名称
b.本质:
子类当中调用父类的成员方法
D.本类方法引用
a.直接引用
this::方法名称
b.本质:
自己调用自己的成员方法
E.构造方法引用
a.直接引用
类名称::new
b.本质:
就是在创建对象
F.数组的构造引用
a.直接引用
数据类型[] :: new
b.本质:
初始化数组