Question

我有一个要处理的列表。这些项目要么启用, 要么禁用。用户可以选择是否显示禁用的项目。

So you have cond2 that depends on the items, and cond1 that does not. Here s the dilemma I got into: Should I use cond1 && !cond2 or !(!cond1 || cond2)? Or should I check for the cond2 (show disabled items) before the loop? I also thought (as you will see in the code I put) if I should put the cond2 before cond1, because cond2 is a boolean variable, and with "short-circuits" (lazy evaluation?), it will be faster?

我主要关心的是速度,如果我在循环中有许多项目,这可能是一个重要的变化。

这是说明选项的代码:

// First Option
for (String item : items) {
    doSomethingFirst(item);
    if (isDisabled(item) && !showDisabled) {
        continue;
    }
    doSomethingElse(item);
}

// Second Option
for (String item : items) {
    doSomethingFirst(item);
    if (!(!isDisabled(item) || showDisabled)) {
        continue;
    }
    doSomethingElse(item);
}

// Third Option
if (showDisabled) {
    for (String item : items) {
        doSomethingFirst(item);
        doSomethingElse(item);
    }
} else {
    for (String item : items) {
        doSomethingFirst(item);
        if (isDisabled(item)) {
            continue;
        }
        doSomethingElse(item);
    }
}

所以, is disabled (it) 和 how disabled 的顺序是否重要? 我应该在循环之前检查事项吗? 还是编译器优化了这一点? (I doubt...)

" 坚固 " / " 坚固 " 如果相关,我不知道我将如何进行测量,以查看实际值。

谢谢

Answer 1

在 Java 中,表达式从左到右被评估。如果第一个条件是假的, 则 < code_ amp; & amp; 。如果第一个条件是假的, 第二个条件没有执行, 如果第一个条件是真实的, 第二个条件是不执行。

所以首先尝试将可以更快解析的条件放在首位, 在您的情况下, show Disabled 。

第三例,它看起来更好,因为你只检查过一次布林,但我猜它不会真正改变性能,布林比较并不真正昂贵。在代码的其他部分,你可能会有更好的改进。(对于可读性方面,它不是我最喜欢的 - 相当长)

如果您想要测量您案例中的性能, 请使用一个剖析档器, 例如。

或者在您的代码中添加 :

long start=System.currentTimeMillis();
//code to analyse
long timeSpent = System.currentTimeMillis()-start

您需要将代码放入一个循环中, 才能使其具有相关性。您可能会注意到 Java 会在某些循环后提高性能 ; ) 。

Answer 2

关于可读性,另一个良好做法是用正态命名函数和变量。很难读取双倍负数。您更愿意读哪一个?

enabled

或

!disabled

虽然用否定的形式命名事物是有道理的,但也有少数例子。例如,如果你用它们来终止条件,例如文件的结尾。 while (! feof(fp))

但在大多数情况下,规范应该是用正面的形式命名事物,因此阅读守则的摩擦较少。

让我们看看你的代码看起来如何正面的形式:

// First Option
for (String item : items) {
    doSomethingFirst(item);

    // if (isDisabled(item) && !showDisabled) {

    if (!isEnabled(item) && showEnabled) {
        continue;
    }
    doSomethingElse(item);
}

该守则的可读性肯定有所改善。

即使以下内容也能读懂, 也可以避免双重负值, 阅读代码其实只是阅读它, 而不是太多。我曾经读过一篇文章, 指出写代码的时候, 阅读代码应该也会非常愉快, 他说阅读代码不应该像读侦探小说一样。阅读双负值代码就像阅读和破译侦探小说。

// Second Option
for (String item : items) {
    doSomethingFirst(item);

    // if (!(!isDisabled(item) || showDisabled)) {

    // You can now avoid double negatives
    if (!( isEnabled(item) || !showEnabled )) {
        continue;
    }
    doSomethingElse(item);
}

事实上,以下不单是双重否定,而是三重否定:

if (!! (! is disabled (itm) ) (! (!) is disabled( item)

isDisabled
!isDisabled
!(!isDisabled

它需要双通读取,甚至三通读取才能破解代码的用意

Answer 3

和这些类型的问题一样, 您应该测量它来确定它本身是否是你的瓶颈。如果是这样的话, 那么我会测量替代方案。我怀疑上述假设方案不会对您的替代方案造成任何影响, 特别是因为您可能会在列表条目上做一些更繁重的事情( 将它们写入 db 或文件? ) 。

最简单的测量方法就是生成一个数量可观的列表, 在您处理、处理和记录 ms (或秒) 之前记录时间( 例如, 通过 System. pentimateTimeMillis () ) 。

Answer 4

我应使用 Cond1 & amp; & amp;! cond2 或! (! cond1 cond2) 吗? 或者我应在循环前检查 cond2( 显示禁用项目)?

无论你最能表达你的想法, 也就是更易读的东西。

我主要关心的是速度。

写作速度? 重组速度? 编译速度? 发展速度? 阅读和理解速度?调试速度?执行速度?

你不能同时拥有全部,没有语言

Answer 5

我将去选择1,然后倒转开关

isDisabled(item) && !showDisabled

与

!showDisabled && isDisabled(item)

If isDisabled(...) is as slow as you say it is better to test the faster case first. Now compared to the other option this is the most explicit and readable:

We do something is done for all items
we skip for items which validate some test
we do something for all other items.

更明确的是很难做到的。第三种选择是明显的丑陋。

友情链接