相关疑难解决方法(0)

我在这里看到了很多关于Java lambdas性能的问题,但是大多数问题都像"Lambdas稍快一点,但在使用闭包时变慢"或"预热与执行时间不同"或其他类似的东西.

但是,我在这里遇到了一件相当奇怪的事情.考虑这个LeetCode问题:

给定一组非重叠间隔,在间隔中插入新间隔(必要时合并).

您可以假设间隔最初是根据其开始时间排序的.

问题被标记为难,所以我认为线性方法不是他们想要的.所以我决定想出一种聪明的方法将二进制搜索与修改结合到输入列表中.现在问题在修改输入列表时并不是很清楚 - 它表示"插入",即使签名需要返回对列表的引用,但现在也不用担心.这是完整的代码,但只有前几行与此问题相关.我在这里保留其余部分,以便任何人都可以尝试:

public List<Interval> insert(List<Interval> intervals, Interval newInterval) {
    int start = Collections.binarySearch(intervals, newInterval,
                                         (i1, i2) -> Integer.compare(i1.start, i2.start));
    int skip = start >= 0 ? start : -start - 1;
    int end = Collections.binarySearch(intervals.subList(skip, intervals.size()),
                                       new Interval(newInterval.end, 0),
                                       (i1, i2) -> Integer.compare(i1.start, i2.start));
    if (end >= 0) {
        end += skip; // back to original indexes
    } else {
        end -= skip; // ditto
    }
    int newStart = newInterval.start;
    int headEnd; …

Java 8闭包真的是一流的价值还是只是一个语法糖？

在获取流之前进行空检查的最佳/惯用方法是什么？

我有接收List可能为null的方法.所以我不能只调用.stream()传入的值.是否有一些静态助手,如果值为null,会给我一个空流？

如果我使用新语法获取方法引用:

anObject::aMethod

我总是得到同一个对象吗？也就是说,我可以相信对同一方法的两个引用是相同的吗？

例如,我很乐意知道是否计划将它们用作Runnable我可以添加和删除的回调:

someLibrary.addCallback(anObject::aMethod)
// later
someLibrary.removeCallback(sameObject::sameMethod)

这是否需要在Runnable变量中保存引用以保持其稳定？

请考虑以下Java 8代码段.

public static void main(String[] args) {            
   List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);

   Consumer<Integer>  consumer = x -> System.out.print(x);  

   integers.forEach(consumer);
}

什么是Consumer<Integer> consumer = x -> System.out.print(x)编译到？

我知道Lambdas不是作为匿名内部类实现的.然而Consumer<Integer>,接口因此x -> System.out.print(x)必须产生某种对象,但不清楚生成什么样的对象.

Java 8中是否有一些新类型的对象来表示lambda表达式？

更新这里是程序与eclipse java 8编译器一起编译的反编译程序,下面的输出是在打开类文件时来自eclipse.

看起来lambda表达式在包含lambda表达式的类上变成了一个静态方法 private static synthetic void lambda$0(java.lang.Integer x);

// Compiled from Example.java (version 1.8 : 52.0, super bit)
public class Example {

  // Method descriptor #6 ()V
  // Stack: 1, Locals: 1
  public Example();
    0  aload_0 …

Lambda是在Java8中引入的.包含lambda表达式的代码是否会在较旧的JVM上运行,例如,对于java 1.6？我担心二进制兼容性而不是源代码兼容性.这是一个简单的是/否问题.

谢谢.

我今天读过这篇关于lambdas的文章:

http://www.infoq.com/articles/Java-8-Lambdas-A-Peek-Under-the-Hood

文章建议,lambda 不是 作为anon内部类实现的(由于性能).它给出了一个示例,可以将lambda表达式编译为类的(静态)方法.

我试过一个非常简单的片段:

private void run() {
    System.out.println(this);
    giveHello(System.out::println);
}

private void giveHello(Consumer<String> consumer) {
    System.out.println(consumer);
    consumer.accept("hello");
}

输出是:

sample.Main@14ae5a5
sample.Main$$Lambda$1/168423058@4a574795
hello

所以它不是同一个实例.它不是一些中央的"Lambda Factory"实例.

那么lambdas是如何实现的？

我想知道方法引用和功能接口的所有这些东西如何在较低级别上工作.最简单的例子是我们有一些List

List<String> list = new ArrayList<>();
list.add("b");
list.add("a");
list.add("c"):

现在我们想用Collections类对它进行排序,所以我们可以调用:

Collections.sort(list, String::compareToIgnoreCase);

但是,如果我们定义自定义比较器,它可能是这样的:

Comparator<String> customComp = new MyCustomOrderComparator<>();
Collections.sort(list, customComp::compare);

问题是Collections.sort有两个参数:List和Comparator.由于Comparator是功能接口,因此可以使用具有相同签名(参数和返回类型)的lambda表达式或方法引用替换它.那么它是如何工作的,我们也可以传递compareTo只引用一个参数并且这些方法的签名不匹配？如何在Java8中翻译方法引用？

以下代码:

public static void main(String[] args) {
    Collections.singleton(1).stream().forEach(i -> new Exception().printStackTrace());
}

打印:

java.lang.Exception
    at PrintLambdaStackTrace.lambda$main$0(PrintLambdaStackTrace.java:6)
    at PrintLambdaStackTrace$$Lambda$1/1831932724.accept(Unknown Source)
    at java.util.Collections$2.tryAdvance(Collections.java:4717)
    at java.util.Collections$2.forEachRemaining(Collections.java:4725)
    at java.util.stream.ReferencePipeline$Head.forEach(ReferencePipeline.java:580)
    at PrintLambdaStackTrace.main(PrintLambdaStackTrace.java:6)

lambda调用是如何实现的？为什么有2个堆栈帧？

关于Java 8中的流,有大量关于流的信息和教程.我发现的大部分内容都很好地解释了流的各个元素如何在概念层面上工作.但是,我没有遇到过很多材料,这些材料描述了JVM实际上如何实现和执行流.

考虑比较Collection使用流和使用旧学前Java 8方式的操作.底层的Bytecodes在这两种方法之间看起来是否相同？性能是否相同？

为了使这个具体,请考虑以下示例,其中我需要找到名称中包含单词"fish"的所有鱼,然后将每个匹配鱼的第一个字母大写.(是的,我知道Hagfish实际上并不是一条鱼,但是我用完了匹配的鱼名.)

List<String> fishList = Arrays.asList("catfish", "hagfish", "salmon", "tuna", "blowfish");

// Pre Java-8 solution
List<String> hasFishList = new ArrayList<String>();

for (String fish : fishList) {
    if (fish.contains("fish")) {
        String fishCap = fish.substring(0, 1).toUpperCase() + fish.substring(1); 
        hasFishList.add(fishCap);
    }
}

// Java-8 solution using streams
List<String> hasFishList = fishList.stream()
    .filter(f -> f.contains("fish"))
    .map(f -> f.substring(0, 1).toUpperCase() + f.substring(1))
    .collect(Collectors.toList());

您可能对这两种方法在Bytecode级别下可能有何不同的见解会很有帮助.而一些实际的字节代码会更好.