Java 8ラムダVoid引数

Java 8に次の機能インターフェースがあるとします。

interface Action<T, U> {
   U execute(T t);
}

そして、いくつかのケースでは、引数や戻り値のないアクションが必要です。だから私はこのようなものを書きます：

Action<Void, Void> a = () -> { System.out.println("Do nothing!"); };

しかし、それは私にコンパイルエラーを与えます、私はそれを次のように書く必要があります

Action<Void, Void> a = (Void v) -> { System.out.println("Do nothing!"); return null;};

醜いです。Void型パラメーターを取り除く方法はありますか？

あなたは後にしている構文は、変換の小さなヘルパー関数で可能であるRunnableにAction<Void, Void>（あなたがそれを置くことができるActionなど）：

public static Action<Void, Void> action(Runnable runnable) {
    return (v) -> {
        runnable.run();
        return null;
    };
}

// Somewhere else in your code
 Action<Void, Void> action = action(() -> System.out.println("foo"));

Supplier何も取らないが何かを返す場合に使用します。

Consumer何かをとるが何も返さない場合に使用します。

Callable結果を返し、スローする可能性がある場合に使用します（Thunk一般的なCS用語とほとんど同じです）。

Runnableどちらも行わず、スローできない場合に使用します。

ラムダ：

() -> { System.out.println("Do nothing!"); };

実際には、次のようなインターフェースの実装を表します。

public interface Something {
    void action();
}

これは、定義したものとは完全に異なります。そのため、エラーが発生します。

を拡張する@FunctionalInterfaceことも、新しいものを導入することもできないため、選択肢はあまりないと思います。Optional<T>ただし、インターフェースを使用して、一部の値（戻り値の型またはメソッドのパラメーター）が欠落していることを示すことができます。ただし、これによってラムダボディが単純になるわけではありません。

その特別な場合のためにサブインターフェースを作成できます：

interface Command extends Action<Void, Void> {
  default Void execute(Void v) {
    execute();
    return null;
  }
  void execute();
}

デフォルトのメソッドを使用して、継承されたパラメーター化されたメソッドをオーバーライドしVoid execute(Void)、呼び出しをより単純なメソッドに委任しますvoid execute()。

その結果、使用がはるかに簡単になります。

Command c = () -> System.out.println("Do nothing!");

この表は短くて便利だと思います：

Supplier       ()    -> x
Consumer       x     -> ()
Callable       ()    -> x throws ex
Runnable       ()    -> ()
Function       x     -> y
BiFunction     x,y   -> z
Predicate      x     -> boolean
UnaryOperator  x1    -> x2
BinaryOperator x1,x2 -> x3

他の回答で述べたように、この問題の適切なオプションは Runnable

それは不可能です。void以外の戻り値の型を持つ関数は、それがであってもVoid、値を返す必要があります。ただし、静的メソッドを追加しActionて、「作成」することができますAction。

interface Action<T, U> {
   U execute(T t);

   public static Action<Void, Void> create(Runnable r) {
       return (t) -> {r.run(); return null;};
   }

   public static <T, U> Action<T, U> create(Action<T, U> action) {
       return action;
   } 
}

これにより、次のように記述できます。

// create action from Runnable
Action.create(()-> System.out.println("Hello World")).execute(null);
// create normal action
System.out.println(Action.create((Integer i) -> "number: " + i).execute(100));

関数型インターフェース内に静的メソッドを追加する

package example;

interface Action<T, U> {
       U execute(T t);
       static  Action<Void,Void> invoke(Runnable runnable){
           return (v) -> {
               runnable.run();
                return null;
            };         
       }
    }

public class Lambda {


    public static void main(String[] args) {

        Action<Void, Void> a = Action.invoke(() -> System.out.println("Do nothing!"));
        Void t = null;
        a.execute(t);
    }

}

出力

Do nothing!

あなたの例では関数定義が一致しないため、それは可能ではないと思います。

ラムダ式は次のように正確に評価されます

void action() { }

一方、宣言は次のようになります

Void action(Void v) {
    //must return Void type.
}

例として、次のインターフェイスがある場合

public interface VoidInterface {
    public Void action(Void v);
}

互換性がある唯一の種類の関数（インスタンス化中）は次のようになります

new VoidInterface() {
    public Void action(Void v) {
        //do something
        return v;
    }
}

また、returnステートメントまたは引数が不足していると、コンパイラエラーが発生します。

したがって、引数を取って返す関数を宣言すると、上記のどちらも行わない関数に変換することは不可能だと思います。

参考までに、メソッドが値をスローしたり返したりする場合のメソッド参照に使用できる機能インターフェイスを示します。

void notReturnsNotThrows() {};
void notReturnsThrows() throws Exception {}
String returnsNotThrows() { return ""; }
String returnsThrows() throws Exception { return ""; }

{
    Runnable r1 = this::notReturnsNotThrows; //ok
    Runnable r2 = this::notReturnsThrows; //error
    Runnable r3 = this::returnsNotThrows; //ok
    Runnable r4 = this::returnsThrows; //error

    Callable c1 = this::notReturnsNotThrows; //error
    Callable c2 = this::notReturnsThrows; //error
    Callable c3 = this::returnsNotThrows; //ok
    Callable c4 = this::returnsThrows; //ok

}


interface VoidCallableExtendsCallable extends Callable<Void> {
    @Override
    Void call() throws Exception;
}

interface VoidCallable {
    void call() throws Exception;
}

{
    VoidCallableExtendsCallable vcec1 = this::notReturnsNotThrows; //error
    VoidCallableExtendsCallable vcec2 = this::notReturnsThrows; //error
    VoidCallableExtendsCallable vcec3 = this::returnsNotThrows; //error
    VoidCallableExtendsCallable vcec4 = this::returnsThrows; //error

    VoidCallable vc1 = this::notReturnsNotThrows; //ok
    VoidCallable vc2 = this::notReturnsThrows; //ok
    VoidCallable vc3 = this::returnsNotThrows; //ok
    VoidCallable vc4 = this::returnsThrows; //ok
}