Java进阶知识点2：Lambda

1.背景
匿名内部类有以下问题：

1. 语法过于冗余
2. 匿名类中的this和变量名容易使人产生误解
3. 类型载入和实例创建语义不够灵活
4. 无法捕获非final的局部变量
5. 无法对控制流进行抽象

lambda表达式提供了轻量级的语法。

2.语法
lambda表达式的语法由参数列表、箭头符号->和函数体组成。

函数体既可以是一个表达式，也可以是一个语句块：

• 表达式：表达式会被执行然后返回执行结果。
• 语句块：语句块中的语句会被依次执行，就像方法中的语句一样——
  • return语句会把控制权交给匿名方法的调用者
  • break和continue只能在循环中使用
  • 如果函数体有返回值，那么函数体内部的每一条路径都必须返回值

表达式函数体适合小型lambda表达式，它消除了return关键字，使得语法更加简洁。

lambda表达式也会经常出现在嵌套环境中，比如说作为方法的参数。为了使lambda表达式在这些场景下尽可能简洁，我们去除了不必要的分隔符。不过在某些情况下我们也可以把它分为多行，然后用括号包起来，就像其它普通表达式一样。
3.参数列表

• 没有参数时:一定要加上()

new Thread(()->System.out.println("Hello World!!!")).start();

---

• 有一个参数时:
  1.如果写了参数类型，就需要加()
  2.如果没有写参数类型，可以不加()

Arrays.asList("qwe","asd","zxc").forEach((String s) -> System.out.println(s)); 

Arrays.asList("qwe","asd","zxc").forEach( s -> System.out.println(s)); 

• 有两个参数时：一定需要()；当参数需要加修饰符或者标签时，参数则需要加上完整的参数类型，否则，可以不加完整的参数类型。

Arrays.asList("b","a","c","d").sort((final String s1,final String s2)->s1.compareTo(s2));

4.函数体

Lambda的函数体和普通Java的方法差不多

• 函数体只有一行，可以省略{}，需要返回值时，return也可以省略

Arrays.asList("b","a","c","d").sort((s1,s2)->s1.compareTo(s2));

• 多行时则需要{}，需要返回值时，return也不可以省略

Arrays.asList("b","a","c","d").sort((s1,s2) ->{

        int result = s1.compareTo(s2);

        return result;

});

5. Lambda表达式中的变量

参数

 Arrays.asList("b","a","c","d").sort((s1,s2)->s1.compareTo(s2)); 

 s1,s2就是Labmbda表达式的参数

局部变量和自由变量

private static void printHelloLambda(int times, String str) {
    Runnable runnable = () -> {
        for (int i = 0; i < times; i++) {
            System.out.println(str);
        }
    };
    new Thread(runnable).start();
}

运行结果就是打印times次string
for()中的i就是局部变量

int times, String str既不是参数，也不是局部变量，而是自由变量。

自由变量在Lambda表达式中不能修改。如果是采用内部类的形式，内部类想用使用方法的参数int times, String str，是需要加上final的。

在Lambda表达式中的this代表创建Lambda表达式方法的this，表达式所在的类。

---

Lambda表达式中的异常同普通方法一样，也是有两种处理方法。
1.表达式函数体内进行try-catch处理
2.接口方法进行throws。Lambda所在的方法进行throws是无效的。

6.Lambda的引用方式
6.1 Lambda表达式方法引用

Arrays.asList("b", "a", "c", "d").forEach(System.out :: println);

String[] strings = { "acb", "abc", "cb", "bc" };
List list = Arrays.asList(strings);
Collections.sort(list, String::compareTo); 

方法引用形式：
类 ::静态方法
对象::方法
对象::静态方法

6.2 构造方法引用

形式：类::new

Arrays.asList()返回的是ArrayList，如果我们想要可以根据需要来确定返回List的类型，就可以使用构造方法引用。

import java.util.List;
@FunctionalInterface
public interface ICreater> {
    T create();
}

定义一个接口泛型为List的子类，接口内抽象方法无参，返回值为T

public class LambdaDemo {
    public static void main(String[] args) {
        forEach();
    }

