Java编程中使用lambda表达式的奇技淫巧-6ren

Java编程中使用lambda表达式的奇技淫巧

转载作者：qq735679552 更新时间：2022-09-29 22:32:09

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Java编程中使用lambda表达式的奇技淫巧由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

为什么使用Lambda表达式先看几个例子:

第一个例子，在一个独立的线程中执行某项任务，我们通常这么实现:

class Worker implements Runnable {  public void run() {    for (int i = 0; i < 100; i++)      doWork();  }  ...}Worker w = new Worker();new Thread(w).start();

第二个例子，自定义字符串比较的方法（通过字符串长度），一般这么做:

class LengthComparator implements Comparator<String> {  public int compare(String first, String second) {    return Integer.compare(first.length(), second.length());  }}Arrays.sort(strings, new LengthComparator());

第三个例子，在JavaFX中，给一个button添加一个callback:

button.setOnAction(new EventHandler<ActionEvent>() {  public void handle(ActionEvent event) {    System.out.println("Thanks for clicking!");  }});

这些例子有一个共同点，就是：先定义一段代码块，传给某个对象或方法，然后被执行。在Lambda表达式之前，Java是不允许直接传递代码块的，因为Java是面向对象的，因此必须传递一个对象，将要执行的代码块封装到对象里.

Lambda表达式的语法将上面第二个例子中的LengthComparator，用Lambda表达式表示为:

(String first, String second) -> Integer.compare(first.length(),   second.length());

->前为参数列表，其后为表达式语句体；。

如果表达式语句体不止一行，则将语句体写在{}中，与普通的函数一样:

(String first, String second) -> {  if (first.length() > second.length()) {    return 1;  } else if (first.length() == second.length()) {    return 0;  } else {    return -1;  }};

如果没有参数，()还是需要带上，比如上面的第一个例子，可以表示为:

() -> {  for (int i = 0; i < 1000; i ++) {    doWork();  }}

如果参数的类型可以从上下文自动推断，则可以省略:

Comparator<String> comp  = (first, second) // Same as (String first, String second)  -> Integer.compare(first.length(), second.length());

如果参数只有一个，且类型可以自动推断，则小括号()也可以省略:

// Instead of (event) -> or (ActionEvent event) ->eventHandler<ActionEvent> listener =   event -> System.out.println("Thanks for clicking!");

lambda表达式的返回值的类型是自动推断的，因此不需要指明；在lambda表达式，某些条件分支中有返回值，而其它分支没有返回值，是不允许的，如:

(x) -> {  if (x >= 0) {    return 1;  }}

另外，expression lambda和statement lambda的区别是，expression lambda不需要写return关键字，Java runtime会将表达式的结果作为返回值返回，而statement lambda是写在{}中的表达式，需要使用return关键字，比如:

// expression lambdaComparator<String> comp1 =   (first, second) -> Integer.compare(first.length(), second.length());// statement lambdaComparator<String> comp2 = (first, second) ->   { return Integer.compare(first.length(), second.length());};

Functional Interface 如果一个接口（interface）仅有一个抽象方法（abstract method），就称为 Functional Interface，比如Runnable、Comparator等。在任何一个需要Functional Interface对象的地方，都可以使用lambda表达式:

Arrays.sort(words,   (first, second) -> Integer.compare(first.length(), second.length()));

这里，sort()的第二个参数需要的是一个Comparator对象，而Comparator是 Functional Interface，因此可以直接传入lambda表达式，在调用该对象的compare()方法时，就是执行该lambda表达式中的语句体；。

如果lambda表达式的语句体会抛出异常，则对应的Functional Interface中的抽象方法必须抛出了该异常，否则就需要在lambda表达式中显式捕获异常:

