将空检查替换为可选的

Question

if (item!= null)
{
   if (item.getCrystal() == Crystal.A)
   {
     player.getInventory().addItem(inventoryItem);
   }
}

我喜欢的，我觉得很酷的东西

Optional.ofNullable(item).filter(i -> i.getCrystal() == Crystal.A).ifPresent(k -> player.getInventory.addItem(i));

有人能告诉我我没意见吗？也许很酷，但成本很高？我不知道.多谢.

Answer 1

在像这样的简单情况下，及时编译器可能会省略对象分配，或者至少在堆栈上分配对象，因此开销可以忽略不计。

这里有一个小基准：

public abstract class Benchmark {

    final String name;

    public Benchmark(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return name + "\t" + time() + " ns / iteration";
    }

    private BigDecimal time() {
        try {
            // automatically detect a reasonable iteration count (and trigger just in time compilation of the code under test)
            int iterations;
            long duration = 0;
            for (iterations = 1; iterations < 1_000_000_000 && duration < 1_000_000_000; iterations *= 2) {
                long start = System.nanoTime();
                run(iterations);
                duration = System.nanoTime() - start;
                cleanup();
            }
            return new BigDecimal((duration) * 1000 / iterations).movePointLeft(3);
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Executes the code under test.
     * @param iterations
     *            number of iterations to perform
     * @return any value that requires the entire code to be executed (to
     *         prevent dead code elimination by the just in time compiler)
     * @throws Throwable
     *             if the test could not complete successfully
     */
    protected abstract Object run(int iterations) throws Throwable;
    
    /**
     * Cleans up after a run, setting the stage for the next.
     */
    protected void cleanup() {
        // do nothing
    }

    public static void main(String[] args) throws Exception {
        Integer[] a = {null, -1, null, 1}; // mix nulls and real values
        
        System.out.println(new Benchmark("Optional") {
            @Override
            protected Object run(int iterations) throws Throwable {
                int[] sum = {0};
                for (int i = 0; i < iterations; i++) {
                    Optional.ofNullable(a[i & 3]).filter(k -> k > 0).ifPresent(k -> sum[0] += k);
                }
                return sum[0]; 
            }
        });
        System.out.println(new Benchmark("if != null") {
            @Override
            protected Object run(int iterations) throws Throwable {
                int[] sum = {0};
                for (int i = 0; i < iterations; i++) {
                    var k = a[i & 3];
                    if (k != null && k % 2 != 0) {
                        sum[0] += k; 
                    }
                }
                return sum[0]; 
            }
        });
    }
}

这表明，使用可选的开销大约为1 ns，即现代CPU每秒可以构造和计算大约10亿个可选对象。除了最极端和人为的工作负载之外，使用可选的对性能的影响不足以让人注意到。

if (item != null && item.getCrystal() == Crystal.A) player.getInventory().addItem(inventoryItem);

Optional.ofNullable(item).filter(i -> i.getCrystal() == Crystal.A).ifPresent(k -> player.getInventory.addItem(i));

当然，在实际代码中，您可能希望将行数保持得相当短，因此比较如下

if (item != null && item.getCrystal() == Crystal.A) {
    player.getInventory().addItem(inventoryItem);
}

VS

Optional.ofNullable(item).filter(i -> i.getCrystal() == Crystal.A)
    .ifPresent(k -> player.getInventory.addItem(i));

同样，我发现第一个版本更易读，因为它包含的单词更少。