    private static void forEach() {
    
        LambdaDemo lambdaDemo = new LambdaDemo();
        
        List list_2 =lambdaDemo.asList(LinkedList::new, strings);
        Collections.sort(list_2, String::compareTo);
        list.stream().forEach(System.out::println);
    }

    public List asList(ICreater> creater, T... t) {
        List list = creater.create();
        for (T a : t)
            list.add(a);
        return list;
    }
}

构造方法引用，接口需要有一个无参的并且一定有返回值。

7.Lambda的常用使用场景

7.1使用Lambdas排序集合

在Java中,Comparator 类被用来排序集合。 在下面的例子中,我们将根据球员的 name, surname, name 长度 以及最后一个字母。 和前面的示例一样,先使用匿名内部类来排序,然后再使用lambda表达式精简我们的代码。

在第一个例子中,我们将根据name来排序list。 使用旧的方式,代码如下所示:

String[] players = {"Rafael Nadal", "Novak Djokovic",  

    "Stanislas Wawrinka", "David Ferrer", 

    "Roger Federer", "Andy Murray", 

    "Tomas Berdych", "Juan Martin Del Potro", 

    "Richard Gasquet", "John Isner"}; 

// 使用匿名内部类根据 name 排序 players 

Arrays.sort(players, new Comparator() { 

    @Override 

    public int compare(String s1, String s2) { 

        return (s1.compareTo(s2)); 

    } 

}); 

使用lambdas,可以通过下面的代码实现同样的功能:

// 使用 lambda expression 排序 players 

Comparator sortByName = (String s1, String s2) -> (s1.compareTo(s2)); 

Arrays.sort(players, sortByName); 

// 也可以采用如下形式: 

Arrays.sort(players, (String s1, String s2) -> (s1.compareTo(s2)));  

其他的排序如下所示。 和上面的示例一样,代码分别通过匿名内部类和一些lambda表达式来实现Comparator :

// 使用匿名内部类根据 surname 排序 players 

Arrays.sort(players, new Comparator() { 

    @Override 

    public int compare(String s1, String s2) { 

        return (s1.substring(s1.indexOf(" ")).compareTo(s2.substring(s2.indexOf(" ")))); 

    } 

}); 

  // 使用 lambda expression 排序,根据 surname 

Comparator sortBySurname = (String s1, String s2) ->  

    ( s1.substring(s1.indexOf(" ")).compareTo( s2.substring(s2.indexOf(" ")) ) ); 

Arrays.sort(players, sortBySurname); 

// 或者这样

Arrays.sort(players, (String s1, String s2) ->  

      ( s1.substring(s1.indexOf(" ")).compareTo( s2.substring(s2.indexOf(" ")) ) )  

    ); 

// 使用匿名内部类根据 name lenght 排序 players 

Arrays.sort(players, new Comparator() { 

    @Override 

    public int compare(String s1, String s2) { 

        return (s1.length() - s2.length()); 

    } 

}); 

// 使用 lambda expression 排序,根据 name lenght 

Comparator sortByNameLenght = (String s1, String s2) -> (s1.length() - s2.length()); 

Arrays.sort(players, sortByNameLenght); 

// or this 

Arrays.sort(players, (String s1, String s2) -> (s1.length() - s2.length())); 

// 使用匿名内部类排序 players, 根据最后一个字母 

Arrays.sort(players, new Comparator() { 

    @Override 

    public int compare(String s1, String s2) { 

        return (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1)); 

    } 

}); 

// 使用 lambda expression 排序,根据最后一个字母 

Comparator sortByLastLetter =  

    (String s1, String s2) ->  

        (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1)); 

Arrays.sort(players, sortByLastLetter); 

// or this 

Arrays.sort(players, (String s1, String s2) -> (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1))); 

就是这样,简洁又直观。

7.2 使用Lambdas和Streams

Stream是对集合的包装,通常和lambda一起使用。 使用lambdas可以支持许多操作,如 map, filter, limit, sorted, count, min, max, sum, collect 等等。 同样,Stream使用懒运算,他们并不会真正地读取所有数据,遇到像getFirst() 这样的方法就会结束链式语法。 在接下来的例子中,我们将探索lambdas和streams 能做什么。 我们创建了一个Person类并使用这个类来添加一些数据到list中,将用于进一步流操作。 Person 只是一个简单的POJO类:

