ラムダ式については色々勉強してきましたが、ここで一度振り返ってみます。

@FunctionalInterface

明示的に関数型インターフェースであることを宣言できる
アノテーションが無くても動作上問題ない
アノテーションを付けることで関数型インターフェースの条件を満たさない場合にコンパイルエラーになる

関数型インターフェースを引数に取るメソッドを例に動きを確認します。

@FunctionalInterface
    public interface Sample{
        //　戻り値なし引数なしのメソッドを持つインターフェースです
        void execute();
    }
    
    // Sample型　sampleはメソッド参照型変数という概念
    private void testFunc(Sample sample){
        sample.execute();
    }
    
    @Test
    public void test(){
        // 引数無しのvoidメソッドであれば、それはSampleに適合できる
        testFunc(()->System.out.println("御坂美琴"));
    }

Sampleという関数型インターフェースは、引数無し戻り値無しの関数が適合します。→メソッドの型が適合する今回はラムダ式で実現しています。

メソッドの型は以下の要素で決まります
- 引数列の型
- 戻り値の型

よくある標準関数型インターフェースというのも、メソッドの型さえ合えばそれに適合できます。

以下の例はConsumerという関数型インターフェースを利用したものです。このメソッドの型は以下のようになっています

T型の引数を一つとる
戻り値なしの関数

よく使うSystem.out.println(String arg)はまさにこれに適合できます。

private <T> void testFunc(Consumer<T> func, T a){
        func.accept(a);
    }

    @Test
    public void test(){
        // 引数無しのvoidメソッドであれば、それはSampleに適合できる
        testFunc(System.out::println,"白井黒子");
    }

これはメソッド参照です

メソッド単体を取り出している
メソッド参照を受取る型はオブジェクト参照（インターフェースの型）で受け取っている

以下のようにすることも可能です

@Test
    public void test(){
        Consumer<String> func = System.out::println;
        testFunc(func,"御坂妹");
    }

System.out::printlnがConsumer型のオブジェクト参照になっているのがわかります。

ラムダ式

メソッドを式として記述できる
メソッド単体の参照を変数に代入できる
評価値は関数型インターフェース

先ほどの例をラムダ式で書き換えると以下のようになる

private <T> void testFunc(Consumer<T> func, T a){
        func.accept(a);
    }

    @Test
    public void test(){
        testFunc(arg -> {
            System.out.println(arg);
        } , "misaka");
    }

Consumerは、任意の引数が1つと戻り値無しの関数なので、渡すラムダ式も同じ型にします。ここが適合できないとエラーになります。

public void test(){
        testFunc((arg,arg2) -> {
            System.out.println(arg + arg2);
        }, "misaka","mikoto");
    }

以下のような関数型インターフェースがあればこのメソッドは成功します

@FunctionalInterface
    public interface TwoArg<T>{
        void execute(T arg, T arg2);
    }
    private <T> void testFunc2(TwoArg<T> func, T arg, T arg2){
        func.execute(arg,arg2);
    }
    @Test
    public void test(){
        testFunc2((arg,arg2) -> {
            System.out.println(arg + arg2);
        }, "misaka","mikoto");
    }

ラムダ式が関数型インターフェースとして評価されているのがわかります。

メソッドに型パラメータは持てない

関数インターフェイスのメソッドが型パラメータを持つ場合、関数インターフェイスにラムダ式を使用することはできません

以下のような場合はエラーになる

@FunctionalInterface
    public interface TwoArg<T>{
        <V> void execute(T arg, V arg2);
    }
    private <T,V> void testFunc2(TwoArg<T> func, T arg, V arg2){
        func.execute(arg,arg2);
    }
    @Test
    public void test(){
        testFunc2((arg,arg2) -> {
            System.out.println(arg + arg2);
        }, "misaka","mikoto");
    }

Target method is generic

ラムダ式のthis

JavaScriptでもラムダ式はthisを束縛するとかありますが、Javaの場合クラスメソッド内のラムダ式ではthisが使えない

以下はthisが利用できる例

private final int score = 100;
    private final Consumer<String> printer = (String str) -> {
      System.out.println(Integer.toString(this.score) + str);
    };
    @Test
    public void doTest(){
        // thisが使える
        Consumer<String> print = (String str) -> System.out.println(Integer.toString(this.score) + str);
        print.accept("点です");
        this.printer.accept("score");
    }

以下はthisが利用できない例

public static void doTester(){
        // このラムダはクラスメソッドに相当する
        Consumer<String> print = (String str) -> System.out.println(Integer.toString(this.score)+str);
    }

ローカル変数とラムダ式

ラムダ式の中から、ラムダ式の外側のメソッドの実質finalのローカル変数にアクセスできる

アクセスできる変数
- 実質finalのローカル変数
- 実質finalのパラメータ変数

public void doTest(String paramValue){
        String localValue = "目薬";
        Consumer<String> print = (String str) -> {
            str = "一方通行"; //ラムダ式内の変数なので再代入できる
            //localValue = "再代入"; // ここはエラー
            // paramValue = "ダークマター"; // 同じくエラー
            // Variable used in lambda expression should be final or effectively final
            System.out.println(Integer.toString(this.score) + str + localValue + paramValue); //参照は可能
        };
        print.accept("点でした");
    }

クロージャ

その昔、JavaScriptでprivate変数を作るのにクロージャを使っていたそうですが、メソッド内に定義するメソッドという意味ではラムダ式も同じです。

JavaScriptではクロージャの外側の関数で定義したローカル変数を書き換えて、privateを模倣しますが、Javaはそれができません。

先ほどもあげたように、外側の関数で定義されている変数は実質finalとなるためです。

public void hoge(){
        IntSupplier supplier = counter();
        System.out.println(supplier.getAsInt());
    }
    public IntSupplier counter(){
        int count = 0;
        return () -> count++; // 実質finalなので再代入不可
    }

参照先オブジェクトを利用することで実現できます

public void hoge(){
        IntSupplier supplier = counter();
        System.out.println(supplier.getAsInt());
        System.out.println(supplier.getAsInt());
        System.out.println(supplier.getAsInt());
    }
    public IntSupplier counter(){
        AtomicInteger count = new AtomicInteger();
        return () -> count.getAndIncrement();
    }

0
1
2

関数合成

関数合成
- 関数型インターフェースを合成して新しい関数型インターフェースを作成すること
- Function系、Consumer系andThenメソッドで合成
- Predicate系and、or、negateメソッドで合成
  - andThenメソッドで合成
  - and、or、negateメソッドで合成

private Consumer<String> writeLog = msg -> System.out.println("Log : " + msg);
    private Consumer<String> sendEmail = msg -> System.out.println("Send : " + msg);
    private Consumer<String> notifMenber = msg -> System.out.println("Notif : " + msg);
    @Test
    public void newFuncTest(){
        Consumer<String> event = writeLog.andThen(sendEmail).andThen(notifMenber);
        event.accept("超重要な処理が完了しました");
    }

Log : 超重要な処理が完了しました

Send : 超重要な処理が完了しました

Notif : 超重要な処理が完了しました

参考書籍

改訂2版　パーフェクトJava

Javaの参考書としては十分な内容だと思います。変な本を買うくらいならコレって感じです。

Java | 関数型インターフェースとラムダ式