Java 8 Lambda

最近查找资料学习时，发现例子中有好多地方用到了lambda表达式，所以今天学习记录一下。

推荐一个youtube的视频，讲解的非常不错。国内的伙伴有可能需要fan qiang才能看到。Good luck！！！

https://www.youtube.com/watch?v=gpIUfj3KaOc&list=PLqq-6Pq4lTTa9YGfyhyW2CqdtW9RtY-I3&index=1

Lambda表达式

它可以看做是函数型编程，那么java中函数定义就用接口来担当，所以，用到Lambda的时候需要使用一个接口。Lambda相关的语法规则也在下面代码中补充。

public class LamdbaDemo01 {

    public static void main(String[] args) {

        // new Thread( () -> System.out.println("--")).start();
        MyLambda greet = () -> System.out.println("Hello World!");
        greet.foo();
        // MyAdd myAdd = (int i, int j) -> i + j; 
        // 因为参数的变量名称一致，所以参数的变量类型可以省略
        MyAdd myAdd = (i, j) -> i + j; 
        System.out.println(myAdd.add(2, 3));
        
        // 当参数只有一个的时候可以省略（） ， 此外当箭头右侧的代码只用一行的时候，可以省略{}
        MyLength myLength = s -> s.length();
        System.out.println(myLength.leng("Hello world!"));
    }
}

// 接口中只能有一个方法，这是使用Lambda表达式的要求
interface MyLambda {
    void foo();
}

interface MyAdd {
    int add(int i, int b);
}

interface MyLength {
    int leng(String s);
}

接下来看一个例子：

public interface Condition {
        boolean test (Person p);
}

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Unit1ExercistWithJava7 {

    public static void main(String args[]) {
        
    List<Person> list = Arrays.asList(
            new Person ("Charles", "Dickens", 60),
            new Person ("Lewis", "Carrol", 42),
            new Person ("Thamos", "Cayloe", 51),
            new Person ("Charlotte", "Brote", 45),
            new Person ("Matthew", "Aroid", 39)
            );
    
    // step 1: sort list by lastName
    Collections.sort(list, new Comparator<Person>(){
        @Override
        public int compare(Person o1, Person o2) {
            return o1.getLastName().compareTo(o2.getLastName());
        }
    } );
    
    // step 2: Create a method that print all elements in the list
    printConditionally (list, new Condition(){
        @Override
        public boolean test(Person p) {
            return true;
        }
    });
    
    System.out.println("-------------------------");
    // step 3: Create a method that prints all people whose lastName beginning whie C
    printConditionally(list, new Condition(){
        @Override
        public boolean test(Person p) {
            return p.getLastName().startsWith("C");
        }
    });
    }

    private static void printConditionally (List<Person> list, Condition condition) {
        for (Person p : list) {
            if (condition.test(p)) {
                System.out.println(p);
            }
        }
    }
}

上面的例子很简单，就是创建一个接口，里面有test方法，之后创建了一个List，根据自己的需要将list中满足一定条件的值取出。这里例子是用Java7写的。

接下来看Lambda表达式的例子：

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Unit1ExercistWithLambda {

    public static void main(String args[]) {
        
    List<Person> list = Arrays.asList(
            new Person ("Charles", "Dickens", 60),
            new Person ("Lewis", "Carrol", 42),
            new Person ("Thamos", "Cayloe", 51),
            new Person ("Charlotte", "Brote", 45),
            new Person ("Matthew", "Aroid", 39)
            );
    
    // step 1: sort list by lastName
    // 使用Lambda表达式时，刚开始写不出，可以先写出匿名类的形式，之后在这个基础上再进行修改，慢慢的就会写了
    // 为什么括号里直接省略掉参数类型，你尅看用Java8实现的例子
    Collections.sort(list, (p1, p2) -> p1.getLastName().compareTo(p2.getLastName()));
    
    // step 2: Create a method that print all elements in the list
    printConditionally (list, (p) -> true);
    
    System.out.println("-------------------------");
    // step 3: Create a method that prints all people whose lastName beginning whie C
    printConditionally(list, (p) -> p.getLastName().startsWith("C"));
    }

    private static void printConditionally (List<Person> list, Condition condition) {
        for (Person p : list) {
            if (condition.test(p)) {
                System.out.println(p);
            }
        }
    }
}

在这个例子中，条件判断的实现，通过Lambda表达式来实现，可以看到代码量的减少，这是它的一个好处。

我们现在思考一下使用Lambda表达式的步骤。首先需要有个接口，接口中，必须有且只有一个方法，这是使用Lambda的前提条件。

之后，你就可以编写接口的实现部分。

其实我们也可以不自己创建接口，使用java.util.function 包 里面存在的接口。

比如上面Lambda表达式的例子可以修改成如下：

private static void printConditionally (List<Person> list, Predicate<Person> predict) {
        for (Person p : list) {
            if (predict.test(p)) {
                System.out.println(p);
            }
        }
    }

