Lambda表达式

字数统计: 3.3k字   |   阅读时长≈ 15分

摘要：Lambda表达式总结

前言：今天总结一下Lambda表达式。

Lambda表达式基本介绍

可以把Lambda表达式理解为简洁地表示可传递的匿名函数的一种方式：它没有名称，但它有参数列表、函数主体、返回类型，还可能有可以抛出的异常列表。

  • 匿名————它不像普通的方法那样有一个明确的名称：写得少而想得多！
  • 函数————Lambda表达式不像方法那样属于某个特定的类，但和方法一样，Lambda有参数列表、函数主体、返回类型，还可能有可以抛出的异常列表。
  • 传递————Lambda表达式可以作为参数传递给方法或存储在变量中。
  • 简洁————无需像匿名类那样写很多模板代码。

Lambda表达式鼓励我们采用行为参数化风格，例如下面的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
没有使用Lambda表达式：
Comparator<Apple> byWeight = (Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());：

Comparator<Apple> byWeight = new Comparator<Apple>() {
            @Override
            public int compare(Apple a1, Apple a2) {
                return a1.getWeight().compareTo(a2.getWeight());
            }
        };

使用Lambda表达式：

Comparator<Apple> byWeight = (Apple a1, Apple a2) ->
          a1.getWeight().compareTo(a2.getWeight());

上面展示的Lambda表达式由3部分组成：
参数列表
箭头：箭头->把参数列表与Lambda主体分隔开
Lambda主体

有效的Lambda表达式：

  • (String s) -> s.length();

  • (Apple a) -> g.getWeight() > 150;

  • (int x, int y) -> {

    System.out.println(“Result:”);

    System.out.println(x+y);

    };

  • () -> 42;

  • (Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());

Lambda表达式基本语法是：

(parameters) -> expression

或

(parameters) -> {statements;}

错误语法：

1
2
3
4
5
6
7
8
9
(Integer i) -> return "Alan" + 1;
//return是一个控制流语句。要使此Lambda有效，需要使用花括号，如下所示：
(Integer i) -> {return "Alan" + 1;}

(String s) -> {"IronMan";}
//"IronMan"是一个表达式，不是一个语句。要使此Lambda有效，需要去掉花括号或者添加return，如下所示：
(String s) -> "IronMan";
或
(String s) -> {return "IronMan";}

函数式接口

函数式接口：只定义一个抽象方法的接口。

利用函数式接口来传递Lambda：

  • 行为参数化
  • 使用函数式接口来传递行为
  • 执行一个行为
  • 传递lambda

Function常用函数接口：

name type description
Consumer Consumer< T > 接收T对象，不返回值
Predicate Predicate< T > 接收T对象并返回boolean
Function Function< T, R > 接收T对象，返回R对象
Supplier Supplier< T > 提供T对象（例如工厂），不接收值
UnaryOperator UnaryOperator 接收T对象，返回T对象
BinaryOperator BinaryOperator 接收两个T对象，返回T对象

基本示例：

使用案例 lambda示例 对应的函数式接口
布尔表达式 (List list) -> list.isEmpty() Predicate<List>
创建对象 () -> new Apple(10) Supplier
消费一个对象 (Apple a) -> { System.out.println(a.getWeight);} Consumer
从一个对象中选取/抽取 (String s) -> s.length() Function<String, Integer> 或 <ToIntFunction>
组合两个值 (int a, int b) -> a * b IntBinaryOperator
比较两个对象 (Apple a1, Apple a2) -> a1.getWeight.compareTo(a2.getWeight()) BiFunction<Apple, Apple, Integer> 或 ToIntBiFunction<Apple, Apple>

方法引用

第一个方法引用：

1
2
3
4
5
6
7

//先前
inventory.sort((Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight()));

//之后(使用方法引用和java.util.Comparator.comparing)
inventory.sort(comparing(Apple::getWeight));

方法引用可以被看作仅仅调用特定方法的Lambda的一种快捷写法。它的基本思想是，如果一个Lambda代表的只是“直接调用这个方法”，那最好还是用名称来调用它，而不是去描述如何调用它。方法引用就是让你根据已有的方法实现来创建Lambda表达式。

1
2
3
4
5
6
7
8
9
10
11
12
13
当你需要使用方法引用时：目标引用放在分隔符::前，方法的名称放在后面

