Java 8 lambda 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类型参数?

当前回答

与@rado回答参数和描述相同的方法:

/*----------------------
Represents an operation
that accepts two input
arguments and returns no
result.
*/
BiConsumer<T,U>         (T x, U y)  -> ()


/*----------------------
Represents a function
that accepts two arguments
and produces a result.
*/
BiFunction<T,U,R>       (T x, U y)   -> R z


/*----------------------
Represents an operation
upon two operands of the
same type, producing a
result of the same type
as the operands.
*/
BinaryOperator<T>       (T x1, T x2) -> T x3


/*----------------------
A task that returns a
result and may throw an
exception.
*/
Callable<V>             ()    -> V x   throws ex


/*----------------------
Represents an operation
that accepts a single
input argument and returns
no result.
*/
Consumer<T>             (T x)   -> ()


/*----------------------
Represents a function that
accepts one argument and
produces a result.
*/
Function<T,R>           (T x)   -> R y


/*----------------------
Represents a predicate
(boolean-valued function)
of one argument.
*/
Predicate<T>            (T x)   -> boolean


/*----------------------
Represents a portion of
executable code that
don't recieve parameters
and returns no result.
*/ 
Runnable                ()    -> ()


/*----------------------
Represents a supplier of
results.
*/
Supplier<T>             ()      -> T x

/*----------------------
Represents an operation 
on a single operand that
produces a result of the
same type as its operand.
*/
UnaryOperator<T>        (T x1)  -> T x2

字体:

[1] https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html

[2] https://docs.oracle.com/javase/8/docs/api/java/lang/Runnable.html

[3] https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Callable.html

2022-08-27 00:30:51

其他回答

λ:

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

实际上表示接口的实现，如下所示:

public interface Something {
    void action();
}

这和你定义的完全不同。这就是为什么你会得到一个错误。

既然你不能扩展你的@FunctionalInterface，也不能引入一个全新的接口，那么我认为你没有太多的选择。不过，您可以使用Optional<T>接口来表示缺少某些值(返回类型或方法参数)。然而，这并不会使体更简单。

2015-04-29 13:50:01

如果它不需要任何东西，但返回一些东西，则使用Supplier。

如果它获取一些东西，但不返回任何东西，则使用Consumer。

如果Callable返回一个结果并且可能抛出，则使用Callable(最类似于一般CS术语中的Thunk)。

如果Runnable既不做也不能抛出，则使用Runnable。

2016-10-20 11:31:43

我认为这是不可能的，因为函数定义在您的示例中不匹配。

lambda表达式的计算结果完全为

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语句或参数都会导致编译器错误。

因此，如果你声明一个函数接受一个参数并返回一个，我认为不可能将它转换为上面提到的任何一个函数。

2015-04-29 14:03:40

你所追求的语法是可以用一个小的帮助函数将一个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"));

2015-04-29 14:06:15