Runnable r = () -> {  System.out.println("------");  try {    Thread.sleep(10);  } catch (InterruptedException e) {    // catch exception  }};Callable<String> c = () -> {  System.out.println("--------");  Thread.sleep(10);  return "";};

Method Reference 如果将lambda表达式的参数作为参数传递给一个方法，他们的执行效果是相同的，则该lambda表达式可以使用Method Reference表达，以下两种方式是等价的:

(x) -> System.out.println(x)System.out::println

其中System.out::println被称为Method Reference.

Method Reference主要有三种形式:

object::instanceMethod
Class::staticMethod
Class::instanceMethod

对于前两种方式，对应的lambda表达式的参数和method的参数是一致的，比如:

System.out::println(x) -> System.out.println(x)Math::pow (x, y) -> Math.pow(x, y)

对于第三种方式，对应的lambda表达式的语句体中，第一个参数作为对象，调用method，将其它参数作为method的参数，比如:

String::compareToIgnoreCase(s1, s2) -> s1.compareToIgnoreCase(s2)1.5 Constructor Reference

Constructor Reference与Method Reference类似，只不过是特殊的method：new，具体调用的是哪个构造函数，由上下文环境决定，比如:

List<String> labels = ...;Stream<Button> stream = labels.stream().map(Button::new);

Button::new等价于(x) -> Button(x)，所以调用的构造函数是：Button(x),

除了创建单个对象，也可以创建对象数组，如下面两种方式等价:

int[]::new (x) -> new int[x]

变量作用域 lambd表达式会捕获当前作用域下可用的变量，比如:

public void repeatMessage(String text, int count) {  Runnable r = () -> {    for (int i = 0; i < count; i ++) {      System.out.println(text);      Thread.yield();    }  };  new Thread(r).start();}

但是这些变量必须是不可变的，为什么呢？看下面这个例子:

int matches = 0;for (Path p : files)  new Thread(() -> { if (p has some property) matches++; }).start();   // Illegal to mutate matches

因为可变的变量在lambda表达式中不是线程安全的，这和内部类的要求是一致的，内部类中只能引用外部定义的final变量；。

lambda表达式的作用域与嵌套代码块的作用域是一样的，所以在lambd表达式中的参数名或变量名不能与局部变量冲突，如:

Path first = Paths.get("/usr/bin");Comparator<String> comp = (first, second) -> Integer.compare(first.length(),   second.length()); // Error: Variable first already defined

如果在lambda表达式中引用this变量，则引用的是创建该lambda表达式的方法的this变量，如:

public class Application() {  public void doWork() {    Runnable runner = () -> {      ...;      System.out.println(this.toString());      ...    };  }}

所以这里的this.toString()调用的是Application对象的toString()，而不是Runnable 对象的.

Default Method 接口中只能有抽象方法，如果在已有的接口中新增一个方法，则该接口所有的实现类都需要实现该方法。 Java 8中引入了Default Method的概念，在接口中新增一个default方法，不会破坏已有的接口规则，接口的实现类可以选择重写或直接继承该default方法，比如:

interface Person {  long getId();  default String getName() { return "John Q. Public"; }}

Java是允许多继承的，如果一个类的父类中定义的方法和接口中定义的default方法完全相同，或者一个类的两个接口中定义了完全相同的方法，则如何处理这种冲突呢？处理规则如下:

如果是父类和接口的方法冲突：以父类中的方法为准，接口中的方法被忽略；如果两个接口中的default方法冲突，则需要重写该方法解决冲突；。

Static Method Java 8之前，接口中只能定义static变量，Java 8开始，接口中可以添加static方法，比如 Comparator接口新增了一系列comparingXXX的static方法，比如:

public static <T> Comparator<T> comparingInt(ToIntFunction<? super T>   keyExtractor) {  Objects.requireNonNull(keyExtractor);  return (Comparator<T> & Serializable)   (c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1),        keyExtractor.applyAsInt(c2));}

使用这个static方法，以下两种方式也是等价的:

1、。

Arrays.sort(cities, (first, second) -> Integer.compare(first.length(),   second.length()));

2、。

Arrays.sort(cities, Comparator.comparingInt(String::length));

所以，以后我们在设计自己的接口时，不需要再定义单独的工具类（如Collections/Collection)，在接口中使用static方法就行了.

匿名内部类。

在 Java 世界中，匿名内部类可以实现在应用程序中可能只执行一次的操作。例如，在 Android 应用程序中，一个按钮的点击事件处理。你不需要为了处理一个点击事件单独编写一个独立的类，可以用匿名内部类完成该操作:

Button button = (Button) findViewById(R.id.button1);button.setOnClickListener(new OnClickListener() {   @Override  public void onClick(View view) {    Toast.makeText(MainActivity.this, "Button Clicked", Toast.LENGTH_SHORT).show();  } });

Lambda 示例

1.Runnable Lambda

来看几个示例，下面是一个 Runnable 的示例：

public void runnableTest() {    System.out.println("=== RunnableTest ===");    // 一个匿名的 Runnable    Runnable r1 = new Runnable() {      @Override      public void run() {        System.out.println("Hello world one!");      }    };    // Lambda Runnable    Runnable r2 = () -> System.out.println("Hello world two!");    // 执行两个 run 函数    r1.run();    r2.run();  }

  public void runnableTest() {    System.out.println("=== RunnableTest ===");    // 一个匿名的 Runnable    Runnable r1 = new Runnable() {      @Override      public void run() {        System.out.println("Hello world one!");      }    };     // Lambda Runnable    Runnable r2 = () -> System.out.println("Hello world two!");     // 执行两个 run 函数    r1.run();    r2.run();  }

这两个实现方式都没有参数也没有返回值。Runnable lambda 表达式使用代码块的方式把五行代码简化为一个语句。
2. Comparator Lambda

在 Java 中，Comparator 接口用来排序集合。在下面的示例中一个 ArrayList 中包含了一些 Person 对象，并依据 Person 对象的 surName 来排序。下面是 Person 类中包含的 fields:

public class Person {  private String givenName;  private String surName;  private int age;  private Gender gender;  private String eMail;  private String phone;  private String address;}

public class Person {  private String givenName;  private String surName;  private int age;  private Gender gender;  private String eMail;  private String phone;  private String address;}

下面是分别用匿名内部类和 Lambda 表达式实现 Comparator 接口的方式：

public class ComparatorTest {  public static void main(String[] args) {    List<Person> personList = Person.createShortList();    // 使用内部类实现排序    Collections.sort(personList, new Comparator<Person>() {      public int compare(Person p1, Person p2) {        return p1.getSurName().compareTo(p2.getSurName());      }    });    System.out.println("=== Sorted Asc SurName ===");    for (Person p : personList) {      p.printName();    }    // 使用 Lambda 表达式实现    // 升序排列    System.out.println("=== Sorted Asc SurName ===");    Collections.sort(personList, (Person p1, Person p2) -> p1.getSurName().compareTo(p2.getSurName()));    for (Person p : personList) {      p.printName();    }    // 降序排列    System.out.println("=== Sorted Desc SurName ===");    Collections.sort(personList, (p1, p2) -> p2.getSurName().compareTo(p1.getSurName()));    for (Person p : personList) {      p.printName();    }  }}

public class ComparatorTest {  public static void main(String[] args) {    List<Person> personList = Person.createShortList();     // 使用内部类实现排序    Collections.sort(personList, new Comparator<Person>() {      public int compare(Person p1, Person p2) {        return p1.getSurName().compareTo(p2.getSurName());      }    });     System.out.println("=== Sorted Asc SurName ===");    for (Person p : personList) {      p.printName();    }     // 使用 Lambda 表达式实现     // 升序排列    System.out.println("=== Sorted Asc SurName ===");    Collections.sort(personList, (Person p1, Person p2) -> p1.getSurName().compareTo(p2.getSurName()));    for (Person p : personList) {      p.printName();    }     // 降序排列    System.out.println("=== Sorted Desc SurName ===");    Collections.sort(personList, (p1, p2) -> p2.getSurName().compareTo(p1.getSurName()));    for (Person p : personList) {      p.printName();    }  }}

可以看到匿名内部类可以通过 Lambda 表达式实现。注意第一个 Lambda 表达式定义了参数的类型为 Person；而第二个 Lambda 表达式省略了该类型定义。Lambda 表达式支持类型推倒，如果通过上下文可以推倒出所需要的类型，则可以省略类型定义。这里由于我们把 Lambda 表达式用在一个使用泛型定义的 Comparator 地方，编译器可以推倒出这两个参数类型为 Person 。

最后此篇关于Java编程中使用lambda表达式的奇技淫巧的文章就讲到这里了,如果你想了解更多关于Java编程中使用lambda表达式的奇技淫巧的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！。