文章目录
1. lambda 表达式
1.1 lambda 的基本语法
左边：对应接口中的抽象方法的参数
右边，对应接口中的抽象方法的实现，即所需要执行的功能，也即 lambda 体
注：在 jdk1.7 及以前，在 lambda 表达式内部要调用类的成员变量的时候，这个成员变量必须用 final 显示声明，而 jdk1.8 之后，不需要显示声明，系统会默认我们调用的这个成员变量是 final 的，但是你对这个变量进行修改的时候仍然是会报错的
lambda 的语法形式：
① 无参数，无返回值：()-> 具体实现
② 有一个参数，无返回值：（x）-> 具体实现
③ 若只有一个参数，小括号可以省略不写：x -> 具体实现
④ 若有多个参数，多条语句，加个大括号就行了：（x,y）-> { 具体实现 }
⑤ 若 lambda 体重只有一条语句，return 和大括号都可以省略不写，如Comparator<Integer>com = (x,y) -> Integer.compare(x,y)。原本应该是
Comparator<Integer>com = (x,y) -> {
return Integer.compare(x,y);
}
⑥ lambda 表达式的参数列表的数据类型可以省略不写，因为 JVM 编译器通过上下文可以推断出数据类型，即“类型推断”
注：lambda 需要“函数式接口”的支持
函数式接口：接口中只有一个抽象方法的接口，称为函数式接口。可以使用 @FunctionalInterface 修饰
1.2 lambda 四大内置函数式接口
| 类型 | 语法 |
|---|---|
| Consumer:消费型接口 | void accept(T t) |
| Supplier :供给型接口 | T get() |
| Function<T,R>: 函数型接口 | R apply(T t) |
| Predicate: 断言型接口 | boolean test(T t) |
1. Consumer 消费型接口：
public void happy(double m, Consumer<Double>con){
con.accept(m);
}
@Test
public void test01(){
happy(1000,(m) -> System.out.println("消费了"+m+"元"));
}
2. Supplier 供给型接口：
@Test
public void test02(){
String s=supplier(()->"生产一辆车");
System.out.println(s);
}
public String supplier(Supplier<String>sup){
return sup.get();
}
3.函数型接口
@Test
public void test03(){
System.out.println(strHandler("abcd",(s)->s.toUpperCase()));
}
public String strHandler(String s, Function<String,String>fun){
return fun.apply(s);
}
4.断言型接口
@Test
public void test04(){
Integer arr[]={1,2,3,4,5};
for (Integer a : arr) {
Pre(a,(b)->{
if(b<=3) return true;
return false;
});
}
}
public void Pre(int a,Predicate<Integer>pre){
System.out.println(a+" "+pre.test(a));
}
2. 方法引用与构造器引用
2.1 方法引用
方法引用：若 lambda体 中的内容有方法已经实现了，我们可以使用 “方法引用” （可以理解为方法引用是 lambda 表达式的另外一种表现形式）
主要有三种语法格式：
① 对象 :: 实例方法名
② 类 :: 静态方法名
③ 类 :: 实例方法名
案例演示：
① 对象 :: 实例方法名
@Test
public void test05(){
// 正常的用 lambda 表达式表示：传入一个数并打印应该是这样写的
Consumer<String>con=(x)-> System.out.println(x);
con.accept("小猪猪1号");
/*
由于这里的 System.out.println() 函数和Consumer接口的
参数列表和返回值类型都一致，所以我们可以把上面的lambda表达式
改写成方法引用的形式，如下:
*/
Consumer<String>con1= System.out :: println;// 对象 :: 实例方法名
con1.accept("小猪猪2号");
}
注意：
① lambda 体中调用方法的参数列表与返回值类型，要与函数式接口中抽象方法的函数列表和返回值类型保持一致
② 若 lambda 参数列表中的第一参数是实例方法的调用者，而第二个参数是实例方法的参数时，可以使用 ClassName :: method
2.2 构造器引用
语法格式：ClassName :: new
案例演示：
@Test
public void test06(){
Supplier<Employee> sup=() -> new Employee();
//构造器引用
Supplier<Empployee>suo2=Employee:new;
}
2.3 数组引用
语法格式：Type[] :: new
@Test
public void test06(){
Function<Integer,String[]>fun = (x) -> new String[x];
Function<Integer,String[]>fun1 = String[] :: new;
}
3. Stream 流式计算
Stream流：和普通的流一样，就是对数据进行操作，是数据就会有数据源（集合、数组等），而流对数据的操作其实主要表现在对数据的传输
但是和普通的流不一样的是，在传输的过程中可以对数据源进行一系列流水线式的中间操作，最终产生一个新流（原来的数据源并不改变，怎么理解呢，就是相当于复制文件，原来的文件并不会改变）。
流（Stream）到底是什么？ 是数据渠道，用于操作数据源（集合、数组）所生成的元素序列。“集合讲的是数据，流讲的是运算！”
注意：
① Stream 自己不会存储元素
② Stream 不会改变源对象。相反，他们会返回一个持有结果的新的 Stream
③ Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行
3.1 创建流的几种方式
1.Java8 中的 Collection 接口被扩展，提供了两个获取流的方法，使用这个方法，包括继承Collection的接口，如：Set，List，Map，SortedSet 等等：
default Stream<E> stream();返回一个顺序流default Stream<E> parallelStream();返回一个并行流
2.Arrays.stream，我们可以通过Arrays的静态方法，传入一个泛型数组，创建一个流
3.Stream.of，我们可以通过Stream的静态方法，传入一个泛型数组，或者多个参数，创建一个流，这个静态方法，也是调用了Arrays的stream静态方法，如下
4.Stream.iterate，是Stream接口下的一个静态方法，从名字也可以看出，这个静态方法，是以迭代器的形式，创建一个数据流
5.Stream.generate，也是stream中的一个静态方法
案例演示：
@Test
public void test(){
//1.通过 Collection 系列集合提供的 stream() 或 parralleStream()
List<String> list=new ArrayList<>();
Stream<String> stream1=list.stream();
//2. 通过 Arrays 中的静态方法 stream 获得数组流
Integer []arr=new Integer[10];
Stream<Integer>stream2= Arrays.stream(arr);
//3. 通过 Stream 中的静态方法 of()
Stream<String>stream3=Stream.of("aa","bb","cc");
//4. 创建无限流
//迭代
Stream<Integer>stream4=Stream.iterate(0,(x)->x+2);
//生成
Stream.generate(()->Math.random()).limit(5);
}
3.2 Stream_筛选与切片
- filter – 接收 lambda，从流中排除某些元素
- limit – 截断流，使其元素不超过给定数量
- skip(n) – 跳过元素，返回第一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流，与 limit(n) 互补
- distinct – 筛选，通过流所生成元素的 hashcode() 和 equals() 去除重复元素
案例演示：
@Test
@Test
public void test(){
Integer []arr={1,2,3,4,4,4,4,5,6,7,8,9};
// 中间操作:不会执行任何操作
Stream<Integer>stream = Arrays.stream(arr).filter((a)->{
System.out.println("Stream 的中间操作");
return a>=3;
}).skip(2).distinct().limit(1);
//终止操作:一次性执行全部内容，即“惰性求值”
stream.forEach(System.out::println);
}
注意：
filter 是一个短路运算，就比如 limit(2) ，已经取到满足条件的两条数据之后， filter 就不会再继续向下执行了
多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为 “惰性求值”
3.3 Stream_映射
- map – 接收 lambda ，将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
- flatMap – 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连成一个流
stream中的flatmap是stream的一种中间操作，它和stream的map一样，是一种收集类型的stream中间操作，但是与map不同的是，它可以对stream流中单个元素再进行拆分（切片），从另一种角度上说，使用了它，就是使用了双重for循环
案例演示：
// map -- 将list里面的小写字母全部转成大写
@Test
public void test1() {
List<String> list = Arrays.asList("aaa", "bbb", "ccc");
Stream<String> stream = list.stream();
stream.map((s) -> s.toUpperCase()).forEach(System.out::println);
}
//flatMap -- 将多个 List 合并成一个
@Test
public void test2(){
List<String> list1= new ArrayList(){{add("1");add("2");}};
List<String> list2= new ArrayList(){{add("3");add("4");}};
List<String> list3= new ArrayList(){{add("5");add("6");}};
List<List<String>> list = new ArrayList(){{add(list1);add(list2);add(list3);}};
System.out.println(list.stream().flatMap(List::stream).collect(Collectors.toList()));
}
3.4 stream_排序
sorted() – 自然排序（Comparable）
sorted(Comparable com) – 定制排序（Comparator）
@Test
public void test() {
List<Emp>list=Arrays.asList(new Emp("zs",10),new Emp("ls",15),new Emp("zs",16));
list.stream().sorted((x,y)->{
if(x.name.equals(y.name)){
return x.age.compareTo(y.age);
}
else return x.name.compareTo(y.name);
}).forEach(System.out::println);
}
3.5 stream_查找与匹配
Stream 的终止操作：
allMatch – 检查是否匹配所有元素
anyMatch – 检查是否至少匹配一个元素
noneMatch – 检查是否没有匹配所有元素
findFirst – 返回第一个元素
findAny – 返回当前流中的任意元素
cout – 返回流中元素的总个数
max – 返回流中最大值
min – 返回流中最小值
3.6 stream_归约与收集
3.6.1 规约
归约： reduce(T identity,BinaryOperator) / reduce(BinaryOperator) ：可以将流中的元素反复结合起来，得到一个值，比如求一个数组的和
identity：起始值
BinaryOperator：二元运算
@Test
public void test(){
List<Integer>list=Arrays.asList(1,2,3,4,5,6,7,8,9,10);
Integer sum=list.stream().reduce(0,(x,y)->x+y);
System.out.println(sum);
}
注意：map 和 reduce 的连接通常称为 map-reduce 模式，因 Google 用它来进行网络搜索而出名
3.6.2 收集
收集： collect(Collector<? super T, A, R> collector)：将流转换为其他形式。接收一个 Collector 接口的实现，用于给 Stream 中元素做汇总的方法。例如，把一个公司的所有员工信息单独收集起来存到一个集合中去
collector：我们要按照哪种方式去收集
案例演示：
@Test
public void test(){
List<Emp>list=Arrays.asList(new Emp("zs",10),new Emp("ls",15),new Emp("zs",16));
List<String>l1=list.stream().map(Emp::getName).collect(Collectors.toList());
// Collectors 里面有很多的工具
for (String s : l1) {
System.out.println(s);
}
}
4. 并行流与串行流
并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流
Java8 中将并行进行了优化，我们可以很容易对数据进行并行操作。Stream API 可以生命性地通过 parallel() 与 sequential() 在并行流与顺序流之间进行切换
4.1 Fork/Join 框架
4.1.1 了解 Fork/Join 框架
Fork/Join 框架： 就是在必要的情况下，将一个大人物，进行拆分成若干个小任务（拆到不可再分时），再将一个个的小任务运算的结果进行 join 汇总
4.1.2 Fork/Join 框架与传统线程池的区别
Fork/Join 框架采用了“工作窃取”模式：
当执行新任务时它可以将其拆分成更小的任务执行，并将小任务加到线程队列中，当自己的线程队列执行完了之后，再从其他的一个随机线程队列中偷一个并把它放在自己的队列中
相对于一般的线程池实现，Fork/Join 框架的优势体现在对其中包含的任务的处理方式上，在一般的线程池中，如果一个线程正在执行的任务由于某些原因无法继续运行，那么该线程会处于等待状态。而在 Fork/Join 框架实现中，如果某个子问题由于等待另外一个子问题的完成而无法继续运行，那么处理该子问题的线程会主动寻求其他尚未运行的子问题来执行，这种方式减少了线程等待时间，提高性能
4.1.3 Fork/Join 框架案例
计算 1~ 1000000000
import java.util.concurrent.RecursiveTask;
public class ForkJoinCalculate extends RecursiveTask<Long> {
Long start,end;
Long thread=5000L;
public ForkJoinCalculate(Long start,Long end) {
this.start=start;
this.end=end;
}
@Override
protected Long compute() {
Long len=end-start,ans=0L;
if(len<=thread){
for(Long i=start;i<end;i++) ans+=i;
return ans;
}
else{
Long mid=(start+end)/2;
ForkJoinCalculate left=new ForkJoinCalculate(start,mid);
ForkJoinCalculate right=new ForkJoinCalculate(mid,end);
left.fork(); //拆分子任务，同时压入线程队列中
right.fork();
return left.join()+right.join();
}
}
}
public class ForkJoinTest {
@Test
public void test(){
//要用到 ForkJoinPool 的池子
ForkJoinPool pool = new ForkJoinPool();
ForkJoinTask<Long>forkJoinTask=new ForkJoinCalculate(0L,1000000000L);
Long sum=pool.invoke(forkJoinTask);
System.out.println(sum);
}
}
5.Optional 类
Optional<T> 类（java.util.Optional）是一个容器类，代表一个值存在或不存在，原来用 null 来表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常
常用方法：
- Optional.of(T t)：创建一个 Optional 实例
- Optional.empty()：创建一个空的 Optional 实例
- Optional.ofNullable(T t)：若 t 不为空，创建 Optional 实例，否则创建空实例
- isPresent()：判断是否包含值
- orElse(T t)：如果调用对象包含值，返回该值，否则返回 t
- orElseGet(Supplier s)：如果调用对象包含值，返回该值，否则返回 s 获取的值
- map(Function f)：如果有值对其处理，并返回处理后的 Optional ，否则返回 * * * * Optional.empty()
- flatMap(Function mapper)：与 map 类似，要求返回值必须是 Optional
6.接口中的默认方法与静态方法
6.1 接口中的默认方法
在接口中的方法前加上default关键字就可以在接口中写方法的默认实现。
默认方法，接口的子类不需要实现，可以直接使用
可以定义一个或多个默认方法
Java8为什么要引入默认方法？
默认方法的主要优势是提供一种拓展接口的方法，而不破坏现有代码。加入我们有一个已经投入使用接口需要拓展一个新的方法，在JDK8以前，如果为一个使用的接口增加一个新方法，则我们必须在所有实现类中添加该方法的实现，否则编译会出现异常。如果实现类数量少并且我们有权限修改，可能会工作量相对较少。如果实现类比较多或者我们没有权限修改实现类源代码，这样可能就比较麻烦。而默认方法则解决了这个问题，它提供了一个实现，当没有显示提供其他实现时就采用这个实现。这样新添加的方法将不会破坏现有代码。
默认方法的另一个优势是该方法是可选的，子类可以根据不同的需求Override默认实现。
接口默认方法的 “类优先” 原则
若接口中定义了一个默认方法，而另一个父类或接口中又定义了一个同名的方法时
- 选择父类中的方法。如果一个父类提供了具体的实现，那么接口中具有相同名称和参数的默认方法会被忽略
- 接口冲突。如果一个父接口提供一个默认方法，而另一个接口也提供了一个具有相同名称和参数列表的方法（不管方法是否是默认方法），那么必须覆盖该方法来解决冲突
7. 新时间日期API
和原来的时间日期API最大的不同就是以前不是线程安全的，现在的是线程安全的
8.重复注解与类型注解
就是在一个类上可以定义两个类型相同的注解
附上 Java8 实战的 pdf：
链接：https://pan.baidu.com/s/1AUHhyT7xDH1nsEjqR6lJWA
提取码：eju6
扫一扫
191
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
