Java 8 新特性之 Lambda表达式-CSDN博客

Lambda的出现就是为了增强Java面向过程编程的深度和灵活性。今天就来分享一下在Java中经常使用到的几个示例，通过对比分析，效果应该会更好。

–

1、实现Runnable线程案例

其存在的意义就是用Lambda来代替匿名类，如下：

// before java 8
new Thread(new Runnable(){
@Override
public void run(){
    System.out.println("Before Java 8");
}
}

// Java 8 way
new Thread(()-> System.out.println("Java 8 Way"););

我们可以使用下面的语法来完成Lambda的书写：

（params) -> expression
(params) -> statement
(params) -> {statements}
如果表达式不需要参数，那么可以简写如下：
() -> Ssytem.out.println("Something Here!");

2、实现事件处理

这里拿Swing编程来举例，主要的作用是简化事件监听器的代码书写。

// Before java 8
JButton button = new JButton("Show");
button.addActionListener(new ActionListener(){

    @Override
    public void actionPerformed(ActionEvent e){
        System.ut.println("Before Java 8");
    }
});

// Java 8 Way
button.addActionListener((e)-> {
    System.out.println("Java 8 Way");
};

不难看出，使用Lambda来代替匿名类是一件很优雅的事情。

3、使用Lambda表达式遍历List集合

遍历输出一个集合是一件很简单但是很繁琐的事情，但是有了Lambda之后，一切。又将变的优雅起来。

// Before Java 8
List ls = Arrays.asList("Lambdas","Default Method","Stream API","Date and Time Api");

for(String item : ls){
    System.out.println(item);
}

// Java 8 Way
List ls = Arrays.asList("Lambdas","Default Method","Stream API","Date and Time Api");
// 这里很重要，因为输出语句后面没有那个分号！！！
ls.forEach(item -> System.out.println(item));

4、使用Lambda表达式和函数接口

为了使得Java支持函数编程，Java8 加入了一个新的包java.util.function,其中有一个接口java.util.function.Predicate 是支持Lambda函数编程。

@Test
    public void test6() throws Exception {
        List<String> languages = Arrays.asList("C", "C++", "Java", "HTML", "CSS", "JavaScript", "C#", "MySQL");
        List<String> result = languages.stream().filter(item -> item.startsWith("J")).collect(Collectors.toList());
        System.out.println(languages.toString());
        System.out.println("---------------co" + "mpared result--------------");
        System.out.println("With J:");
        System.out.println(result.toString());
    }

上面的filter(item -> item.startWith(“J”))就是对此接口的简单的使用，这便是因为Lambda支持接口调用的体现。

详细的操作方式，我们可以参考Stream API来进行更加复杂的操作。

5、较复杂的结合Predicate接口的使用

此处主要演示的是结合流操作，类似于Linux的管道命令。

Predicate<String> startsWithJ = (n) -> n.startsWith("J");
 Predicate<String> fourLetterLong = (n) -> n.length() == 4;

 names.stream()
      .filter(startsWithJ.and(fourLetterLong))
      .forEach((n) -> System.out.print("\nName, which starts with
            'J' and four letter long is : " + n));

在流操作的整个过程中，StreamAPI内使用的就是我们定义好的Predicate实现。是不是感觉很方便啦。

6、使用Lambda实现Map和Reduce

类比Python中的可变数组，Java8 的Map就是实现了类似的功能。我们可以方便的借助Lambda来实现元素信息的改变。

// Before Java 8
List costBeforeTax = Arrays.asList(100,200,300,400,500);
for(Integer cost: costBeforeTax){
    double price = cost+.12*cost;
    System.out.println(price);
}

// Java 8 Way
List costBeforeTax = Arrays.asList(100,200,300,40,500);
costBeforeTax.stream().map((cost)-> cost+.12*cost).forEach(System.out.println(cost));

reduce() 是将集合中所有的值结合,汇聚到一个值中，Reduce类似SQL语句中的sum(),avg(),count()等等。

// Applying 12% VAT on each purchase
// Old way:
List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
double total = 0;
for (Integer cost : costBeforeTax) {
 double price = cost + .12*cost;
 total = total + price;

}
System.out.println("Total : " + total);

// New way:
List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
double bill = costBeforeTax.stream().map((cost) -> cost + .12*cost)
                                    .reduce((sum, cost) -> sum + cost)
                                    .get();
System.out.println("Total : " + bill);

Output
Total : 1680.0
Total : 1680.0

7.通过filtering 创建一个字符串String的集合

Filtering是对大型Collection操作的一个通用操作，Stream提供filter()方法，接受一个Predicate对象，意味着你能传送lambda表达式作为一个过滤逻辑进入这个方法：

// Create a List with String more than 2 characters
List<String> filtered = strList.stream().filter(x -> x.length()> 2)
                                        .collect(Collectors.toList());
System.out.printf("Original List : %s, filtered list : %s %n", 
                  strList, filtered);

Output :
Original List : [abc, , bcd, , defg, jk], filtered list : [abc, bcd, defg]

8、对集合中的每个元素应用函数

// Convert String to Uppercase and join them using coma
List<String> G7 = Arrays.asList("USA", "Japan", "France", "Germany", 
                                "Italy", "U.K.","Canada");
String G7Countries = G7.stream().map(x -> x.toUpperCase())
                                .collect(Collectors.joining(", "));
System.out.println(G7Countries);

Output : 
USA, JAPAN, FRANCE, GERMANY, ITALY, U.K., CANADA
上面是将字符串转换为大写，然后使用逗号串起来。

9、通过复制不同的值创建一个子列表

使用Stream的distinct()方法过滤集合中的重复性的元素。

// Create List of square of all distinct numbers
List<Integer> numbers = Arrays.asList(9, 10, 3, 4, 7, 3, 4);
List<Integer> distinct = numbers.stream().map( i -> i*i).distinct()
                                         .collect(Collectors.toList());
System.out.printf("Original List : %s,  Square Without duplicates :
                   %s %n", numbers, distinct);

Output :
Original List : [9, 10, 3, 4, 7, 3, 4],  Square Without 
                                         duplicates : [81, 100, 9, 16, 49]

10、计算List中的元素的最大值，最小值，总和以及平均值

@Test
    public void test7() throws Exception {
        List<Integer> ls = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        IntSummaryStatistics stats = ls.stream().mapToInt((x)->x).summaryStatistics();

        System.out.println("Max:"+ stats.getMax());
        System.out.println("Min:"+ stats.getMin());
        System.out.println("Avg:"+ stats.getAverage());
        System.out.println("SUm:"+ stats.getSum());
    }