0x00 例子

1、 用lambda表达式实现Runnable

import java.util.Arrays;

/**
 * Created by haicheng.lhc on 10/04/2017.
 *
 * @author haicheng.lhc
 * @date 2017/04/10
 */
public class Test {
    public static void main(String[] args) {
//        java8之前
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Before Java8, too much code for too little to do");
            }
        }).start();
//      java8之后
        new Thread( () -> System.out.println("In Java8, Lambda expression rocks !!") ).start();
    }
}

输出结果：

2、使用lambda表达式对列表进行迭代

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

/**
 * Created by haicheng.lhc on 10/04/2017.
 *
 * @author haicheng.lhc
 * @date 2017/04/10
 */
public class Test {
    public static void main(String[] args) {

        // Java 8之前：
        List<String> features = Arrays.asList("Lambdas", "Default Method", "Stream API", "Date and Time API");
        for (String feature : features) {
            System.out.println(feature);
        }

        // Java 8之后：
        List<String> features = Arrays.asList("Lambdas", "Default Method", "Stream API", "Date and Time API");
        features.forEach(n -> System.out.println(n));

        // 使用Java 8的方法引用更方便，方法引用由::双冒号操作符标示，
        features.forEach(System.out::println);
    }
}

3、使用lambda表达式和函数式接口Predicate

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

/**
 * Created by haicheng.lhc on 13/04/2017.
 *
 * @author haicheng.lhc
 * @date 2017/04/13
 */
public class TT {

    public static void main(String args[]) {
        List<String> languages = Arrays.asList("Java", "Scala", "C++", "Haskell", "Lisp");

        System.out.println("Languages which starts with J :");
        filter(languages, (str) -> str.startsWith("J"));

        System.out.println("Languages which ends with a ");
        filter(languages, (str) -> str.endsWith("a"));

        System.out.println("Print all languages :");
        filter(languages, (str) -> true);

        System.out.println("Print no language : ");
        filter(languages, (str) -> false);

        System.out.println("Print language whose length greater than 4:");
        filter(languages, (str) -> str.length() > 4);
    }

    public static void filter(List<String> names, Predicate<String> condition) {
        for (String name : names) {
            if (condition.test(name)) {
                System.out.println(name + " ");
            }
        }
    }
}

其中的filter可以实现的更加优雅

  public static void filter(List<String> names, Predicate<String> condition) {
        names.stream().filter((name) -> (condition.test(name))).forEach((name) -> {
            System.out.println(name + " ");
        });
    }

4、通过过滤创建一个String列表

过滤是Java开发者在大规模集合上的一个常用操作，而现在使用lambda表达式和流API过滤大规模数据集合是惊人的简单。流提供了一个 filter() 方法，接受一个 Predicate 对象，即可以传入一个lambda表达式作为过滤逻辑。下面的例子是用lambda表达式过滤Java集合，将帮助理解

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Created by haicheng.lhc on 13/04/2017.
 *
 * @author haicheng.lhc
 * @date 2017/04/13
 */
public class T2 {
    public static void main(String[] args) {
        List<String> strList = Arrays.asList("Java", "Scala", "C", "Haskell", "Lisp");
        // 创建一个字符串列表，每个字符串长度大于2
        List<String> filtered = strList.stream().filter(x -> x.length()> 2).collect(Collectors.toList());
        System.out.printf("Original List : %s %n filtered list : %s %n", strList, filtered);
    }
}

0x01 lambda表达式语法

(params) -> expression
(params) -> statement
(params) -> { statements }

如果只有一个参数，可以不写（）

0x02 lambda表达式和要点

• lambda表达式仅能放入如下代码：预定义使用了 @Functional 注释的函数式接口，自带一个抽象函数的方法，或者SAM（Single Abstract Method 单个抽象方法）类型。这些称为lambda表达式的目标类型，可以用作返回类型，或lambda目标代码的参数。例如，若一个方法接收Runnable、Comparable或者 Callable 接口，都有单个抽象方法，可以传入lambda表达式。类似的，如果一个方法接受声明于 java.util.function 包内的接口，例如 Predicate、Function、Consumer 或 Supplier，那么可以向其传lambda表达式。
• lambda表达式内可以使用方法引用，仅当该方法不修改lambda表达式提供的参数。本例中的lambda表达式可以换为方法引用，因为这仅是一个参数相同的简单方法调用。

list.forEach(n -> System.out.println(n)); 
list.forEach(System.out::println);  // 使用方法引用

若对参数有任何修改，则不能使用方法引用，而需键入完整地lambda表达式，如下所示：

list.forEach((String s) -> System.out.println("*" + s + "*"));

• lambda内部可以使用静态、非静态和局部变量，这称为lambda内的变量捕获。
• Lambda表达式在Java中又称为闭包或匿名函数
• Lambda方法在编译器内部被翻译成私有方法，并派发 invokedynamic 字节码指令来进行调用。
• lambda表达式有个限制，那就是只能引用 final 或 final 局部变量，这就是说不能在lambda内部修改定义在域外的变量。如下代码会编译报错

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Created by haicheng.lhc on 13/04/2017.
 *
 * @author haicheng.lhc
 * @date 2017/04/13
 */
public class T2 {
    public static void main(String[] args) {
        List<Integer> primes = Arrays.asList(new Integer[]{2, 3,5,7});
        int factor = 2;
        primes.forEach(element -> { factor++; });
    }
}

0x03 函数式开发

• 学习资料

0x04 函数接口

• lambda表达式的目标是函数接口。所以我们要了解一下啥是函数接口
• 学习资料
• 函数接口指的是只有一个函数的接口，这样的接口可以隐式转换为Lambda表达式。java.lang.Runnable和java.util.concurrent.Callable是函数式接口的最佳例子
• Java 8 提供了一个特殊的注解@FunctionalInterface来标明一个接口是函数接口

package java.lang;

/**
 *
 * @author  Arthur van Hoff
 * @see     java.lang.Thread
 * @see     java.util.concurrent.Callable
 * @since   JDK1.0
 */
@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

• 不过有一点需要注意，默认方法和静态方法不会破坏函数式接口的定义