目标引用::方法名称

例如：

(Apple a) -> a.getWeight() 等价于 Apple::getWeight

() -> Thread.currentThread().dumpStack() 等价于 Thread.currentThread()::dumpStack

(str, i) -> str.substring(i) 等价于 String::substring

(String s) -> System.out.println(s) 等价于 System.out.println

方法引用主要有三类：

  1. 指向静态方法的方法引用
  2. 指向任意类型实例方法的方法引用
  3. 指向现有对象的实例方法的引用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
具体实例如下所示：

第一种：
Integer::parseInt
第二种:
String::length
第三种:
假设你有一个局部变量expensiveTransaction用于存放Transaction类型的对象，它支持实例方法getValue，那么就可以写成：
expensiveTransaction::getValue

第二种和第三种的区别：

第二种方法引用类似于String::length的第二种方法引用的思想就是在你引用一个对象的方法，而这个对象本身是Lambda的一个参数。
例如：Lambda表达式(String s) -> s.toUpperCase()可以写作String::toUpperCase。

第三种方法引用指的是，你在Lambda中调用一个已经存在的外部对象中的方法。
例如：Lambda表达式()->expensiveTransaction.getValue()可以写作expensiveTransaction::getValue。

构造函数引用

无参构造函数引用：

Supplier c1 = Apple::new;
Apple a1 = c1.get();

等价于：

Supplier c1 = () -> new Apple();
Apple a1 = c1.get();

一个构造函数引用：

Function<Integer, Apple> c2 = Apple::new;
Apple a2 = c2.apply(110);

等价于:

Function<Integer, Apple> c2 = (weight) -> new Apple(weight);
Apple a2 = c2.apply(110);

两个构造函数引用:

BiFunction<String, Integer, Apple> c3 = Apple::new;
Apple c3 = c3.apply(“green”, 110)

等价于:

BiFunction<String, Integer, Apple> c3 = (color, weight) -> new Apple(color, weight);
Apple c3 = c3.apply(“green”, 110)

三个构造函数引用:
我们需要有一个与构造函数引用的签名匹配的函数式接口，但是语言本身没有给我们提供一个这样的函数式的接口，所以我们需要自己创建一个：

1
2
3
4
5
6
7
8
public interface TriFunction<T, U, V, R>{
  R apply(T t, U u, V v);
}

//现在我们就可以像下面这样使用构造函数引用了：
TriFunction<Integer, Integer, Integer, Color> colorFactory = Color::new;

//其他情况类比就行，就不一一举例。

复合Lambda表达式

  1. 排序:Comparator c = Comparator.comparing(Apple::getWeight);
  2. 逆序:inventory.sort(comparing(Apple::getWeight).reversed());
  3. 比较链:inventory.sort(comparing(Apple::getWeight).reversed().thenComparing(Apple::getWeight));
  4. 谓词复合:negate、and、or
    • negate:Predicate notRedApple = redApple.negate();//产生现有Predicate对象redApple的非
    • and、or:Predicate redAndHeavyAppleGreen = redApple.and(a -> a.getWeight() > 150).or(a -> “green”.equals(a.getColor()));//要么是重150以上的红苹果，要么是绿苹果。
  5. 函数复合:Function接口为此配了andThen和compose两个默认方法，它们都会返回Function的一个实例。 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    Function<Integer, Integer> f = x -> x + 1;
    Function<Integer, Integer> g = x -> x * 2;
    Function<Integer, Integer> h = f.andThen(g);
    int result = h.apply(1);//result为4

    Function<Integer, Integer> f = x -> x + 1;
    Function<Integer, Integer> g = x -> x * 2;
    Function<Integer, Integer> h = f.compare(g);
    int result = h.apply(1);//result为3

    compare:f(g(x))
    andThen:g(f(x))

lambda表达式示例

1.用lambda表达式实现Runnable

1
2
3
4
5
6
7
8
9
10
// Java 8之前：
new Thread(new Runnable() {
    @Override
    public void run() {
    System.out.println("Before Java8, too much code for too little to do");
    }
}).start();

//Java 8之后：
new Thread( () -> System.out.println("In Java8, Lambda expression rocks !!") ).start();

2.使用Java 8 lambda表达式进行事件处理