public class Person { 

private String firstName, lastName, job, gender; 

private int salary, age; 

public Person(String firstName, String lastName, String job, 

                String gender, int age, int salary)       { 

          this.firstName = firstName; 

          this.lastName = lastName; 

          this.gender = gender; 

          this.age = age; 

          this.job = job; 

          this.salary = salary; 

} 

// Getter and Setter  

// . . . . . 

} 

接下来,我们将创建两个list,都用来存放Person对象:

List javaProgrammers = new ArrayList() { 

  { 

    add(new Person("Elsdon", "Jaycob", "Java programmer", "male", 43, 2000)); 

    add(new Person("Tamsen", "Brittany", "Java programmer", "female", 23, 1500)); 

    add(new Person("Floyd", "Donny", "Java programmer", "male", 33, 1800)); 

    add(new Person("Sindy", "Jonie", "Java programmer", "female", 32, 1600)); 

    add(new Person("Vere", "Hervey", "Java programmer", "male", 22, 1200)); 

    add(new Person("Maude", "Jaimie", "Java programmer", "female", 27, 1900)); 

    add(new Person("Shawn", "Randall", "Java programmer", "male", 30, 2300)); 

    add(new Person("Jayden", "Corrina", "Java programmer", "female", 35, 1700)); 

    add(new Person("Palmer", "Dene", "Java programmer", "male", 33, 2000)); 

    add(new Person("Addison", "Pam", "Java programmer", "female", 34, 1300)); 

  } 

}; 

 

List phpProgrammers = new ArrayList() { 

  { 

    add(new Person("Jarrod", "Pace", "PHP programmer", "male", 34, 1550)); 

    add(new Person("Clarette", "Cicely", "PHP programmer", "female", 23, 1200)); 

    add(new Person("Victor", "Channing", "PHP programmer", "male", 32, 1600)); 

    add(new Person("Tori", "Sheryl", "PHP programmer", "female", 21, 1000)); 

    add(new Person("Osborne", "Shad", "PHP programmer", "male", 32, 1100)); 

    add(new Person("Rosalind", "Layla", "PHP programmer", "female", 25, 1300)); 

    add(new Person("Fraser", "Hewie", "PHP programmer", "male", 36, 1100)); 

    add(new Person("Quinn", "Tamara", "PHP programmer", "female", 21, 1000)); 

    add(new Person("Alvin", "Lance", "PHP programmer", "male", 38, 1600)); 

    add(new Person("Evonne", "Shari", "PHP programmer", "female", 40, 1800)); 

  } 

}; 

现在我们使用forEach方法来迭代输出上述列表:

System.out.println("所有程序员的姓名:"); 

javaProgrammers.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName())); 

phpProgrammers.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName())); 

我们同样使用forEach方法,增加程序员的工资5%:

System.out.println("给程序员加薪 5% :"); 

Consumer giveRaise = e -> e.setSalary(e.getSalary() / 100 * 5 + e.getSalary()); 

 javaProgrammers.forEach(giveRaise); 

phpProgrammers.forEach(giveRaise); 

另一个有用的方法是过滤器filter() ,让我们显示月薪超过1400美元的PHP程序员:

System.out.println("下面是月薪超过 $1,400 的PHP程序员:") 

phpProgrammers.stream() 

          .filter((p) -> (p.getSalary() > 1400)) 

          .forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName())); 

我们也可以定义过滤器,然后重用它们来执行其他操作:

// 定义 filters 

Predicate ageFilter = (p) -> (p.getAge() > 25); 

Predicate salaryFilter = (p) -> (p.getSalary() > 1400); 

Predicate genderFilter = (p) -> ("female".equals(p.getGender())); 

  System.out.println("下面是年龄大于 24岁且月薪在$1,400以上的女PHP程序员:"); 

phpProgrammers.stream() 

          .filter(ageFilter) 

          .filter(salaryFilter) 

          .filter(genderFilter) 

          .forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName())); 

  // 重用filters 

System.out.println("年龄大于 24岁的女性 Java programmers:"); 

javaProgrammers.stream() 

          .filter(ageFilter) 

          .filter(genderFilter) 

          .forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName())); 

使用limit方法,可以限制结果集的个数:

System.out.println("最前面的3个 Java programmers:"); 

