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

и отсутствие оператора возврата или аргумента приведет к ошибке компилятора.

Поэтому, если вы объявляете функцию, которая принимает аргумент и возвращает его, я думаю, что невозможно преобразовать ее в функцию, которая не выполняет ни одного из упомянутых выше.

Просто для справки, какой функциональный интерфейс может быть использован для ссылки на метод в случаях, когда метод вызывает и / или возвращает значение.

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
}