Java8的一个大亮点是引入Lambda表达式,使用它设计的代码会更加简洁。当开发者在编写Lambda表达式时,也会随之被编译成一个函数式接口。
https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html
简单来说:就是把我们的函数(方法)作为参数传递、调用等
例子:自定义函数式接口(用jdk
自带的函数式接口也可以)
import java.io.Serializable;
/**
* 可序列化的Functional
*
* @author VampireAchao
*/
@FunctionalInterface
public interface Func<T, R> extends Serializable {
/**
* 调用
*
* @param t 参数
* @return 返回值
*/
R apply(T t);
}
我们定义一个类可以去实现该接口
/**
* 可序列化的函数式接口实现类
*
* @author VampireAchao
*/
public class FuncImpl implements Func<Object, String> {
/**
* 调用
*
* @param o 参数
* @return 返回值
*/
@Override
public String apply(Object o) {
return o.toString();
}
}
到此为止,都非常的简单
这里就有个问题:假设我有很多的地方需要不同的类去实现Func
,我就得每次都去写这么一个类,然后实现该接口并重写方法
这样很麻烦!因此我们使用匿名内部类
Func<String, Integer> func = new Func<String, Integer>() {
/**
* 调用
*
* @param s 参数
* @return 返回值
*/
@Override
public Integer apply(String s) {
return s.hashCode();
}
};
我们可以看到,使用了匿名内部类后不用每次去新建这个类了,只需要在调用的地方,new
一下接口,创建一个匿名内部类即可
但这样还有个问题,我们每次都要写这么一大几行代码,特别麻烦
由此而生,我们有了lambda
这种简写的形式
https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html#syntax
Func<String, String> func1 = (String s) -> {
return s.toUpperCase();
};
如果只有一行,我们可以省略掉中括号以及return
Func<String, String> func2 = (String s) -> s.toUpperCase();
我们可以省略掉后边的参数类型
Func<String, String> func3 = s -> s.toUpperCase();
如果我们满足特定的形式,我们还可以使用方法引用(双冒号)的形式缩写
Func<String, String> func4 = String::toUpperCase;
这里除了我们的参数->返回值
写法:s->s.toUpperCase()
,还有很多种
例如无参数带返回值写法()->"yes"
、无参无返回值写法()->{}
等等
而方法引用这种写法有如下几种:
https://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html
package org.dromara.streamquery;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Supplier;
/**
* 语法糖——方法引用
*
* @author VampireAchao
*/
public class MethodReferences {
public static Object staticSupplier() {
return "whatever";
}
public Object instanceSupplier() {
return "whatever";
}
public Object anonymousInstanceFunction() {
return "whatever";
}
public static void main(String[] args) {
// 引用构造函数
Supplier<MethodReferences> conSup = () -> new MethodReferences();
conSup = MethodReferences::new;
// 数组构造函数引用
IntFunction<int[]> intFunction = value -> new int[value];
// intFunc == new int[20];
int[] intFuncResult = intFunction.apply(20);
// 引用静态方法
Supplier<Object> statSup = () -> staticSupplier();
statSup = MethodReferences::staticSupplier;
Object statSupResult = statSup.get();
// 引用特定对象的实例方法
Supplier<Object> instSup = new MethodReferences()::instanceSupplier;
instSup = new MethodReferences()::instanceSupplier;
Object instSupResult = instSup.get();
// 引用特定类型的任意对象的实例方法
Function<MethodReferences, Object> anonInstFunc = streamDemo -> streamDemo.anonymousInstanceFunction();
anonInstFunc = MethodReferences::anonymousInstanceFunction;
}
}
顺便放几个常用的,jdk
自带的函数式接口写法
package org.dromara.streamquery;
import java.math.BigDecimal;
import java.util.function.*;
/**
* 常用的几个函数式接口写法
*
* @author VampireAchao
*/
class Usual {
public static Consumer<Object> consumer() {
// 有参数无返回值
return o -> {
};
}
public static Function<Integer, Object> function() {
// 有参数有返回值
return o -> o;
}
public static Predicate<Object> predicate() {
// 有参数,返回值为boolean
return o -> true;
}
public static Supplier<Object> supplier() {
// 无参数有返回值
return Object::new;
}
public static BiConsumer<String, Integer> biConsumer() {
// 俩参数无返回值
return (q, o) -> {
};
}
public static BiFunction<Integer, Long, BigDecimal> biFunction() {
// 俩参数,有返回值
return (q, o) -> new BigDecimal(q).add(BigDecimal.valueOf(o));
}
public static UnaryOperator<Object> unaryOperator() {
// 一个参数,返回值类型和参数一样
return q -> q;
}
public static BinaryOperator<Object> binaryOperator() {
// 俩参数和返回值类型保持一致
return (a, o) -> a;
}
}
接下来讲一个实际应用,使用lambda实现java判断版本执行不同的代码,例如java8执行逻辑A,java9执行逻辑B等
可以封装一个函数例如:
public static void execute(Map<org.dromara.streamquery.stream.core.enums.JreEnum, Runnable> jdkVersionStragyMap) {
jdkVersionStragyMap.forEach((key, value) -> {
if (key.isCurrentVersion()) {
value.run();
}
});
}
使用时指定不同的策略:
Map<JreEnum, Runnable> jdkVersionStragyMap = new HashMap<>();
jdkVersionStragyMap.put(JreEnum.JAVA_8, () -> System.out.println("java8"));
jdkVersionStragyMap.put(JreEnum.JAVA_9, () -> System.out.println("java9"));
jdkVersionStragyMap.put(JreEnum.JAVA_10, () -> System.out.println("java10"));
execute(jdkVersionStragyMap);
上述使用的JreEnum在http://stream-query.dromara.org/ 中存在
Java 8 API
添加了一个新的抽象称为流Stream
,可以让你以一种声明的方式处理数据。方法全是传入函数作为参数,来达到我们的目的。
https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html
// 声明式编程是告诉计算机需要计算“什么”而不是“如何”去计算
// 现在,我想要一个List,包含3个数字6
List<Integer> sixSixSix =
// 我想要:
Stream
// 数字6
.generate(() -> 6)
// 3个
.limit(3)
// 最后收集起来转为List
.collect(Collectors.toList());
sixSixSix.forEach(System.out::print);
Stream
使用一种类似用 SQL
语句从数据库查询数据的直观方式来提供一种对 Java
集合运算和表达的高阶抽象。
// 就像sql里的排序、截取
// 我要把传入的list逆序,然后从第五个(元素下标为4)开始取值,取4条
abc = abc.stream()
// 排序(按照自然顺序的逆序)
.sorted(Comparator.reverseOrder())
// 从下标为4开始取值
.skip(4)
// 取4条
.limit(4)
// 最后收集起来转为List
.collect(Collectors.toList());
System.out.println("我要把传入的list逆序,然后从第五个(元素下标为4)开始取值,取4条");
abc.forEach(System.out::print);
System.out.println();
Stream API
可以极大提高Java
程序员的生产力,让程序员写出高效率、干净、简洁的代码。
/**
* 老办法实现一个list,存储3个6
*
* @return [6, 6, 6]
*/
private static List<Integer> oldSix() {
// 老办法
List<Integer> sixSixSix = new ArrayList<>(3);
sixSixSix.add(6);
sixSixSix.add(6);
sixSixSix.add(6);
System.out.println("老办法实现一个list,存储3个6");
for (Integer integer : sixSixSix) {
System.out.print(integer);
}
System.out.println();
return sixSixSix;
}
/**
* 新方法实现一个list,存储3个6
*
* @return [6, 6, 6]
*/
private static List<Integer> newSix() {
List<Integer> sixSixSix = Stream.generate(() -> 6).limit(3).collect(Collectors.toList());
System.out.println("新方法实现一个list,存储3个6");
sixSixSix.forEach(System.out::print);
System.out.println();
return sixSixSix;
}
这种风格将要处理的元素集合看作一种流, 流在管道中传输, 并且可以在管道的节点上进行处理, 比如筛选, 排序,聚合等。
// 管道中传输,节点中处理
int pipe = abc.stream()
// 筛选
.filter(i -> i > 'G')
// 排序
.sorted(Comparator.reverseOrder())
.mapToInt(Object::hashCode)
// 聚合
.sum();
System.out.println("将26个字母组成的集合过滤出大于'G'的,逆序,再获取hashCode值,进行求和");
System.out.println(pipe);
元素流在管道中经过中间操作(intermediate operation
)的处理,最后由最终操作(terminal operation
)得到前面处理的结果。
// 将26个大写字母Character集合转换为String然后转换为小写字符
List<String> terminalOperation = abc.stream()
// 中间操作(intermediate operation)
.map(String::valueOf).map(String::toLowerCase)
// 最终操作(terminal operation)
.collect(Collectors.toList());
System.out.println("26个大写字母Character集合,转换成String然后转换为小写字符,收集起来");
terminalOperation.forEach(System.out::print);
System.out.println();
再介绍一下collect函数里的参数`Collector`:
https://docs.oracle.com/javase/8/docs/api/java/util/stream/Collector.html
Collector通常是作为Stream的collect方法的参数,通过使用Collectors可以创建一些预设的Collector例如上方提到的
list.stream().collect(Collectors.toList())
则是将流转换收集起来为List集合,Collectors还预设了非常多的常用收集器,基本满足大多数场景如Collectors.toMap、Collectors.groupingBy等,此处回答不做过多展开,继续回答一下Collector的五个方法,除了characteristics以外,其他四个方法均返回函数式接口
1. supplier ,意义是用于指定初始值,也可用于指定具体类型,可以传入lambda表达式如:
HashMap::new、()-> new ArrayList(88)等
2. accumulator,返回值是BiConsumer类型,意义为传入具体的收集操作,例如此处的lambda包含两个参数为
map(需要收集到的map)和item(每一个元素)
逻辑为将item.toString作为key,item作为value放入map
(map, item) -> {
map.put(item.toString(), item);
}
3. combiner,返回BinaryOperator类型的函数式接口,是一个可选的参数,可选不一定代表可以传入null,而指的是lambda中可以随便写,例如传入(lastMap, curMap) -> null
这个参数的意义是在“并行流”场景下,将多线程返回的多个结果进行合并,如果是“串行流”,则不会调用lambda中的方法。此处讲一下并行流和串行流:
因为Stream流只有在 结束操作(collect、reduce、forEach等) 时才会真正触发执行以往的 中间操作 (filter、map、flatMap等)
它分为串行流和并行流 并行流会使用拆分器(java.util.Spliterator)将操作拆分为多个异步任务(java.util.concurrent.ForkJoinTask)执行 这些异步任务默认使用(java.util.concurrent.ForkJoinPool)线程池进行管理
拆分后的任务,由于是异步并行执行,所以每个异步任务会返回一个结果,宏观就是会返回多个结果,最终将这些结果收集起来,所以需要使用combiner,使用例子:
(lastMap, curMap) -> {
lastMap.putAll(curMap);
return lastMap;
}
如果只是在串行流(同步场景)使用,这个参数对应的lambda就不会执行
4. finisher,意义为最终转换,返回Function,是在收集结束后执行,例:
map -> {
return Collections.unmodifiableMap(map);
}
不一定是相同类型,不同类型也可以
map -> {
return map.values();
}
5. characteristics,表示特征,返回值是一个Set,里面装着Characteristics类型的枚举
CONCURRENT允许并发执行的
UNORDERED没有指定特定的顺序的
IDENTITY_FINISH中间步骤和结束步骤一致
这部分主要是用于描述特征,在执行时如果有相应的特征,会走相应的执行流程
然后是三个泛型
T: 元素类型,流里的每一个元素的具体类型
A: 中间类型,用于收集元素的对象/集合的类型
R: 最终类型,通常和中间类型一致,但如果有最终操作finisher,会改变最终类型
这里列举一个完整用法:
Collector<Object, Map<String, Object>, Map<String, Object>> mapCollector =
Collector.of(HashMap::new,
(map, item) -> map.put(item.toString(), item),
(lastMap, curMap) -> {
lastMap.putAll(curMap);
return lastMap;
}, Collections::unmodifiableMap,
Collector.Characteristics.IDENTITY_FINISH);
Map<String, Object> map = Stream.of(1, 2, 3).collect(mapCollector);
原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。
原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。