javaProgrammers.stream() 

          .limit(3) 

          .forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName())); 

System.out.println("最前面的3个女性 Java programmers:"); 

javaProgrammers.stream() 

          .filter(genderFilter) 

          .limit(3) 

          .forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));

排序呢? 我们在stream中能处理吗? 答案是肯定的。 在下面的例子中,我们将根据名字和薪水排序Java程序员,放到一个list中,然后显示列表:

System.out.println("根据 name 排序,并显示前5个 Java programmers:"); 

List sortedJavaProgrammers = javaProgrammers 

          .stream() 

          .sorted((p, p2) -> (p.getFirstName().compareTo(p2.getFirstName()))) 

          .limit(5) 

          .collect(toList()); 

sortedJavaProgrammers.forEach((p) -> System.out.printf("%s %s; %n", p.getFirstName(), p.getLastName())); 

System.out.println("根据 salary 排序 Java programmers:"); 

sortedJavaProgrammers = javaProgrammers 

          .stream() 

          .sorted( (p, p2) -> (p.getSalary() - p2.getSalary()) ) 

          .collect( toList() ); 

sortedJavaProgrammers.forEach((p) -> System.out.printf("%s %s; %n", p.getFirstName(), p.getLastName())); 

如果我们只对最低和最高的薪水感兴趣,比排序后选择第一个/最后一个 更快的是min和max方法:

System.out.println("工资最低的 Java programmer:"); 

Person pers = javaProgrammers 

          .stream() 

          .min((p1, p2) -> (p1.getSalary() - p2.getSalary())) 

          .get() 

System.out.printf("Name: %s %s; Salary: $%,d.", pers.getFirstName(), pers.getLastName(), pers.getSalary()) 

System.out.println("工资最高的 Java programmer:"); 

Person person = javaProgrammers 

          .stream() 

          .max((p, p2) -> (p.getSalary() - p2.getSalary())) 

          .get() 

System.out.printf("Name: %s %s; Salary: $%,d.", person.getFirstName(), person.getLastName(), person.getSalary()) 

上面的例子中我们已经看到 collect 方法是如何工作的。 结合 map 方法,我们可以使用 collect 方法来将我们的结果集放到一个字符串,一个 Set 或一个TreeSet中:

System.out.println("将 PHP programmers 的 first name 拼接成字符串:"); 

String phpDevelopers = phpProgrammers 

          .stream() 

          .map(Person::getFirstName) 

          .collect(joining(" ; ")); // 在进一步的操作中可以作为标记(token)    

System.out.println("将 Java programmers 的 first name 存放到 Set:"); 

Set javaDevFirstName = javaProgrammers 

          .stream() 

          .map(Person::getFirstName) 

          .collect(toSet()); 

System.out.println("将 Java programmers 的 first name 存放到 TreeSet:"); 

TreeSet javaDevLastName = javaProgrammers 

          .stream() 

          .map(Person::getLastName) 

          .collect(toCollection(TreeSet::new)); 

Streams 还可以是并行的(parallel)。 示例如下:

System.out.println("计算付给 Java programmers 的所有money:"); 

int totalSalary = javaProgrammers 

          .parallelStream() 

          .mapToInt(p -> p.getSalary()) 

          .sum(); 

我们可以使用summaryStatistics方法获得stream 中元素的各种汇总数据。 接下来,我们可以访问这些方法,比如getMax, getMin, getSum或getAverage:

//计算 count, min, max, sum, and average for numbers 

List numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); 

IntSummaryStatistics stats = numbers 

          .stream() 

          .mapToInt((x) -> x) 

          .summaryStatistics(); 

System.out.println("List中最大的数字 : " + stats.getMax());  

System.out.println("List中最小的数字 : " + stats.getMin()); 

System.out.println("所有数字的总和   : " + stats.getSum()); 

System.out.println("所有数字的平均值 : " + stats.getAverage());  

 

总结：身为Java程序员，得能读懂吧。

-----------------------------------------------------------------------------------------

参考博客：
https://www.cnblogs.com/figure9/p/java-8-lambdas-insideout-language-features.html
http://www.cnblogs.com/franson-2016/p/5593080.html
https://www.jianshu.com/p/0b4b59966276