Java JVM（八）：Lambda 简介

一. 为什么需要lambda
二. lambda 语法
三. lambda 配合 Function 等接口的使用
四. lambda 配合 集合的使用


一. 为什么需要 lambda

        Java是一种面向对象的编程方式。而
lambda 属于一种 函数式编程。Java 为什么要引入？
        1.
结合函数式接口，可以消除很多重复性代码。例如：

public class Test {
public static void main(String[] args) throws InterruptedException {
String name = "";
String name1 = "12345";
System.out.println(validInput(name, inputStr -> inputStr.isEmpty() ? "名字不能为空":inputStr));
System.out.println(validInput(name1, inputStr -> inputStr.length() > 3 ? "名字过长":inputStr));
}

public static String validInput(String name,Function<String,String> function) {
return function.apply(name);
}
}

        上述代码使用了lambda
表达式，如果不用这种方式，需要写比较多的 if 语句。
        再比如，lambda 表达式可以代替匿名内部类。

        
        2.
结合 集合的流式操作可以充分利用 CPU，利用现代多核的特性，提升效率。例如：

// 统计年龄在25-35岁的男女人数、比例
public void boysAndGirls(List<Person> persons) {
Map<Integer, Integer> result = persons.parallelStream().filter(p -> p.getAge()>=25 && p.getAge()<=35).
collect(
Collectors.groupingBy(p->p.getSex(), Collectors.summingInt(p->1))
);
System.out.print("boysAndGirls result is " + result);
System.out.println(", ratio (male : female) is " + (float)result.get(Person.MALE)/result.get(Person.FEMALE));
}

        如上的 parallelStream 方法，即获取并行流，以达到充分利用多核的特性。

二. lambda 语法

        由三部分组成： 参数列表，箭头(
->)，表达式或者语句块。
简单例子：

// 1. 不需要参数,返回值为 5
() -> 5
// 2. 接收一个参数(数字类型),返回其2倍的值
x -> 2 * x
// 3. 接受2个参数(数字),并返回他们的差值
(x, y) -> x – y
// 4. 接收2个int型整数,返回他们的和
(int x, int y) -> x + y
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s)

解释：

参数类型省略–绝大多数情况，编译器都可以从上下文环境中推断出lambda表达式的参数类型。例如上面的第二条 x 和第三条 （x，y） 都没声明类型。
当lambda表达式的参数个数只有一个，可以省略小括号。 如上面 第二条的 x
当lambda表达式只包含一条语句时，可以省略大括号、return和语句结尾的分号。如上面的返回都没有 return 这东西。
lambda 表达式 可以访问外部变量（外部变量不可变）。

三. lambda 配合 Function 等接口的使用

如下，配合 Function，Consumer，Predicate 接口的使用，减少了代码的冗余：

public class Test {
public static void main(String[] args) throws InterruptedException {
String name = "";
String name1 = "12345";
System.out.println(validInput(name, inputStr -> inputStr.isEmpty() ? "名字不能为空":inputStr));
System.out.println(validInput(name1, inputStr -> inputStr.length() > 3 ? "名字过长":inputStr));
}

public static String validInput(String name,Function<String,String> function) {
return function.apply(name);
}
}

public class Test {
public static void main(String[] args) throws InterruptedException {
String name = "";
String name1 = "12345";

validInput(name, inputStr ->
System.out.println(inputStr.isEmpty() ? "名字不能为空":"名字正常"));
validInput(name1, inputStr ->
System.out.println(inputStr.isEmpty() ? "名字不能为空":"名字正常"));

}
public static void validInput(String name,Consumer<String> function) {
function.accept(name);
}
}

public class Test {
public static void main(String[] args) throws InterruptedException {
String name = "";
String name1 = "12";
String name2 = "12345";

System.out.println(validInput(name,inputStr ->  !inputStr.isEmpty() &&  inputStr.length() <= 3 ));
System.out.println(validInput(name1,inputStr ->  !inputStr.isEmpty() &&  inputStr.length() <= 3 ));
System.out.println(validInput(name2,inputStr ->  !inputStr.isEmpty() &&  inputStr.length() <= 3 ));

}
public static boolean validInput(String name,Predicate<String> function) {
return function.test(name);
}
}

四.lambda 配合 集合的使用

//给出一个String类型的数组，求其中所有不重复素数的和
public void distinctPrimarySum(String... numbers) {
List<String> l = Arrays.asList(numbers);
int sum = l.stream()
.map(e -> new Integer(e))
.filter(e -> Primes.isPrime(e))
.distinct()
.reduce(0, (x,y) -> x+y); // equivalent to .sum()
System.out.println("distinctPrimarySum result is: " + sum);

        Ps： lambda 配合 集合的使用应该是 JDK8 最重要的特性，既能简便了代码，也充分利用了现代多核的特性，各方面都提升了效率。

总结：

引入lambda：代码更简单，配合其他使用效率更高。
lambda语法：基本组成由 参数列表，箭头，表达式组成。如果参数列表和表达式简单，还可以把括号什么的进一步省略。
Lambda的使用：一般配合 Function，Consumer，Predicate或者自定义的函数式接口使用，使得代码更加方便；同时也配合集合使用，提升效率，提高阅读性。

参考：
1. Java8  为什么需要Lambda 表达式：http://developer.51cto.com/art/201304/387681.htm
2. Java8 初体验（一） lambda 表达式语法：http://ifeve.com/lambda/