摘要：在云服务业务开发中，长于应用代码新个性，往往能让开发效率大大晋升，这里简略介绍下 lambad 表达式及函数式接口个性。
在云服务业务开发中，长于应用代码新个性，往往能让开发效率大大晋升，这里简略介绍下 lambad 表达式及函数式接口个性。
1.Lambda 表达式
Lambda 表达式也被称为箭头函数、匿名函数、闭包。他容许把函数作为一个办法的参数（函数作为参数传递到办法中），体现出轻量级函数式编程思维。
为什么引入 lambda？
Model Code as Data，编码及数据，尽可能轻量级的将代码封装为数据。
解决方案：接口 & 实现类（匿名外部类）
存在问题：语法冗余，this 关键字、变量捕捉、数据管制等
public static void main (String[] args){
// 1. 传统模式下，新线程的创立
new Thread (new Runnable() {
@Override
public void run() {System.out.println("threading..." + Thread.currentThread().getId())
}
}).start();
// 2. lambda 表达式优化线程模式
new Thread(()->{System.out.println("lambda threading..." + Thread.currentThread().getId());
})
}
复制代码- 不是解决未知问题的新技术
- 对现有问题的语义化优化
- 须要依据理论需要思考性能问题
2. 函数式接口（Functional Interface）
函数式接口就是 Java 类型零碎中的接口，是只蕴含一个形象办法的非凡接口（能够有很多非形象办法）。
语言化检测注解：@FunctionalInterface 检测合法性
java1.8 反对接口内蕴含：形象办法、默认接口办法、动态接口办法、来自 Object 继承的办法
/**
* 用户身份认证标记接口
*/
@FunctionalInterface
public interface IUserCredential {
/**
* 通过用户账号，验证用户身份信息的接口
* @param username 要验证的用户账号
* @return 返回身份信息[系统管理员、用户管理员、普通用户]
*/
String verifyUser(String username);
default String getCredential(String username) {if ("admin".equals(username)) {return "admin + 系统管理员用户";} else if("manager".equals(username)){return "manager + 用户管理员用户";} else {return "commons + 一般会员用户";} } String toString(); /** * 音讯合法性验证办法 * @param msg 要验证的音讯 * @return 返回验证后果 */ static boolean verifyMessage(String msg) {if (msg != null) {return true;} return false; }} // 匿名外部类，实现接口的形象办法 IUserCredential ic = new IUserCredential() { @Override
public String verifyUser(String username) {return "admin".equals(username)?"管理员":"会员"; } }; // lambda 表达式是函数式接口的一种简略实现 IUserCredential ic2 = (username) -> {return "admin".equals(username)?"lbd 管理员": "lbd 会员"; };
复制代码JDK 1.8 之前已有的函数式接口:
- java.lang.Runnable
- java.util.concurrent.Callable
- java.security.PrivilegedAction
- java.util.Comparator
- java.io.FileFilter
- more
JDK 1.8 新减少的函数接口：
-
java.util.function
/* java.util.function 提供了大量的函数式接口 Predicate 接管参数 T 对象，返回一个 boolean 类型后果 Consumer 接管参数 T 对象，没有返回值 Function 接管参数 T 对象，返回 R 对象 Supplier 不承受任何参数，间接通过 get()获取指定类型的对象 UnaryOperator 接口参数 T 对象，执行业务解决后，返回更新后的 T 对象 BinaryOperator 接口接管两个 T 对象，执行业务解决后，返回一个 T 对象 */ Predicate<String> pre = (String username) -> {return "admin".equals(username); }; System.out.println(pre.test("manager")); Consumer<String> con = (String message) -> {System.out.println("要发送的音讯：" + message); }; con.accept("lambda expression."); Function<String, Integer> fun = (String gender) -> {return "male".equals(gender)?1:0; }; System.out.println(fun.apply("male")); Supplier<String> sup = () -> {return UUID.randomUUID().toString();}; System.out.println(sup.get()); UnaryOperator<String> uo = (String img)-> {img += "[100x200]"; return img; }; System.out.println(uo.apply("原图 --")); BinaryOperator<Integer> bo = (Integer i1, Integer i2) -> {return i1 > i2? i1: i2;}; System.out.println(bo.apply(12, 13)); 复制代码
3.lambda 表达式的根本语法
根本语法
- 申明：就是和 lambda 表达式绑定的接口类型
- 参数：蕴含在一对圆括号中，和绑定的接口中的形象办法中的参数个数及程序统一。
- 操作符：->
- 执行代码块：蕴含在一对大括号中，呈现在操作符号的右侧
[接口申明] = (参数) -> {执行代码块};
// 没有参数，没有返回值的 lambda 表达式绑定的接口
interface ILambda1{void test();
}
// 带有参数，没有返回值的 lambda 表达式
interface ILambda2{void test(String name, int age);
}
// 带有参数，带有返回值的 lambda 表达式
interface ILambda3 {int test(int x, int y);
}
ILambda1 i1 = () -> System.out.println("hello boys!");
i1.test();
ILambda2 i21 = (n, a) -> {System.out.println(n + "say: my year's old is " + a);
};
i21.test("jerry", 18);
ILambda2 i22 = (n, a) ->
System.out.println(n + "说：我往年" + a + "岁了.");
i22.test("tom", 22);
ILambda3 i3 = (x, y) -> {
int z = x + y;
return z;
};
System.out.println(i3.test(11, 22));
ILambda3 i31 = (x, y) -> x + y;
System.out.println(i31.test(100, 200));
复制代码总结：
- lambda 表达式，必须和接口进行绑定。
- lambda 表达式的参数，能够附带 0 个到 n 个参数，括号中的参数类型能够不必指定，jvm 在运行时，会主动依据绑定的形象办法中的参数进行推导。
- lambda 表达式的返回值，如果代码块只有一行，并且没有大括号，不必写 return 关键字，单行代码的执行后果，会主动返回。如果增加了大括号，或者有多行代码，必须通过 return 关键字返回执行后果。
变量捕捉
- 匿名外部类型变量捕捉
-
lambda 表达式变量捕捉
// 1. 匿名外部类型中对于变量的拜访 String s1 = "全局变量"; public void testInnerClass() { String s2 = "局部变量"; new Thread(new Runnable() { String s3 = "外部变量"; @Override public void run() { // 拜访全局变量 // System.out.println(this.s1);// this 关键字~ 示意是以后外部类型的对象（报错）System.out.println(s1); System.out.println(s2);// 局部变量的拜访，不能对局部变量进行数据的批改 final // s2 = "hello"; System.out.println(s3); System.out.println(this.s3); } }).start();} // 2. lambda 表达式变量捕捉 public void testLambda() { String s2 = "局部变量 lambda"; new Thread(() -> { String s3 = "外部变量 lambda"; // 拜访全局变量 // 不再建设对象域 System.out.println(this.s1);// this 关键字，示意的就是所属办法所在类型的对象 // 拜访局部变量 System.out.println(s2); // s2 = "hello";// 不能进行数据批改，默认推导变量的修饰符：final System.out.println(s3); s3 = "labmda 外部变量间接批改"; System.out.println(s3); }).start();} 复制代码
总结：Lambda 表达式优化了匿名外部类类型中的 this 关键字，不再独自建设对象作用域，表达式自身就是所属类型对象的一部分，在语法语义上应用更加简洁。
类型查看
对于语法雷同的表达式，Jvm 在运行的过程中，在底层通过解释及重构，进行类型的主动推导。
- 表达式类型查看
- 参数类型查看
办法重载
interface Param1 {void outInfo(String info);
}
interface Param2 {void outInfo(String info);
}
// 定义重载的办法
public void lambdaMethod(Param1 param) {param.outInfo("hello param1 imooc!");
}
public void lambdaMethod(Param2 param) {param.outInfo("hello param2 imooc");
}
test.lambdaMethod(new Param1() {
@Override
public void outInfo(String info) {System.out.println(info);
}
});
test.lambdaMethod(new Param2() {
@Override
public void outInfo(String info) {System.out.println("------");
System.out.println(info);
}
});
/*
lambda 表达式存在类型查看 -> 主动推导 lambda 表达式的指标类型
lambdaMethod() -> 办法 -> 重载办法
-> Param1 函数式接口
-> Param2 函数式接口
调用办法 -> 传递 Lambda 表达式 -> 主动推导 ->
-> Param1 | Param2
*/
// 报错 Ambigus Method call
// test.lambdaMethod((String info) -> {// System.out.println(info);
// });
复制代码总结：呈现办法重载的类型中参数都是函数式接口的状况，需应用匿名外部类实现代替 lambda 表达式。
底层构建原理
public class Test{public static void main(String args[]){ITest it = (message) -> System.out.println(message);
it.markUp("lambda!");
// new Test$$Lambda$1().markUp("lambda");
}
}
interface ITest{void markUp(String msg);
}
复制代码javac Test.java
javap -p Test.class (javap 反解析工具 - p 显示所有类与成员)
- java -Djdk.internal.lambda.dumpProxyClasses Test
- 申明一个公有静态方法，对 Lambda 表达式做一个具体的办法实现
- 申明一个 final 外部类型并实现接口
- 在实现接口后的重写办法中利用外部类调用该公有静态方法
4. 办法援用
办法援用提供了十分有用的语法，能够间接援用已有 Java 类或对象（实例）的办法或结构器。与 lambda 联结应用，办法援用能够使语言的结构更紧凑简洁，缩小冗余代码。
- 静态方法援用
- 实例办法援用
- 构造方法援用
5.Stream
- 新增加的 Stream 流—是一个来自数据源的元素队列并反对聚合操作。把真正的函数式编程格调引入到 Java 中。
- 不存储数据，也不批改原始源。
- Stream 应用一种相似用 SQL 语句从数据库查问数据的直观形式来提供一种对 Java 汇合运算和表白的高阶形象。
- Stream API 能够极大进步 Java 程序员的生产力，让程序员写出高效率、洁净、简洁的代码。
- 这种格调将要解决的元素汇合看作一种流，流在管道中传输，并且能够在管道的节点上进行解决，比方筛选，排序，聚合等。
- 元素流在管道中通过两头操作（intermediate operation）的解决，最初由最终操作 (terminal operation) 失去后面解决的后果。
// 1. for 循环实现 List list = new ArrayList(); for (String s : list) {if (s.length() > 3) {lista.add(s); } } System.out.println(lista);
// 2. 迭代器实现
List<String> listb = new ArrayList<>();
Iterator<String> it = list.iterator();
while(it.hasNext()) {String s = it.next();
if(s.length() > 3) {listb.add(s);
}
}
System.out.println(listb);
// 3. stream 实现
List listc = list.stream().filter(s->s.length()>3)
.collect(Collectors.toList());
System.out.println(listc);
复制代码几者关系
- lambda 表达式是传统办法的语法糖，简化并且革新传统外部类实现设计方案的另一种实现模式。
- 办法援用又是 lambda 根底上的语法糖，和 Stream 没有关系，简化办法调用的。
- Stream 是针对数据和汇合的强化优化操作，能够和 lambda 联合起来简化编码过程。
常见 API 介绍
1. 聚合操作
2.Stream 的解决流程
- 数据源
- 数据转换[可一到屡次转换]
- 获取后果
3. 获取 Stream 对象
- 从汇合或者数组中获取
Collection.stream(), 如 list.stream()
Collection.parallelstream(), 取得反对并发解决的流
Arrays.stream(T t)
- BufferReader
BufferReader.lines()-> stream()
- 动态工厂
java.util.stream.IntStream.range()..
java.nio.file.Files.walk()..
- 自定构建
java.util.Spliterator
- 更多的形式
Random.ints()
Pattern.spiltAsStream()..
4. 两头操作 API{intermediate}：
- 操作后果是一个 Stream 对象，所以两头操作可有一个或多个间断的两头操作，须要留神的是两头操作只记录操作形式，不做具体执行，直到完结操作产生时，才做数据的最终执行。
- 两头操作就是业务逻辑解决
- 操作过程分为有状态和无状态
无状态：即解决数据时，不受前置两头操作的影响
- map/filter/peek/parallel/sequential/unordered
- 有状态：即解决数据时，受前置两头操作的影响
- distant/sorted/limit/skip
5. 终结操作 | 完结操作{Terminal}
一个 steam 对象只能有一个 Terminal 操作。这个操作不可逆，一旦产生，就会实在解决数据生成对应后果
- 非短路操作: 以后的 Stream 对象必须解决完汇合中所有的数据，能力失去处理结果
forEach/forEachOrdered/toArray/reduce/collect/min/max/count/iterator
- 短路操作: 以后的 Stream 对象在处理过程中，一旦满足某个条件，就能够失去后果
anyMatch/AllMatch/noneMatch/findfirst/findAny 等
short-circuiting : 在无限大的 stream 中返回无限大的 stream 须要蕴含短路操作是有必要的
Stream 转换
// 1. 批量数据 -> Stream 对象
// 多个数据
Stream stream = Stream.of("admin", "tom", "jerry");
// 数组
String [] strArrays = new String[] {"xueqi", "biyao"};
Stream stream2 = Arrays.stream(strArrays);
// 列表
List<String> list = new ArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
Stream stream3 = list.stream();
// 汇合
Set<String> set = new HashSet<>();
set.add("aaa");
set.add("bbb");
set.add("ccc");
Stream stream4 = set.stream();
// Map
Map<String, Integer> map = new HashMap<>();
map.put("tom", 1000);
map.put("jerry", 1200);
map.put("shuke", 1000);
Stream stream5 = map.entrySet().stream();
//2. Stream 对象对于根本数据类型的性能封装
//int / long / double
IntStream.of(new int[] {10, 20, 30}).forEach(System.out::println); // 只做一次拆箱装箱
IntStream.range(1, 5).forEach(System.out::println);
IntStream.rangeClosed(1, 5).forEach(System.out::println);
// 3. Stream 对象 --> 转换失去指定的数据类型
// 数组
Object [] objx = stream.toArray(String[]::new);
// 字符串
String str = stream.collect(Collectors.joining()).toString();
System.out.println(str);
// 列表
//List<String> listx = (List<String>) stream.collect(Collectors.toList());
System.out.println(listx);
// 汇合
//Set<String> setx = (Set<String>) stream.collect(Collectors.toSet());
System.out.println(setx);
// Map
//Map<String, String> mapx = (Map<String, String>) stream.collect(Collectors.toMap(x->x, y->"value:"+y));
System.out.println(mapx);
复制代码Stream 常见操作
// Stream 中常见的 API 操作
List<String> accountList = new ArrayList<>();
accountList.add("tom");
accountList.add("jerry");
accountList.add("apha");
accountList.add("beta");
accountList.add("shuke");
// map() 两头操作，map()办法接管一个 Functional 接口
accountList = accountList.stream().map(x->"name:" + x).collect(Collectors.toList());
// filter() 增加过滤条件，过滤符合条件的用户
accountList = accountList.stream().filter(x-> x.length() > 3).collect(Collectors.toList());
// forEach 增强型循环
accountList.forEach(x-> System.out.println("forEach->" + x));
// peek() 两头操作，迭代数据实现数据的顺次处理过程
accountList.stream()
.peek(x -> System.out.println("peek 1:" + x))
.peek(x -> System.out.println("peek 2:" + x))
.forEach(System.out::println);// 合并多个过程 迭代只产生一次
accountList.forEach(System.out::println);
// Stream 中对于数字运算的反对
List<Integer> intList = new ArrayList<>();
intList.add(20);
intList.add(19);
intList.add(7);
intList.add(8);
intList.add(86);
intList.add(11);
intList.add(3);
intList.add(20);
// skip() 两头操作，有状态，跳过局部数据
intList.stream().skip(3).forEach(System.out::println);
// limit() 两头操作，有状态，限度输入数据量
intList.stream().skip(3).limit(2).forEach(System.out::println);
// distinct() 两头操作，有状态，剔除反复的数据
intList.stream().distinct().forEach(System.out::println);
// sorted() 两头操作，有状态，排序
// max() 获取最大值
Optional optional = intList.stream().max((x, y)-> x-y);
System.out.println(optional.get());
// min() 获取最小值
// reduce() 合并解决数据
Optional optional2 = intList.stream().reduce((sum, x)-> sum + x);
System.out.println(optional2.get());
复制代码6. 案例
问题一：将实例 List 转化为 Map
对于 List
来说，我须要将其形变为 Map<Table.id,Table>，用如下流解决代码
//Table 类
public class DmTable {
private Integer id;
private String tableName;
private String tableComment;
private Integer datasourceId;
private Integer directoryId;
private Boolean partitionFlag;
private Integer columnNum;
// ......
}
tableMap=TableList.stream().collect(Collectors.toMap(Table::getId, b -> b);
// 等效于
tableMap=TableList.stream().collect(Collectors.toMap(Table::getId, Function.identity()));// 静态方法 实现 return t -> t;
复制代码问题二：将汇合分成若干类别
应用问题一中的 Table 类，对于 List
，我须要将其依照 partitionFlag 分类，Collector 提供两种办法 partitioningBy()、groupingBy()。前者分成满足条件与不满足条件两类，后者可按条件分成若干类别的 Map。
Map<Boolean, List<Table>> tablePartition = tableList
.stream().collect(Collectors.partitioningBy(item -> item.getPartitionFlag() == true));
复制代码- 有的时候，咱们关注的不光是元素还有元素的个数，流解决能够再进行前期解决。
Map<Boolean, List
tablePartition = tableList .stream().collect(Collectors.partitioningBy(item -> item.getPartitionFlag() == true,Collectors.counting()));
可输入符合要求的个数。
groupingBy()可对字符串长度分组。
List<String> strings=Arrays.asList(“this”,”is”,”a”,”test”);
Map<Integer, List<String>> stringsMap = strings
.stream().collect(Collectors.groupingBy(String::length);
复制代码后果输入多分类的 map,key 值为字符串长度。
留神：如果是从数据库获取数据，务必将分组操作放在数据库中执行，java8 新增办法只适宜解决内存中的数据。
问题三：从 list 中失去某个特定的对象
取得 List
中 columnNum 最多的 table 对象
tableList.stream().sorted(comparingInt(Table::getColumnNum)).collect(Collectors.toList()).get(tableList.size() - 1);
复制代码增加两头操作 reversed() 可获取最小 columnNum 的对象
问题四：失去 Map<Table,Table.columnNum> 中最大 columnNum 的 table
List<Map.Entry<Table, Integer>> list = new ArrayList(tableMap.entrySet());
Collections.sort(list, (o1, o2) -> (o2.getValue() - o1.getValue()));
list.get(0).getKey();
复制代码7. 性能与平安
- 串行 Stream 的性能小于传统的 for 循环、迭代器
-
并行 Stream 的性能与传统的 for 循环、迭代器差不多，在解决对象（简单数据类型）的状况下，并行性能最佳
// 整数列表 List lists = new ArrayList(); // 减少数据 for (int i = 0; i < 1000; i++){lists.add(i); }
// 串行 Stream List<Integer> list2 = new ArrayList<>(); lists.stream().forEach(x->list2.add(x)); System.out.println(lists.size()); System.out.println(list2.size()); // 并行 Stream 线程不平安 失落 List<Integer> list3 = new ArrayList<>(); lists.parallelStream().forEach(x-> list3.add(x)); System.out.println(list3.size()); // collect 当并行执行时能够实例化、填充和合并多个两头后果，以放弃可变数据结构的隔离 List<Integer> list4 = lists.parallelStream().collect(Collectors.toList()); System.out.println(list4.size()); 复制代码
本文分享自华为云社区《如何善用函数式接口简化云服务业务代码开发》，原文作者：luanzhen。
点击关注，第一工夫理解华为云陈腐技术~