Java 8 Lambda 表达式

Java 8 Lambda 表达式

1、出现的背景

java是一流的面向对象语言，除了部分简单数据类型，java中的一切都是对象，即使数组也是一种对象，每个类创建的实例也是对象。在java中定义的函数或方法不可能完全独立，也不能将方法作为参数或返回一个方法给实例。

在Java8以前，如果我们想把某些功能传递给某个方法，总要去写匿名内部类，代码示例：

/*
lambda 语法 :
    (参数) ->{函数体}
    是匿名函数.一般在方法的参数为接口时来代替之前所写的匿名内部类
    (a,b)参数类型可以不写,可以自动类型推断
    怎么推断?
    要求接口中只能有一个抽象的方法
*/
  public static void main(String[] args) {
        List<User> list = new ArrayList<>();
        list.sort(new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                return o1.getId()-o2.getId();
            }
        });
    }

在上面的例子中，为了对集合进行排序，我们为Comparator接口创建了它的一个匿名内部类对象，重写接口中的方法，来实现排序功能。

简而言之，言而总之，在java里将普通的方法或函数向参数一样传值并不简单，为此，java8增加了一个语言级的新特性，名为 lambda表达式

2、简介

Lambda表达式是一个匿名函数，我们可以把Lambda表达式理解为一段可以传递的代码（将代码端向数据一样传递）。使用它可以写出更简洁，更灵活的代码。作为一种更紧凑的代码风格，使Java语言的表达能力得到提升。

Lambda表达式的本质只是一个语法糖，由编译器推断并帮你转换包装为常规的代码，因此你可以使用更少的代码来实现同样的功能。

java中的Lambda表达式通常用(argument) -> {body}语法书写，例如：

左侧：lambda 表达式的参数列表 
右侧：lambda 表达式中需要执行的功能，即 lambda 体 
(arg1, arg2...) -> { body } 
(type1 arg1, type2 arg2...) -> { body }

以下是一些lambda表达式的例子：

无参数，无返回值，lambda 体中只有一行代码时，{}可以忽略 
    () -> System.out.println("Hello World"); 
无参数，有返回值 
    () -> { return 3.1415 }; 
有参数，无返回值 
    (String s) -> { System.out.println(s); } 
有一个参数，无返回值 
    s -> { System.out.println(s); } 
有多个参数，有返回值 
    (int a, int b) -> { return a + b; } 
有多个参数，表达式参数类型可以不写，jvm 可以根据上下文进行类型推断 
    (a, b) -> { return a - b; }

3、lambda表达式的结构

 Lambda 表达式可以具有零个，一个或多个参数。

 可以显式声明参数的类型，也可以由编译器自动从上下文推断参数的类型。

例如 (int a,int b)与 (a,b)相同。 参数用小括号括起来，用逗号分隔。例如 (a, b) 或 (int a, int b) 或 (String

a, int b, float c)。

 空括号用于表示一组空的参数。例如 () -> 42。

 当有且仅有一个参数时，如果不显式指明类型，则不必使用小括号。

例如 a -> return a*a。

 Lambda 表达式的正文可以包含零条，一条或多条语句。

 如果 Lambda 表达式的正文只有一条语句，则大括号可不用写，且表达式

的返回值类型要与匿名函数的返回类型相同。

 如果 Lambda 表达式的正文有一条以上的语句必须包含在大括号（代码块）

中，且表达式的返回值类型要与匿名函数的返回类型相同。

4、什么是功能接口**（Functional interface）**

功能接口是 java 8 中的新增功能，它们只允许一个抽象方法。这些接口也

称为单抽象方法接口。这些也可以使用 Lambda 表达式，方法引用和构造函数

引用来表示。Java 8 也引入了一个注释，即@FunctionalInterface，当你注释

的接口违反了 Functional Interface 的契约时，它可以用于编译器级错误。

示例：

@FunctionalInterface
public interface FunctionInterfaceDemo {
    public void demo(int a,int b);
}

案例：

 FunctionInterfaceDemo f = (a,b)->{
            System.out.println(a+b);
        };
        f.demo(1,2);

结果：3
正如其定义所述，功能接口只能有一个抽象方法。如果我们尝试在其中添加一个抽象方法，则会抛出编译时错误。例如：

5.Lambda 表达式的例子

5.1线程初始化

 /*
    匿名内部类方式
     */

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello World!");
            }
        }).start();
        //lambda表达式方式
        new Thread(
                ()-> System.out.println("Hello World!")
        ).start();

    }

5.2 事件处理

 /*
        匿名内部类方式
     */

    public static void main(String[] args) {
        Button b = new Button();
        b.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("hhhh");
            }
        });
        //lambda表达式方式
        b.addActionListener((e -> {
            System.out.println("hhhhh");
        }));

    }

5.3 遍历输出（方法引用）
输出给定数组的所有元素的简单代码。请注意，还有一种使用 Lambda 表达式 的方式。

public static void main(String[] args) {
        //普通方式
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,6);
        for (Integer num:list){
            System.out.println(num);
        }
        System.out.println("----------分割线-----------");
        //使用lambda表达式
        list.forEach(e->{
            System.out.println(e);
        });
    }

5.4 Stream API 示例
java.util.stream.Stream 接口 和 Lambda 表达式一样，都是 Java 8 新引入
的。所有 Stream 的操作必须以 Lambda 表达式为参数。Stream 接口中带有 大量有用的方法，比如 map() 的作用就是将 input Stream 的每个元素，映射 成 output Stream 的另外一个元素。 下面的例子，我们将 Lambda 表达式 x -> x*x 传递给 map() 方法，将其应 用于流的所有元素。之后，我们使用 forEach 打印列表的所有元素。

public static void main(String[] args) {
        //原始方式
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
        for (Integer n : list) {
            int x = n * n;
            System.out.println(x);
        }
        System.out.println("----------分割线-----------");
        //lambda 方式
        List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
        list1.stream().forEach((n) -> System.out.println(n*n));
    }

结果：