JDK1.8新特性
Demo源码地址:https://github.com/lxwjq/lambda
1. 函数式接口
含义:有且仅有一个抽象方法,但可以有多个非抽象方法的接口
函数式接口,就是Java类型系统中的接口
函数式接口,是只包含一个接口方法的特殊接口
语义化检测注解:@FunctionalInterface
- 函数式接口只能操作一个方法
- Lambda表达式,只能操作一个方法
- Java中的Lambda表达式,核心就是函数式接口的实现类
代码示例:
@FunctionalInterface
public interface FunctionInterfaceServer {
/**
* JDK1.8+新特性,接口的默认实现方法
* 优点:
* 1、对于一些公有的方法,直接使用默认的方法,就不用再实现类中写重复代码
* 2、可以对代码进行零入侵的加入一些新特性
*/
default String defaultFunction(String name) {
if ("admin".equals(name)) {
return name += ":admin";
}
return name += ":user";
}
/**
* JDK1.8+新特性 接口的静态实现类
*/
static String staticFunction() {
return "This is FunctionInterface static method";
}
/**
* 认证用户(抽象方法)
*
* @param name 用户名
*/
boolean ouathUser(String name);
/**
* 实现父类Object类
*/
@Override
boolean equals(Object obj);
}
1.1 常用的函数式接口
常用的函数接口(java.utils.function包中):
Predicate——接收T对象并返回boolean
Predicate<String> predicate = userName -> {
if ("admin".equals(userName)) {
return true;
}
return false;
};
boolean result = predicate.test("admin");
Consumer——接收T对象,不返回值
Consumer f = System.out::println;
Consumer f2 = n -> System.out.println(n + "-F2");
//执行完F后再执行F2的Accept方法
Consumer consumer = f.andThen(f2);
consumer.accept("test");
//连续执行F的Accept方法
f.andThen(f).andThen(f).andThen(f).accept("test1");
Function<T, R>——接收T对象,返回R对象
Function<String, Integer> function = temp -> {
if ("admin".equals(temp)) {
return 0;
} else {
return 1;
}
};
Integer result = function.apply(param);
Supplier——提供T对象(例如工厂),不接收值
Supplier<String> supplier = () -> {
return "这是你要的字符串";
};
return supplier.get();
UnaryOperator——接收T对象,返回T对象
UnaryOperator<Person1> unaryOperator = person1 -> {
person1.setAge(10);
person1.setName("test");
return person1;
};
Person1 person1 = new Person1();
unaryOperator.apply(person1);
System.out.println(person1);
BinaryOperator——接收两个T对象,返回T对象
BinaryOperator<Double> binaryOperator = (x, y) -> {
return x + y;
};
binaryOperator.apply(1.2, 2.1);
2. 方法引用
2.1 方法引用是什么
是lambda表达式的一个简化写法. 方法引用语法:左边是容器(可以是类名,实例名),中间是" :: ",右边是相应
的方法名。
通过方法引用,可以将方法的引用赋值给一个变量,通过赋值给Function,说明方法引用也是一种函数式接口的书
写方式,Lambda表达式也是一种函数式接口,Lambda表达式一般用于自己提供方法体,而方法引用一般直接引
用现成的方法。
ObjectReference::methodName
2.2 一般方法的引用格式
如果是静态方法,则是ClassName::methodName。如 Object ::equals
如果是实例方法,则是Instance::methodName。
Object obj=new Object();
obj::equals;
// 必须与函数式接口结合使用,并且函数式接口的参数为实体类的属性
构造函数.则是ClassName::new
详细见MethodReferenceTest.java
3. Optional
源码解析
package java.util;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
/**
* @since 1.8
*/
public final class Optional<T> {
private static final Optional<?> EMPTY = new Optional<>();
private final T value;
private Optional() {
this.value = null;
}
// 返回一个空的 Optional实例
public static<T> Optional<T> empty() {
@SuppressWarnings("unchecked")
Optional<T> t = (Optional<T>) EMPTY;
return t;
}
private Optional(T value) {
this.value = Objects.requireNonNull(value);
}
// 返回具有 Optional的当前非空值的Optional
public static <T> Optional<T> of(T value) {
return new Optional<>(value);
}
// 返回一个 Optional指定值的Optional,如果非空,则返回一个空的 Optional
public static <T> Optional<T> ofNullable(T value) {
return value == null ? empty() : of(value);
}
// 如果Optional中有一个值,返回值,否则抛出 NoSuchElementException 。
public T get() {
if (value == null) {
throw new NoSuchElementException("No value present");
}
return value;
}
// 返回true如果存在值,否则为 false
public boolean isPresent() {
return value != null;
}
// 如果存在值,则使用该值调用指定的消费者,否则不执行任何操作。
public void ifPresent(Consumer<? super T> consumer) {
if (value != null)
consumer.accept(value);
}
// 如果一个值存在,并且该值给定的谓词相匹配时,返回一个 Optional描述的值,否则返回一个空的 Optional
public Optional<T> filter(Predicate<? super T> predicate) {
Objects.requireNonNull(predicate);
if (!isPresent())
return this;
else
return predicate.test(value) ? this : empty();
}
// 如果存在一个值,则应用提供的映射函数,如果结果不为空,则返回一个 Optional结果的 Optional 。
public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
Objects.requireNonNull(mapper);
if (!isPresent())
return empty();
else {
return Optional.ofNullable(mapper.apply(value));
}
}
// 如果一个值存在,应用提供的 Optional映射函数给它,返回该结果,否则返回一个空的 Optional 。
public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
Objects.requireNonNull(mapper);
if (!isPresent())
return empty();
else {
return Objects.requireNonNull(mapper.apply(value));
}
}
// 如果值存在,就返回值,不存在就返回指定的其他值
public T orElse(T other) {
return value != null ? value : other;
}
public T orElseGet(Supplier<? extends T> other) {
return value != null ? value : other.get();
}
public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
if (value != null) {
return value;
} else {
throw exceptionSupplier.get();
}
}
}
使用案例:
Optional.ofNullable(对象).ifPresent(r -> this.riskSuperviseService.saveBatch(r));
4. Lambda表达式
Lambda 表达式,也可称为闭包,它是推动 Java 8 发布的最重要新特性。
Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中)。
使用 Lambda 表达式可以使代码变的更加简洁紧凑。
以下是lambda表达式的重要特征:
- **可选类型声明:**不需要声明参数类型,编译器可以统一识别参数值。
- **可选的参数圆括号:**一个参数无需定义圆括号,但多个参数需要定义圆括号。
- **可选的大括号:**如果主体包含了一个语句,就不需要使用大括号。
- **可选的返回关键字:**如果主体只有一个表达式返回值则编译器会自动返回值,大括号需要指定明表达式返回了一个数值。
详细请查看LambdaTest.java
4.1 Lambda运行原理
一、手动利用记事本编写Java测试代码
/**
* @author lixiang
* @version V1.0
* @date 2020/1/2 11:31
**/
public class TestDemo {
public static void main(String[] args) {
InterDemo interDemo = temp -> System.out.println(temp);
interDemo.mark("test");
}
}
interface InterDemo{
void mark(String temp);
}
二、使用命令行进行编译
javac TestDemo.java
编译后会在当前文件夹生成TestDemo.class与InterDemo.class两个文件
查看TestDemo.class源码
javap -p TestDemo.class
得到下面的结果
Compiled from "TestDemo.java"
public class TestDemo {
public TestDemo();
public static void main(java.lang.String[]);
private static void lambda$main$0(java.lang.String);
}
这里可以看到有一个构造方法,一个main方法,还有一个私有的静态方法,这个静态方法只要你使用都会生成,是一样的。
这个静态私有方法就是Lambda表达式中的方法实现。也就是Lambda表达式在底层构建中生成了一个
private static void lambda$main$0(java.lang.String message){
System.out.println(message);
}
这个私有静态方法什么时候被调用了呐?
我们对它内部生成的所有接口的源代码进行一个输出,通过如下代码我们可以查看TestDemo底层详细的编译过程
java -Djdk.internal.lambda.dumpProxyClasses TestDemo
执行完毕会在当前文件夹生成TestDemo$$Lambda$1.class
查看TestDemo$$Lambda$1.class源码
javap -p TestDemo.class
结果
final class TestDemo$$Lambda$1 implements InterDemo {
private TestDemo$$Lambda$1();
public void mark(java.lang.String);
}
在这里边可以看到第一个是一个构造方法,第二个markUp的实现实际上就是调用了上边的私有静态方法。在调用静态方法的过程中将message传递了过来。
三、总结
Lambda表达式在编译的过程中会生成一个私有的静态方法,在静态方法中做了一个方法的基本实现。
另外在编译的同时会针对Lambda表达式的目标接口,生成一个内部类型实现定义的接口,在实现这个接口的方法中完成对这个静态方法具体执行过程的调用
这两个方法在底层解析执行的时候其实他是在底层new 了一个当前内部类接口的对象,通过这个内部类接口的对象调用这个方法的marUp方法。
实际上Lambda表达式的运行过程可以理解为如下代码:
public class TestDemo{
public static void main(String [] args){
InterDemo inter=(string)->System.out.println(string);
inter.markUp("WangJun");
/**
new TestDemo$$Lambda$1().markUp("WangJun");
*/
}
}
/**
public class TestDemo {
public TestDemo();
public static void main(java.lang.String[]);
private static void lambda$main$0(java.lang.String){
System.out.println(message);
}
}
*/
/**
final class TestDemo$$Lambda$1 implements InterDemo {
private TestDemo$$Lambda$1();
public void markUp(java.lang.String){
TestDemo.lambda$main$0(java.lang.String message){
TestDemo.lambda$main$0(message);
}
}
}
*/
interface InterDemo{
void markUp(String string);
}
5. Stream
5.1 为什么需要Stream
Stream 作为 Java 8 的一大亮点,它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念。它也不同于 StAX 对 XML 解析的 Stream,也不是 Amazon Kinesis 对大数据实时处理的 Stream。Java 8 中的 Stream 是对集合(Collection)对象功能的增强,它专注于对集合对象进行各种非常便利、高效的聚合操作(aggregate operation),或者大批量数据操作 (bulk data operation)。Stream API 借助于同样新出现的 Lambda 表达式,极大的提高编程效率和程序可读性。同时它提供串行和并行两种模式进行汇聚操作,并发模式能够充分利用多核处理器的优势,使用 fork/join 并行方式来拆分任务和加速处理过程。通常编写并行代码很难而且容易出错, 但使用 Stream API 无需编写一行多线程的代码,就可以很方便地写出高性能的并发程序。所以说,Java 8 中首次出现的 java.util.stream 是一个函数式语言+多核时代综合影响的产物。
JDK1.7 排序取值的实现
List<Transaction> groceryTransactions = new ArrayList<>();
for(Transaction t: transactions){
if(t.getType() == Transaction.GROCERY){
groceryTransactions.add(t);
}
}
Collections.sort(groceryTransactions, new Comparator(){
public int compare(Transaction t1, Transaction t2){
return t2.getValue().compareTo(t1.getValue());
}
});
List<Integer> transactionIds = new ArrayList<>();
for(Transaction t: groceryTransactions){
transactionsIds.add(t.getId());
}
而在 Java 8 使用 Stream,代码更加简洁易读;而且使用并发模式,程序执行速度更快。
JDK1.8 排序取值的实现
List<Integer> transactionsIds = transactions.parallelStream().
filter(t -> t.getType() == Transaction.GROCERY).
sorted(comparing(Transaction::getValue).reversed()).
map(Transaction::getId).
collect(toList());
5.2 什么是流
Stream 不是集合元素,它不是数据结构并不保存数据,它是有关算法和计算的,它更像一个高级版本的 Iterator。原始版本的 Iterator,用户只能显式地一个一个遍历元素并对其执行某些操作;高级版本的 Stream,用户只要给出需要对其包含的元素执行什么操作,比如 “过滤掉长度大于 10 的字符串”、“获取每个字符串的首字母”等,Stream 会隐式地在内部进行遍历,做出相应的数据转换。
Stream 就如同一个迭代器(Iterator),单向,不可往复,数据只能遍历一次,遍历过一次后即用尽了,就好比流水从面前流过,一去不复返。
而和迭代器又不同的是,Stream 可以并行化操作,迭代器只能命令式地、串行化操作。顾名思义,当使用串行方式去遍历时,每个 item 读完后再读下一个 item。而使用并行去遍历时,数据会被分成多个段,其中每一个都在不同的线程中处理,然后将结果一起输出。Stream 的并行操作依赖于 Java7 中引入的 Fork/Join 框架(JSR166y)来拆分任务和加速处理过程。
Stream 的另外一大特点是,数据源本身可以是无限的。
5.3 流的构造与转换
// 1. Individual values
Stream stream = Stream.of("a", "b", "c");
// 2. Arrays
String [] strArray = new String[] {"a", "b", "c"};
stream = Stream.of(strArray);
stream = Arrays.stream(strArray);
// 3. Collections
List<String> list = Arrays.asList(strArray);
stream = list.stream();
需要注意的是,对于基本数值型,目前有三种对应的包装类型 Stream:
IntStream、LongStream、DoubleStream
。当然我们也可以用 Stream、Stream >、Stream,但是 boxing 和 unboxing 会很耗时,所以特别为这三种基本数值型提供了对应的Stream。
Java 8 中还没有提供其它数值型 Stream,因为这将导致扩增的内容较多。而常规的数值型聚合运算可以通过上面三种 Stream 进行。
流转换为其它数据结构
// 1. Array
String[] strArray1 = stream.toArray(String[]::new);
// 2. Collection
List<String> list1 = stream.collect(Collectors.toList());
List<String> list2 = stream.collect(Collectors.toCollection(ArrayList::new));
Set set1 = stream.collect(Collectors.toSet());
Stack stack1 = stream.collect(Collectors.toCollection(Stack::new));
// 3. String
String str = stream.collect(Collectors.joining()).toString();
一个 Stream 只可以使用一次,上面的代码为了简洁而重复使用了数次。
5.4 Stream常用API
接下来,当把一个数据结构包装成 Stream 后,就要开始对里面的元素进行各类操作了。常见的操作可以归类如下。
- Intermediate(中间状态)
- map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、skip、 parallel、 sequential、 unordered
- Terminal(终端状态)
- forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator
- Short-circuiting(短路状态:遍历中途停止操作,例如查找第一个满足条件的元素或者limit操作)
- anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit
详细API操作请查看cn.thislx.lambda.stream包下源代码
5.5 Collectors API
详细请查看 https://www.jianshu.com/p/7eaa0969b424
5.6 性能分析
详细请查看 https://mp.weixin.qq.com/s/-p-N-K_oY-vGtvBIKUqShA
5.7 parallelStream的注意事项
详细请查看源代码TestStreamAPI05.java