使用Comparator.comparingLong比long.compare有什么优势吗？

Question

出于好奇，如果在java8样式中使用Comparator，即使用Lambda表达式比常规比较有任何优势，即。

一种按id排序的方法是：-

List sortedAcs = ac
.stream()
.sorted((a, b) -> Long.compare(a.getId(), b.getId())) //sorted by id here
.collect(Collectors.toList());

其他方法可以是Java 8 way:-

List sortedAcs = ac
.stream()
.sorted(Comparator.comparingLong(AC::getId)) //sorted by id here
.collect(Collectors.toList());

与前一种方法相比，后一种方法(< code>java-8方法参考)是否有性能优势？

请帮忙！！！

Answer 1

因此，从一个角度（即性能）得出答案。

这是我用来测试它的代码：-

AC类:-

package com.test;

public class AC {

    private Long id;

    public AC(Long id) {
        this.id = id;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "AC{" +
                "id=" + id +
                '}';
    }
}

主类：-

package test.java;

import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class Main {

    @org.openjdk.jmh.annotations.Benchmark
    public void measureName() {
        List<AC> acs = new ArrayList<>();

        acs.add(new AC(20l));
        acs.add(new AC(30l));
        acs.add(new AC(10l));
        acs.add(new AC(30l));
        acs.add(new AC(80l));
        acs.add(new AC(50l));
        acs.add(new AC(30l));
        acs.add(new AC(90l));
        acs.add(new AC(80l));
        acs.add(new AC(110l));

   /*     acs
                .stream()
                .sorted(Comparator.comparingLong(AC::getId)) //sorted by id here
                .collect(Collectors.toList());*/

        acs.stream()
                .sorted((a, b) -> Long.compare(a.getId(), b.getId())) //sorted by id here
                .collect(Collectors.toList());

    }

    public static void main(String[] args) {

        Options opt = new OptionsBuilder()
                .include(".*" + Main.class.getSimpleName() + ".*")
                .forks(1)
                .build();

        try {
            new Runner(opt).run();
        } catch (RunnerException e) {
            e.printStackTrace();
        }
    }
}

使用< code > comparator . comparing long :的JMH输出如下

# Run complete. Total time: 00:00:40

Benchmark          Mode  Cnt        Score       Error  Units
Main.measureName  thrpt   20  4130836.283 ± 86675.431  ops/s

对于下面的Long.compare：-

# Run complete. Total time: 00:00:40

Benchmark          Mode  Cnt        Score        Error  Units
Main.measureName  thrpt   20  4106542.318 ± 146956.814  ops/s

如果我按照这些统计< code>Long.compare不知何故要快一些，尽管差别很小。

如果有任何发现，请随时发表评论，我也会尝试。

Answer 2

两个代码片段中的任何性能差异都是可以忽略的。如果您真的需要优化该代码，那么不使用流可能会比更换该比较器带来更大的性能提升。

在两种变体之间进行选择的唯一标准是清晰度：您认为哪一个更清楚地传达了代码的意图？最后，这是个人喜好，具体取决于您对Java 8功能的熟练程度等。

就我个人而言，我发现第二个片段比第一个片段更清晰。比较龙方法（和其他比较X方法）立即告诉我：这里我们正在根据（Long-type）属性的值比较对象。在第一个片段中，我首先需要解析代码以确定确实发生了这种情况。

Answer 3

唯一不同的是完成您想要的方法的数量。Comparator.comparingLong将为每个参数应用ToLong函数，然后委托给Long.compare。但这是一个简单的优化，JIT应该处理。我想说，由于这种差异，可能会有一点差异（直到JIT开始），但它太小了，绝对可以忽略，不应该以任何方式驱动您的决定。

另一方面，如果您确实看到任何差异，那么问题可能是您的测试代码，而不是正在测量的代码。