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พารามิเตอร์ประเภทหรือไม่

ไวยากรณ์คุณหลังจากที่เป็นไปได้ด้วยฟังก์ชั่นช่วยตัวน้อยที่แปลง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) จะต้องส่งกลับค่า อย่างไรก็ตามคุณสามารถเพิ่มวิธีการคงที่เพื่อActionให้คุณ "สร้าง" 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;
   } 
}

ซึ่งจะช่วยให้คุณสามารถเขียนสิ่งต่อไปนี้:

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

และการขาดคำสั่งส่งคืนหรืออาร์กิวเมนต์จะทำให้เกิดข้อผิดพลาดของคอมไพเลอร์

ดังนั้นหากคุณประกาศฟังก์ชั่นที่รับอาร์กิวเมนต์และส่งคืนหนึ่งฉันคิดว่ามันเป็นไปไม่ได้ที่จะแปลงเป็นฟังก์ชันที่ไม่ได้กล่าวถึงข้างต้น

สำหรับการอ้างอิงว่าอินเตอร์เฟสการทำงานใดที่สามารถใช้สำหรับการอ้างอิงเมธอดในกรณีเมธอด throws และ / หรือคืนค่า

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
}