JDK8新特性应用实践
() -> statement
arg -> statement
(arg1, arg2, …) -> { body-block }
(Type1 arg1, Type2 arg2, …) -> {
method-body-block;return value;
}
Lambda表达式有返回值，返回值的类型也由编译器推理得出。如果Lambda表达式中的语句块只有一行，则可以不用使用return语句，下列两个代码片段效果相同：
Arrays.asList( “a”, “b”, “d” )
.sort( ( e1, e2 ) -> e1.compareTo( e2 ) );
Arrays.asList( “a”, “b”, “d” ).sort( ( e1, e2 ) -> {
int result = e1.compareTo( e2 );
return result;
} );
[](()应用案例增强实现
结合对lambda表达式基本语法的认识，通过如下案例在对lambda表达式继续强化分析和实现。
案例1：构建一个线程对象，执行Runnable类型的任务。
传统方式的实现，其关键代码如下：
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(“hello”);
}
}).start();
基于JDK8中的Lambda表达式实现方式，对传统方式线程对象的创建进行简化，其关键代码如下：
new Thread(()->{
System.out.println(“hello”);
}).start();
案例2：通过lambda表达式演示排序过程中代码的简化。
定义一字符串数组，然后对字符串数组中的内容，按字符串元素的长度对其进行排序。代码如下：
String[] strArray= {“abcd”,“ab”,“abc”};
在JDK8之前传统的实现方案，基于Arrays类对数组中的元素进行排序操作，关
键代码实现如下：
Arrays.sort(strArray,new Comparator() {
@Override
public int compare(String o1, String o2) {
return o1.length()-o2.length();
}
});
基于JDK8中的Lambda表达式，对排序如上排序方案的代码实现过程进行简化
，关键代码如下：
Arrays.sort(strArray, (s1, s2) -> s1.length() - s2.length());
[](()JDK8中方法引用
===================================================================
[](()概述
方法引用是用来直接引用类方法、实例方法或者构造方法的一种新的方式。这里要特别强调一点的是“方法引用”提供的是一种对方法的引用而不是执行方法的方式，简单点理解的话就是可以将方法作为参数进行传递，我们还可以将方法引用理解为lambda的一种深层表达。
[](()应用场景
方法引用是一种更简洁易懂的Lambda表达式，操作符是双冒号"::"，也可以将方法引用看成是一个更加紧凑，易读的Lambda表达式。
[](()快速入门分析
方法引用是一种更简洁易懂的Lambda表达式，操作符是双冒号"::"，也可以将方法引用定义一个list集合，然后基于Lambda表达式迭代集合中的内容进行输出，关键代码如下：
List list = Arrays.asList(“a”,“b”,“c”);
list.forEach(str -> System.out.println(str));
基于方法引用的方式，输出list集合中的具体内容的，然后与传统Lambda表达式方式，进行对比分析，关键代码如下：
list.forEach(System.out::println);
说明：当你要访问的接口方法与执行的方法引用参数相同，返回值也相同即可直接使用方法引用。
[](()应用案例增强分析
JDK8方法的引用可分为如下几类：
构造方法引用。
格式：ClassName::new，应用默认构造函数。
package com.cy.java8.methodref;
import java.util.function.Supplier;
public class TestConstructorMethodRef01 {
public static void main(String[] args) {
//1.传统方式
Supplier s1=new Supplier() {
@Override
public Object get() {
return new Object();
}
};
System.out.println(s1.get());
//2.Lambda方式
Supplier s2=()->new Object();
System.out.println(s2.get());
//3.构造方法引用"类名::new"
Supplier obj=Object::new;
System.out.println(obj.get());
}
}
类静态方法引用。
格式：ClassName::static_method。
package com.cy.java8.methodref;
import java.util.function.Function;
public class TestClassMethodRef01 {
public static void main(String[] args) {
//1.传统应用方式
Function
new Function
@Override
public Integer apply(String t) {
return Integer.parseInt(t);
}
};
Integer result=f1.apply(“100”);
System.out.println(result);
//2.lambda应用方式
Function
System.out.println(f2.apply(“200”));
//3.类方法引用应用方式"类名::方法名"
Function
System.out.println(f3.apply(“300”));
}
}
练习：比较两个整数大小。
Comparator com=Integer::compare;
System.out.println(com.compare(39, 20));
类实例方法引用。
格式：ClassName::method，方法不能带参数。
package com.cy.java8.methodref;
import java.io.File;
import java.util.function.Function;
public class TestClassInstanceMethodRef01 {
public static void main(String[] args) {
//1.传统方式
Function
@Override
public String apply(File f) {
return f.getAbsolutePath();
}
};
System.out.println(f1.apply(new File(“pom.xml”)));
//2.Lambda方式
Function
System.out.println(f2.apply(new File(“pom.xml”)));
//3.类实例方法引用"类名::实例方法名"
Function
System.out.println(f3.apply(new File(“pom.xml”)));
}
}
练习：堆数组中内容进行排序，通过方法引用简化编写。
Arrays.sort(strArray,(s1,s2)->s1.compareToIgnoreCase(s2));
Arrays.sort(strArray, String::compareToIgnoreCase);
对象实例方法引用。
格式：对象实例::method，方法不能带参数。
public class TestObjectInstanceMethodRef01 {
public static void main(String[] args) {
List list=Arrays.asList(“A”,“B”,“C”);
//传统方式
list.forEach(new Consumer() {
@Override
public void accept(String t) {
System.out.println(t);
}
});
//Lambda表达式方式
list.forEach(t->System.out.println(t));
//方法引用方式
PrintStream ps=System.out;
list.forEach(ps::println);
list.forEach(System.out::println);
}
}
练习:获取集合中元素的个数。
List list=Arrays.asList(10,20);
Supplier supplier=(list::size);
System.out.println(supplier.get());
[](()JDK8中Stream API应用
===========================================================================
[](()概述
Stream 作为 Java 8 的一大亮点，它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念。Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作，或者大批量数据操作。
[](()应用场景
在当今这个数据爆炸的时代，数据来源多样化、数据海量化，很多时候不得不脱离 RDBMS，以底层返回的数据为基础进行更上层的数据统计。而原有 Java 的集合 API 中，仅仅有极少量的辅助型方法，更多的时候是程序员需要用 Iterator 来遍历集合，然后完成相关的聚合应用逻辑。这是一种远不够高效而且相对比较笨拙的方法。在JDK8中使用 Stream 对象，不仅丰富了在业务层面对数据处理的方式，还可以让代码更加简洁、易读和高效。
[](()快速入门分析
我们在使用Stream对象时，一般会按照如下为三个步骤进行操作：
第一步：创建Stream流对象。
第二步：Stream流中间操作。
第三步：Stream流终止操作。
Stream对象的操作过程，可通过下图进行进一步分析。
Steam对象简易应用，代码如下：
List list = Arrays.asList(3, 2, 12, 5, 6, 11, 13);
long count = list.stream()
.filter(i -> i % 2 == 0)
.count();
System.out.println(count);
[](()应用案例增强分析
Stream对象创建。
Stream对象的创建，常见方式有如下几种：
-
借助Collection接口中的stream()或parallelStream（）方法。
-
借助Arrays类中的stream(…)方法。
-
借助Stream类中的of(…)方法。
-
借助Stream类中的iterator和generator方法（无限操作）。
Stream对象创建，案例分析如下：
Collection col=new ArrayList<>();
…
Stream s1=col.stream();
Stream s2=col.parallelStream();
IntStream s3=Arrays.stream(new int[] {1,2,3,4});
Stream s4=Stream.of(10,20,30,40);
Stream s5=Stream.iterate(2, (x)->x+2);
s5.forEach(System.out::println);
Stream s6=Stream.generate(()->Math.random());
s6.forEach(System.out::println);
Stream中间操作
Stream 对象创建以后可以基于业务执行一些中间操作，但这些操作的结果需要借助终止操作进行输出，案例分析如下：
初始条件：给定list集合作为Stream操作的对象，代码如下：
List list=Arrays.asList(100,101,102,200);
对数据进行过滤：
//输出集合中所有的偶数
//1.创建流
Stream s1=list.stream();
//2.中间操作(过滤)
Stream s2=s1.filter((n)->n%2==0);
//3.终止操作
s2.forEach(System.out::println);
//也可以将多个操作合在一起
list.stream().filter(n->n%2==0).forEach(System.out::println);
限定操作(limit):
list.stream()
.filter(n->n%2==0)
.limit(2)
.forEach(System.out::println);
跳过操作(skip)：
list.stream()
.filter(n->n%2==0)
.skip(2)
.forEach(System.out::println);
去重操作(distinct)：
list.stream()
.distinct()
.forEach(System.out::println);
排序操作(sorted)：底层基于内部比较器Comparable或外部Comparator比较器进行比对。
list.stream()
.sorted()
.forEach(System.out::println);
list.stream()
.sorted((s1,s2)->{//Comparator
return s1-s2;
}).forEach(System.out::println);
映射操作(map)：
List list=Arrays.asList(“a”,“bc”,“def”);
list.stream()
.map((x)->x.toUpperCase())
.forEach(System.out::println);
list.stream()
.map((x)->x.length())
.forEach(System.out::println);
Stream终止操作。
Stream终止操作是Stream的结束操作，案例分析如下：
List list=Arrays.asList(“a”,“bc”,“def”);
list.stream()
.map((x)->x.toUpperCase())
.forEach(System.out::println);
list.stream()
.map((x)->x.length())
.forEach(System.out::println);
案例：初始条件定义，给定一个list集合：
List list=Arrays.asList(10,11,12,13,14,15);
match操作：
boolean flag=list.stream().allMatch((x)->x%2==0);
System.out.println(flag);
flag=list.stream().anyMatch((x)->x%2==0);
System.out.println(flag);
flag=list.stream().noneMatch((x)->x>20);
System.out.println(flag);
find操作：
Optional optional=list.stream().sorted().findFirst();
System.out.println(optional.get());
optional=list.parallelStream().filter((x)->x%2!=0).findAny();
System.out.println(optional.get());
count操作：
long count=list.stream().count();
System.out.println(count);
求最大，最小值：
optional=list.stream().max((x,y)->{return x-y;});
System.out.println(optional.get());
optional=list.stream().min((x,y)->{return x-y;});
System.out.println(optional.get());
forEach迭代操作：
list.stream().forEach(System.out::println);
Reduce(规约)操作：
//计算集合中所有元素的和，其中第一个参数0为初始值，然后与后面每个值累加
Integer sum=list.stream().reduce(0,(x,y)->{return x+y;});
System.out.println(sum);
Collector(收集)操作：
List result=
list.stream()
.map(x->x*2)
.collect(Collectors.toList());
System.out.println(result);
list.stream().map(x->x*2).collect(Collectors.toSet());
System.out.println(result);
double avg=
list.stream()
.collect(Collectors.averagingDouble(x->x));
System.out.println(avg);
Optional max=
list.stream().collect(Collectors.maxBy((x,y)->{return x-y;}));
System.out.println(max.get());
Map
list.stream().collect(Collectors.groupingBy(x->x%2==0));
System.out.println(map);
[](()JDK8中Stream 课堂练习
==========================================================================
[](()red 《一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》无偿开源 威信搜索公众号【编程进阶路】 uce操作
案例1：计算多个整数的和。
static void doTestReduce01() {
List list = Arrays.asList(1,2,3,4,5,6);
Optional count =
list.stream().reduce((a, b) -> (a + b));
System.out.println(count.get()); // 21
}
案例2：计算多个整数乘积，然后再乘以2。
static void doTestReduce02() {
List list = Arrays.asList(1,2,3,4,5,6);
Integer count = list.stream().reduce(2, (a, b) -> (a * b));
System.out.println(count); // 1440
}
案例3：计算多个整数的和，假如超出范围，则对其进行类型转换。.
案例1和2的缺点在于返回的数据都只能和 Stream 流中元素类型一致，但假如求和或乘积之后的数值超过了 Integer 能够表示的范围怎么办？例如，需要使用 Long 类型接收，这就用到了我们下面reduce() 方法的应用形式了。
static void doTestReduce03() {
List list =
Arrays.asList(Integer.MAX_VALUE, Integer.MAX_VALUE);
long count =
list.stream().reduce(0L, (a, b) -> (a + b), (a,b) -> 0L);
System.out.println(count);
}
[](()collect操作实现