Đối số lambda Java 8

Giả sử tôi có giao diện chức năng sau trong Java 8:

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

Và đối với một số trường hợp tôi cần một hành động không có đối số hoặc kiểu trả về. Vì vậy, tôi viết một cái gì đó như thế này:

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

Tuy nhiên, nó mang lại cho tôi lỗi biên dịch, tôi cần phải viết nó dưới dạng

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

Cái nào xấu. Có cách nào để thoát khỏi Voidtham số loại?

Cú pháp bạn theo sau là có thể với một hàm trợ giúp nhỏ chuyển đổi Runnablethành Action<Void, Void>( Actionví dụ bạn có thể đặt nó vào ):

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"));

Sử dụng Suppliernếu nó không mất gì, nhưng trả lại một cái gì đó.

Sử dụng Consumernếu nó mất một cái gì đó, nhưng không trả lại gì.

Sử dụng Callablenếu nó trả về một kết quả và có thể ném (gần giống với Thunkcác thuật ngữ CS nói chung).

Sử dụng Runnablenếu nó không và không thể ném.

Lambda:

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

thực sự đại diện cho một triển khai cho một giao diện như:

public interface Something {
    void action();
}

khác hoàn toàn so với cái bạn đã xác định. Đó là lý do tại sao bạn gặp lỗi.

Vì bạn không thể mở rộng @FunctionalInterface, cũng không giới thiệu một thương hiệu mới, nên tôi nghĩ bạn không có nhiều lựa chọn. Tuy nhiên, bạn có thể sử dụng các Optional<T>giao diện để biểu thị rằng một số giá trị (kiểu trả về hoặc tham số phương thức) bị thiếu. Tuy nhiên, điều này sẽ không làm cho cơ thể lambda đơn giản hơn.

Bạn có thể tạo giao diện phụ cho trường hợp đặc biệt đó:

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

Nó sử dụng một phương thức mặc định để ghi đè phương thức tham số được kế thừa Void execute(Void), ủy quyền cuộc gọi cho phương thức đơn giản hơn void execute().

Kết quả là nó đơn giản hơn nhiều để sử dụng:

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

Đó là không thể. Một hàm có kiểu trả về không trống (ngay cả khi nó Void) phải trả về một giá trị. Tuy nhiên, bạn có thể thêm các phương thức tĩnh để Actioncho phép bạn "tạo" a 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;
   } 
}

Điều đó sẽ cho phép bạn viết như sau:

// 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));

Tôi nghĩ bảng này ngắn và hữu ích:

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

Như đã nói ở các câu trả lời khác, tùy chọn thích hợp cho vấn đề này là Runnable

Thêm một phương thức tĩnh bên trong giao diện chức năng của bạn

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

}

Đầu ra

Do nothing!

Tôi không nghĩ là có thể, bởi vì các định nghĩa hàm không khớp trong ví dụ của bạn.

Biểu thức lambda của bạn được đánh giá chính xác như

void action() { }

trong khi tuyên bố của bạn trông giống như

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

làm ví dụ, nếu bạn có giao diện sau

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

loại chức năng duy nhất (trong khi khởi tạo) sẽ tương thích

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

và thiếu câu lệnh return hoặc đối số sẽ cung cấp cho bạn lỗi trình biên dịch.

Do đó, nếu bạn khai báo một hàm lấy một đối số và trả về một hàm, tôi nghĩ rằng không thể chuyển đổi nó thành hàm không được đề cập ở trên.

Chỉ để tham khảo giao diện chức năng nào có thể được sử dụng để tham chiếu phương thức trong trường hợp phương thức ném và / hoặc trả về giá trị.

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
}