@FunctionalInterfaceを使ってラムダ式と遊んでみます

シンプルな例

とてもシンプルな例です。T型の引数を取ってT型を返すラムダ式を渡してあげることで実装できます。

/*
 * 関数型インターフェースは単一の抽象メソッドを持っています
 * → アノテーションを付けない場合は複数の抽象メソッドを定義できます（エラーにならない）
 * また、defaultやstaticメソッドは必要に応じて定義できる
 */
@FunctionalInterface
public interface SampleFunction<T> {
	
	T get(T t);
	
	default void execute() {
		System.out.println("execute");
	}
	
	static void he() {
		System.out.println("he");
	}
}

引数で受け取って利用してみます。

public String test(String str, SampleFunction<String> func) {
		String r = func.get(str);
		func.execute();
		SampleFunction.he();
		return r;
	}

misakaを渡してmikotoを付与して返すという意味のわからない実装ができました

@Test
	void test() {
		System.out.println("testの実行開始");
		SampleTestFunctional sa = new SampleTestFunctional();
		String result = sa.test( "misaka", str -> {
			return str + "mikoto";
		});
		assertEquals("misakamikoto", result);
	}

結果

testの実行開始

execute

he

シンプルな例２

またシンプルな例を見てみます。これはT型を受取って値を返さないインターフェースです

@FunctionalInterface
public interface ExecutionFunction<T> {
	void execute(T t);
}

このインターフェースを受取るメソッドを作ってみます。Stringを受取って処理します。

public String testExecution(String str, ExecutionFunction<String> func)
	{
		func.execute(str);
		return "終了しました";
	}

テストで実行してみます

@Test
	void teste() {
		System.out.println("testeの実行開始");
		SampleTestFunctional sa = new SampleTestFunctional();
		String result = sa.testExecution("Level5", str -> {
			System.out.println(str);
		});
	}

Level5が出力されます。

ラムダ式を変数に格納する

今度は実行時に型を決めるようなメソッドを定義しておきます。

public <T> T testGeneriExecution(T t, ExecutionFunction<T> func) {
		func.execute(t);
		return t;
	}

テストしてみますが、変数にラムダ式を入れて利用します。

@Test
	void kakunoutest() {
		System.out.println("kakunoutestの実行開始");
		SampleTestFunctional sa = new SampleTestFunctional();
		// 変数にラムダ式を格納する
		ExecutionFunction<String> funcA = str -> System.out.println(str);
		// 変数にラムダ式を格納する
		ExecutionFunction<Boolean> funcB = switchFlag -> {
			if(switchFlag) {
				System.out.println("データベースに接続します");
			}else {
				System.out.println("データベースに接続しませんでした");
			}
		};
		
		//　変数にいれたラムダ式を渡す
		String re = sa.testExecution("hogee?", funcA);
		Boolean b = sa.testGeneriExecution(true, funcB);
		Boolean c = sa.testGeneriExecution(false, funcB);
	}

結果

kakunoutestの実行開始

hogee?

データベースに接続します

データベースに接続しませんでした

ラムダ式を返すラムダ式

この辺から少し頭が痛くなります。

ラムダ式を返すラムダ式は () -> () -> こんな感じ記載します。実際の例は以下です

@FunctionalInterface
public interface ReturnLamda<T> {
	// ラムダ式を返すラムダ式を期待します
	ExecutionFunction<T> getLamda();
}

ReturnLamdaインターフェースを利用してみます。getLamdaの戻り値はExecutionFunctionですので、変数eはExecutionFunctionになります。

public void testGetLamda(String str,ReturnLamda<String> func) {
		ExecutionFunction<String> e = func.getLamda();
		e.execute(str);
	}

ラムダ式を返すラムダ式を記載します。

@Test
	public void test_getLambda() {
		System.out.println("test_getLambdaの実行開始");
		SampleTestFunctional sa = new SampleTestFunctional();
		sa.testGetLamda("lamdaじゃなくてlambda", () ->  str -> System.out.println(str));
	}

getLamdaは引数無しなので()で記載します。そしてその戻り値はStringを引数に取るexecuteメソッドの実装になります。

結果

test_getLambdaの実行開始

lamdaじゃなくてlambda

コンストラクタ参照

Supplierを使ったコンストラクタ参照をやってみます。SupplierはファクトリのようなものでT型のオブジェクトを返します。何を返すのかコンストラクタ参照で実装します。

// コンストラクタ参照
	public <T> T getClazz(Supplier<T> func) {
		T t = func.get();
		return t;
	}

Misakaクラスを定義しておきます

package com.volkruss.misakaspring.functional;

public class Misaka {

	public Misaka() {
		System.out.println("グッジョブです！と、ミサカは惜しみない賞賛を贈ります。");
	}
	
	String get() {
		return "御坂妹";
	}
}

テストで利用してみます。Misakaクラスのコンストラクタ参照を使って、オブジェクトのインスタンス化を行います。

@Test
	public void test_constructor() {
		System.out.println("test_constructor");
		SampleTestFunctional sa = new SampleTestFunctional();
		Misaka misaka = sa.getClazz(Misaka::new);
		System.out.println(misaka.get());
	}

結果

test_constructor

グッジョブです！と、ミサカは惜しみない賞賛を贈ります。

御坂妹

FunctionalInterfaceとラムダ式は、非常に柔軟な実装ができるようになりそうですね

Javaの@FunctionalInterfaceでラムダ式と遊ぶ