0

是否值得制作更好的代码（ClassB）而不是使用两种单独的检查方法？所以主要的问题是：当我假设 A 类比 B 类快一点时我是对的，还是它的区别并不重要并且传递变量（在这种情况下为列表）并不会真正影响生产力，即使这些列表每个有 1000 个对象？对不起，如果这个问题很愚蠢。

 public class ClassA implements Runnable {

    ArrayList<Obj> list1;
    ArrayList<Obj> list2;

    boolean checkList1() {
        for (Obj str : list1) {
            if (str.check()) {
                return true;
            }
        }
        return false;
    }

    boolean checkList2() {
        for (Obj str : list2) {
            if (str.check()) {
                return true;
            }
        }
        return false;
    }

    @Override
    public void run() {
        checkList1();
        checkList2();
    }
}

或者

 public class ClassB implements Runnable {

    ArrayList<Obj> list1;
    ArrayList<Obj> list2;

    boolean checkAnyList(ArrayList<Obj> list) {
        for (Obj str : list) {
            if (str.check()) {
                return true;
            }
        }
        return false;
    }

    @Override
    public void run() {
        checkAnyList(list1);
        checkAnyList(list2);
    }

}
4

5 回答 5

1

你在做同样的事情，所以没有区别。

于 2017-08-22T13:28:39.027 回答
1

做同样的事情。所以没有区别

于 2017-08-22T13:30:13.537 回答
1

要点是代码重复——你做了两次完全相同的事情，请不要。每当你必须改变某些东西时——至少有两个地方你可能需要改变——很容易忘记。

更有趣的是，最终第二种方法可能更快，因为只有一种方法JVM JIT需要优化；比方说inline it。

于 2017-08-22T13:30:13.607 回答
1

您可以自己测试，但最终差异几乎不存在，所以我会选择更易于阅读和维护的版本（我会说是版本 2）。

从 Java 8 开始，也可能是这样的：

//Note that this doesn't match your code exacly but you should get what I mean.
//Since you didn't provide any hint on how you'd use the return values of your methods I'm working on assumptions here.
boolean result = list1.stream().anyMatch(o -> o.check() ) &&
                 list2.stream().anyMatch(o -> o.check() ) ;

一个可能更好的变体，因为重构不需要您更改多个谓词，可能是这样的：

//Changes to how you'd check your elements would just require you to change this predicate.
Predicate<? super Obj> predicate = o -> o.check();
boolean result = list1.stream().anyMatch( predicate ) &&
                 list2.stream().anyMatch( predicate ) ;
于 2017-08-22T13:30:27.000 回答
1

最后，你应该测量它。为此，您可以使用高精度计时器，例如System.nanoTime()

如果不测量，我更喜欢 B 类。以下问题使classB更有趣

  • 避免几乎重复的代码
  • 引入更多列表时更灵活
  • JIT 编译器根据调用次数改进代码。因此，classB 中的方法更早地达到了改进的阈值。
  • 静态可用列表不可能比引用列表快。classA 不通过列表的小优势，确实只节省了很少的启动时间。

等我得到真实数据....

于 2017-08-22T13:52:24.603 回答