相关疑难解决方法(0)

是否可以将方法作为参数传递给Java方法？如果是这样,有人可以指导我吗？这似乎并不重要

该invokedynamic指令用于帮助VM在运行时确定方法引用,而不是在编译时对其进行硬连线.

这对于动态语言很有用,其中确切的方法和参数类型在运行时才知道.但Java lambda不是这种情况.它们被转换为具有明确定义的参数的静态方法.并且可以使用此方法调用此方法invokestatic.

那么invokedynamiclambda 的需求是什么,尤其是在性能受到影响的情况下？

我正在尝试在Scala中实现预定的未来.我希望它等待特定时间然后执行正文.到目前为止,我尝试了以下简单方法

val d = 5.seconds.fromNow

val f = future {Await.ready(Promise().future, d.timeLeft); 1}

val res = Await.result(f, Duration.Inf)

但我正在接受未来的TimeoutExcpetion.这甚至是正确的方法还是我应该只使用Java中的ScheduledExecutor？

我正在学习Kotlin.在此之前,我曾使用Java进行Android开发.Kotlin是一门很好的学习语言.我在使用时感到困惑setOnClickListener(View.OnClickListener).我在Android Studio上看到了两个提示.

我知道如何工作或定义它们.

第一种实施方式 OnClickListerner

 send_button.setOnClickListener(object : View.OnClickListener{
       override fun onClick(p0: View?) {
           TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
       }
   })

这是第二种实施方式 OnClickListener

 send_button.setOnClickListener {
        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
    }

我理解第二种方法基于lambda.但我无法正确理解这些方法.

所以,我的问题是:这些方法有什么区别？如果它们不同,哪一个更好,为什么？

我对以下风格的代码进行了评论:

Iterable<String> upperCaseNames = Iterables.transform(
    lowerCaseNames, new Function<String, String>() {
        public String apply(String input) {
            return input.toUpperCase();
        }
    });

该人说,每次我通过这段代码,我都会实例化这个匿名的Function类,而我宁愿在一个静态变量中有一个实例:

static Function<String, String> toUpperCaseFn =
    new Function<String, String>() {
        public String apply(String input) {
            return input.toUpperCase();
        }
    };
...
Iterable<String> upperCaseNames =
    Iterables.transform(lowerCaseNames, toUpperCaseFn);

在一个非常肤浅的层面上,这在某种程度上是有道理的; 多次实例化一个类必须浪费内存或其他东西,对吧？

另一方面,人们在代码中间实例化匿名类,就像没有明天一样,编译器优化它是微不足道的.

这是一个有效的问题吗？

在Java 8中，提供了许多函数式接口，例如UnaryOperator、BinaryOperator和Function等。

代码，

UnaryOperator<Integer> uOp = (Integer i) -> i * 10;
BinaryOperator<Integer> bOp = (Integer i1, Integer i2) -> i1 * i2 * 10;

总是可以使用函数编写如下，

Function<Integer, Integer> f1 = (Integer i) -> i * 10;
BiFunction<Integer, Integer, Integer> f2 = (Integer i1, Integer i2) -> i1 * i2 * 10;

那么，这些操作界面有什么用呢？他们实现的目标是否与使用 Function 实现的目标不同？

我在替换这个特定的例子时遇到了问题:

Consumer consumer = new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body)
            throws IOException {
        String message = new String(body, "UTF-8");
        System.out.println(" [x] Received '" + message + "'");
    }
};

是否可以用lambda替换它,因为它使用DefaultConsumer的非默认构造函数？

它来自rabbitMQ java教程 - > LINK到全班

在最近的一次采访中，有人问我一个问题：“我们怎么能说java8中的功能接口类似于标记接口”。

我无法回答这个问题。

但是我认为标记甚至没有任何方法，而功能接口必须要覆盖一种方法。

有人可以帮助我理解这是否在某些情况下是有效的论点，或者问题本身是错误的？

我正在学习lambda表达式.我不明白如何从方法引用返回比较器.

我想按年龄排序一份人员名单.

要做到这一点,我有一个方法来找到年龄差异:

public int ageDifference(final Person other) {
    return age - other.age;
}

该sorted方法需要作为参数aComparator

Stream<T> sorted(Comparator<? super T> comparator);

我的lambda表达式是:

people.stream()
.sorted(Person::ageDifference)
.collect(toList());

怎么Person::ageDifference变形Comparator<Person>？

我的完整例子:

public class Person {

private final String name;
private final int age;

public Person(final String theName, final int theAge) {
    name = theName;
    age = theAge;
}

public String getName() {
    return name;
}

public int getAge() {
    return age;
}

public int ageDifference(final Person other) { …