这样的话，接口虽然修改了，但是Lambda实现的部分，完全不用任何修改，这是Lambda的另一个优势。

我们还在可以在printConditionally方法中再添加一个功能接口,例子如下：

    // step 2: Create a method that print all elements in the list
    printConditionally (list, (p) -> true, (p) -> System.out.println(p));
    
    System.out.println("-------------------------");
    // step 3: Create a method that prints all people whose lastName beginning whie C
    printConditionally(list, (p) -> p.getLastName().startsWith("C"), (p) -> System.out.println(p));
    }

    private static void printConditionally (List<Person> list, Predicate<Person> predict, Consumer<Person> consumer) {
        for (Person p : list) {
            if (predict.test(p)) {
                consumer.accept(p);
            }
        }
    }

个人感受是，Lambda表达式使代码解耦，提高结构的灵活性。

Exception的捕获

无例子不说话：

import java.util.function.BiConsumer;

public class Unit1ExercistWithLambdaWithException {

    public static void main(String args[]) {
        int [] someNumbers = {1,2,3,4};
        int key = 0;
        /*第二种设想是在 process 方法中的第三个参数外侧添加try catch
        但是那样的话，跟java 7的匿名类有些相似，而且，又会增加耦合度。
        最后，使用现在的，第三种方式来捕获异常。可能会觉得麻烦，跟之前的两种方法没什么区别，
        但是第三种方式，我觉得有些像AOP，而且这样对结构的入侵要少*/
        process (someNumbers, key, wrapperLambda((k ,v) -> System.out.println(k/v)));
    }

    private static BiConsumer<Integer, Integer> wrapperLambda(BiConsumer<Integer, Integer> wrapper) {
        return (k ,v) -> {
            try {
                wrapper.accept(k, v);
            } catch (ArithmeticException e) {
                System.out.println("Exception caught in wrapper lambda");
            }
        };
    }

    private static void process(int[] someNumbers, int key, BiConsumer<Integer, Integer> consumer) {
        // Exception的捕捉的第一种设想是在下面代码块的外侧追加try catch 来捕捉异常
        // 但是，这只是个抽象的process的方法，不能确定实现类中出现的异常，所以在这里捕捉，不合理
        for (int i : someNumbers) {
            consumer.accept(i, key);
        }
    }
}

不知道怎么该如何讲述这个部分，例子有注释，大家不懂的地方，再留言谈论。

方法的引用

例子如下：

public class MethodReference {

    public static void main(String[] args) {

        // 下面两行的代码是等价的
        // Thread thread = new Thread(() -> printMessage());
        Thread thread = new Thread(MethodReference::printMessage);
        thread.start();
    }

    private static void printMessage() {
        System.out.println("Hello World!");
    }

}

 Unit1ExercistWithLambda3.java 中的例子中的部分代码：

// printConditionally(list, (p) -> p.getLastName().startsWith("C"), (p) -> System.out.println(p));
    
    printConditionally(list, (p) -> p.getLastName().startsWith("C"), System.out::println);

foreach

import java.util.Arrays;
import java.util.List;

public class CollectionIterationExample {

    public static void main(String[] args) {
        List<Person> list = Arrays.asList(
                new Person ("Charles", "Dickens", 60),
                new Person ("Lewis", "Carrol", 42),
                new Person ("Thamos", "Cayloe", 51),
                new Person ("Charlotte", "Brote", 45),
                new Person ("Matthew", "Aroid", 39)
                );
        
        System.out.println("Using for loop");
        for (int i=0; i<list.size();i++) {
            System.out.println(list.get(i));
        }
        
        System.out.println("Using for each loop");
        for (Person person : list) {
            System.out.println(person);
        }
        
        // Java8 Lambda
        System.out.println("Using for loop");
        list.forEach(p -> System.out.println(p));
        System.out.println("--------------");
        list.forEach(System.out::println);
    }

}

Stream

public class StreamExcample {

    public static void main(String[] args) {

        List<Person> list = Arrays.asList(
                new Person ("Charles", "Dickens", 60),
                new Person ("Lewis", "Carrol", 42),
                new Person ("Thamos", "Cayloe", 51),
                new Person ("Charlotte", "Brote", 45),
                new Person ("Matthew", "Aroid", 39)
                );
        
        System.out.println("-------------------------");
        list.stream()
        .filter(p -> p.getLastName().startsWith("C"))
        .forEach(p -> System.out.println(p));
        System.out.println("-------------------------");
        long count = list.stream()
        .filter(p -> p.getFirstName().startsWith("M"))
        .count();
        System.out.println(count);
    }
}


-------------------------
firstName :Lewis lastName ：Carrol age 42
firstName :Thamos lastName ：Cayloe age 51
-------------------------
1

里面的Stream等一些8中新出现的东西还是蛮有趣的，以后编码时会尝试使用，棒棒的！

推荐看篇头推荐的那个youbute的链接视频，very excellent for tutorials of Lambda