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)  

解释：

1. 参数类型省略–绝大多数情况，编译器都可以从上下文环境中推断出lambda表达式的参数类型。例如上面的第二条 x 和第三条 （x，y） 都没声明类型。
2. 当lambda表达式的参数个数只有一个，可以省略小括号。 如上面 第二条的 x
3. 当lambda表达式只包含一条语句时，可以省略大括号、return和语句结尾的分号。如上面的返回都没有 return 这东西。
4. 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 最重要的特性，既能简便了代码，也充分利用了现代多核的特性，各方面都提升了效率。

总结：

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

参考：

1. Java8  为什么需要Lambda 表达式：http://developer.51cto.com/art/201304/387681.htm

2. Java8 初体验（一） lambda 表达式语法： http://ifeve.com/lambda/