1
2
3
4
5
6
7
8
9
10
11
12
13
// Java 8之前：
JButton show =  new JButton("Show");
show.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
    System.out.println("Event handling without lambda expression is boring");
    }
});

// Java 8之后：
show.addActionListener((e) -> {
    System.out.println("Light, Camera, Action !! Lambda expressions Rocks");
});

3.使用lambda表达式对列表进行迭代

1
2
3
4
5
6
7
8
9
10
11
12
13
// Java 8之前：
List features = Arrays.asList("Lambdas", "Default Method", "Stream API", "Date and Time API");
for (String feature : features) {
    System.out.println(feature);
}

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

// 使用Java 8的方法引用更方便，方法引用由::双冒号操作符标示，
// 看起来像C++的作用域解析运算符
features.forEach(System.out::println);

4.使用lambda表达式和函数式接口Predicate

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public static void main(args[]){
    List 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 names, Predicate condition) {
    for(String name: names)  {
        if(condition.test(name)) {
            System.out.println(name + " ");
        }
    }
}

// 更好的办法
public static void filter(List names, Predicate condition) {
    names.stream().filter((name) -> (condition.test(name))).forEach((name) -> {
        System.out.println(name + " ");
    });
}

5.如何在lambda表达式中加入Predicate

1
2
3
4
5
6
7
// 甚至可以用and()、or()和xor()逻辑函数来合并Predicate，
// 例如要找到所有以J开始，长度为四个字母的名字，你可以合并两个Predicate并传入
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));

6.Java 8中使用lambda表达式的Map和Reduce示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// 不使用lambda表达式为每个订单加上12%的税
List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
for (Integer cost : costBeforeTax) {
    double price = cost + .12*cost;
    System.out.println(price);
}

// 使用lambda表达式
List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
costBeforeTax.stream().map((cost) -> cost + .12*cost).forEach(System.out::println);

// 为每个订单加上12%的税
// 老方法：
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);

// 新方法：
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);

7.通过过滤创建一个String列表

1
2
3
// 创建一个字符串列表，每个字符串长度大于2
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);

8.对列表的每个元素应用函数

1
2
3
4
// 将字符串换成大写并用逗号链接起来
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);

9.复制不同的值，创建一个子列表

1
2
3
4
// 用所有不同的数字创建一个正方形列表
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);

10.计算集合元素的最大值、最小值、总和以及平均值

1
2
3
4
5
6
7
//获取数字的个数、最小值、最大值、总和以及平均值
List<Integer> primes = Arrays.asList(2, 3, 5, 7, 11, 13, 17, 19, 23, 29);
IntSummaryStatistics stats = primes.stream().mapToInt((x) -> x).summaryStatistics();
System.out.println("Highest prime number in List : " + stats.getMax());
System.out.println("Lowest prime number in List : " + stats.getMin());
System.out.println("Sum of all prime numbers : " + stats.getSum());
System.out.println("Average of all prime numbers : " + stats.getAverage());

Lambda表达式要点

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

list.forEach(n -> System.out.println(n));

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

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

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

事实上，可以省略这里的lambda参数的类型声明，编译器可以从列表的类属性推测出来。
  1. lambda内部可以使用静态、非静态和局部变量，这称为lambda内的变量捕获。
  2. Lambda表达式在Java中又称为闭包或匿名函数。
  3. Lambda方法在编译器内部被翻译成私有方法，并派发 invokedynamic 字节码指令来进行调用。可以使用JDK中的 javap 工具来反编译class文件。使用 javap -p 或 javap -c -v 命令来看一看lambda表达式生成的字节码。大致应该长这样：
1
private static java.lang.Object lambda$0(java.lang.String);
  1. lambda表达式有个限制，那就是只能引用 final 或 final 局部变量，这就是说不能在lambda内部修改定义在域外的变量。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
List<Integer> primes = Arrays.asList(new Integer[]{2, 3,5,7});

int factor = 2;

primes.forEach(element -> { factor++; });

Compile time error : "local variables referenced from a lambda expression must be final or effectively final"

另外，只是访问它而不作修改是可以的，如下所示：

List<Integer> primes = Arrays.asList(new Integer[]{2, 3,5,7});

int factor = 2;

primes.forEach(element -> { System.out.println(factor*element); });

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

教练，我想学技术！
我主要是以后端技术为主，偶尔看看网络安全相关的内容，或者编写一些有趣的脚本！