Java Lambda 表达式提升效率

• lambda 表达式的应用场景

• Stream 的应用场景

• Lambda/Stream 的进一步封装

自定义函数式接口（用 jdk 自带的函数式接口也可以）

https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html

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 返回值*/@Overridepublic String apply(Object o) {return o.toString();}
}Func<String, Integer> func = new Func<String, Integer>() {/*** 调用** @param s 参数* @return 返回值*/@Overridepublic Integer apply(String s) {return s.hashCode();}};

Lambda 这种简写的形式

java.util.stream (Java Platform SE 8 )

 Func<String, String> func1 = (String s) -> {return s.toUpperCase();};Func<String, String> func2 = (String s) -> s.toUpperCase();
Func<String, String> func3 = s -> s.toUpperCase();
Func<String, String> func4 = String::toUpperCase;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 自带的函数式接口写法

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() {// 有参数，返回值为booleanreturn 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;}}

Java 8 API 的抽象称为流 Stream

java.util.stream (Java Platform SE 8 )

    // 声明式编程是告诉计算机需要计算“什么”而不是“如何”去计算// 现在，我想要一个List，包含3个数字6List<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();/*** 老办法实现一个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();