在 Java 中按 lambda 返回值

lambda java runnable

2022-09-03 13:28:42

直到现在，我设法找到我需要的所有答案，但这个让我感到困惑。假设我们有示例代码：

public class Animal {
   private String species;
   private boolean canHop;
   private boolean canSwim;
   public Animal(String speciesName, boolean hopper, boolean swimmer) {
     species = speciesName;
     canHop = hopper;
     canSwim = swimmer;
   }
  public boolean canHop() { return canHop; }
  public boolean canSwim() { return canSwim; }
  public String toString() { return species; }
}

public interface CheckAnimal {
   public boolean test(Animal a);
}

public class FindSameAnimals {
   private static void print(Animal animal, CheckAnimal trait) {
      if(trait.test(animal)){
         System.out.println(animal);
      }

   public static void main(String[] args) {
      print(new Animal("fish", false, true), a -> a.canHop());
   }
}

OCA学习指南（考试1Z0-808）一书说，这两行是等效的：

a -> a.canHop()
(Animal a) -> { return a.canHop(); }

这是否意味着，在幕后，Java在第一种情况下将关键字添加到代码中？

如果答案是肯定的，那么下一个代码如何编译（想象一下其他所有内容都在适当的位置）：

static int counter = 0;
ExecutorService service = Executors.newSingleThreadExecutor();
service.execute(() -> counter++));

如果我们知道执行和 Runnable 运行的签名是：

void execute(Runnable command)
void run()

如果答案是否定的，那么Java如何知道何时需要返回某些内容，何时不需要返回？也许在

a -> a.canHop()

我们想要忽略布尔返回类型的方法。

答案 1

这是否意味着，在幕后，Java在第一种情况下将关键字添加到代码中？

否，编译器生成字节码，并且可能会生成相同的字节码，但它不会更改语法，然后再次编译。

我们想要忽略布尔返回类型的方法。

它可以选择根据它正在考虑的功能接口忽略值。

a -> a.canHop()

可能是

(Animal a) -> { return a.canHop(); }

或

(Animal a) -> { a.canHop(); }

基于上下文，但是如果可能的话，它倾向于第一个。

考虑和ExecutorService.submit(Callable<T>)ExecutorService.submit(Runnable)

ExecutorService es = Executors.newSingleThreadExecutor();
es.execute(() -> counter++); // has to be Runnable
es.submit(() -> counter++); // Callable<Integer> or Runnable?

保存返回类型，您可以看到它是一个Callable<Integer>

final Future<Integer> submit = es.submit(() -> counter++);

为了尝试自己，这里有一个更长的例子。

static int counter = 0;

public static void main(String[] args) throws ExecutionException, InterruptedException {
    ExecutorService es = Executors.newSingleThreadExecutor();

    // execute only takes Runnable
    es.execute(() -> counter++);

    // force the lambda to be Runnable
    final Future<?> submit = es.submit((Runnable) () -> counter++);
    System.out.println(submit.get());

    // returns a value so it's a Callable<Integer>
    final Future<Integer> submit2 = es.submit(() -> counter++);
    System.out.println(submit2.get());

    // returns nothing so it must be Runnable
    final Future<?> submit3 = es.submit(() -> System.out.println("counter: " + counter));
    System.out.println(submit3.get());

    es.shutdown();
}

指纹

null
2
counter: 3
null

第一个拿一个所以回报submitRunnableFuture.get()null

第二个默认为 so 返回submitCallableFuture.get()2

第三个只能是返回值，因此它必须是 so 返回submitvoidRunnableFuture.get()null

答案 2

是的，当仅指定单个语句时，其值将自动从 lambda 返回。

然后，由于Runnable是一个功能接口，它可以被定义为一个lambda。返回类型为，因此 lambda 内的任何返回值都将被忽略。void