Java プログラミングでラムダ式を使用するためのヒント

ラムダ式を使用する理由
まずいくつかの例を見てみましょう:

最初の例は、通常次のように実装します:

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

2 番目の例はカスタマイズ文字列です。 (文字列の長さによる) 比較メソッドを使用するには、通常次のようにします:

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 での 3 番目の例は、ボタンにコールバックを追加します:

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

これらの例には 1 つの共通点があります。それは、コードを定義するということです。最初にブロックし、それをオブジェクトまたはメソッドに渡してから実行します。 Lambda 式が登場する前は、Java はオブジェクト指向であるため、コード ブロックを直接渡すことはできませんでした。そのため、実行されるコード ブロックをオブジェクトにカプセル化するにはオブジェクトを渡す必要がありました。

ラムダ式の構文

上記の 2 番目の例の LengthComparator は、ラムダ式として次のように表されます:

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

->先頭はパラメータ リストで、その後に式ステートメントの本文が続きます。

If 式数式のステートメント本体が複数行の場合は、通常の関数と同じように、ステートメント本体を {} で記述します。

(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());

パラメータが 1 つだけで、型が自動的に推論できる場合、括弧 () は省略することもできます:

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

lambda 式の戻り値の型は自動的に推測されるため、ラムダ式で指定する必要はありません。一部の条件分岐には

戻り値があります。一方、他のブランチには戻り値がありませんが、これは許可されていません。

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

さらに、式ラムダとステートメント ラムダの違いは、式ラムダが Java ランタイムが返す return キーワードを記述する必要がないことです。式の結果を戻り値として返しますが、ステートメント lambda は {} で書かれた式であり、次のような return キーワードを使用する必要があります。

Runnable、Comparator などの機能インターフェイス

Functional Interface オブジェクトが必要な場合はどこでもラムダ式を使用できます:

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

ここで、sort() の 2 番目のパラメーターには Comparator オブジェクトが必要で、Comparator は

Functional Interface なので、ラムダ式が次の場合に直接使用できます。渡されると、オブジェクトの Compare() メソッドが呼び出されるときに

、ラムダ式のステートメント本体が実行されます。

ラムダ式のステートメント本体が例外をスローした場合、対応する関数インターフェイスの抽象化メソッドは
この例外をスローします。そうでない場合は、ラムダ式で明示的に例外をキャッチする必要があります:

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

メソッドリファレンス
ラムダ式のパラメータがパラメータとしてメソッドに渡される場合、それらの実行効果は同じです。ラムダ式
は、メソッド リファレンスを使用して表現できます。次の 2 つのメソッドは同等です:

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

ここで、System.out::println はメソッド リファレンスと呼ばれます。

メソッドリファレンスには主に 3 つの形式があります:

object::instanceMethod

Class::staticMethod

Class::instanceMethod

最初の 2 つのメソッドでは、対応するラムダ式のパラメーターは、対応するラムダ式のパラメーターと同じです。例:

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

3 番目のメソッドでは、対応するラムダ式のステートメント本体で、最初のパラメーターがオブジェクトとして使用され、メソッドが呼び出され、他のパラメーター

がそのパラメーターとして使用されます。メソッド (例:

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

) は、メソッド リファレンスと似ていますが、特殊なメソッドである点が異なります: new。どのコンストラクターが呼び出されるかはコンテキストによって決まります。例:

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

。は (x) -> Button( x) と同等なので、呼び出されるコンストラクターは次のようになります: Button(x);

単一のオブジェクトを作成することに加えて、次の 2 つのメソッドは同等です。 :

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

変数スコープ

lambd式は、次のような現在のスコープで利用可能な変数をキャプチャします:

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

しかし、これらの変数は不変でなければなりません、なぜですか?次の例を見てください:

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();
}

可変変数はラムダ式ではスレッドセーフではないため、内部クラスは外部で定義された
final 変数のみを参照できます。ラムダ式はネストされたコード ブロックのスコープと同じであるため、ラムダ式内のパラメータ名または変数名は、次のようにローカル変数と競合できません。

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

ラムダ式の場合 この変数が参照されている場合では、ラムダ式を作成したメソッドの this 変数を参照します。たとえば、

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

したがって、ここで this.toString() は、Runnable
オブジェクトではなく、Application オブジェクトの toString() を呼び出します。

デフォルトメソッド
インターフェイスには抽象メソッドのみを含めることができます。既存のインターフェイスに新しいメソッドを追加する場合、インターフェイスのすべての実装クラスはこのメソッドを実装する必要があります。

デフォルト メソッドの概念は Java 8 で導入されました。インターフェイスにデフォルト メソッドを追加しても、既存のインターフェイス ルールは破棄されません。インターフェイスの実装クラスは、次のようにデフォルト メソッドをオーバーライドするか直接継承するかを選択できます。

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表达式的奇技淫巧相关文章请关注PHP中文网！