Java 处理奇偶元素最有效的方法是什么？ 方法1 int[]arr=newint[10]； 对于（int i=0；i

从方法1切换到方法3时

在一个大团队的生产环境中，在2和3之间选择一种方法有哪些优点和缺点

编辑

---

当您拥有分布式团队时，在不牺牲太多可读性的情况下，哪种方法是最好的？

如果性能是您想要的，我会把我的钱押在以下几点上：

    for(int i = 0; i < arr.length; i+=2) {
        // do even stuff
    }
    for(int i = 1; i < arr.length; i+=2) {
        // do odd stuff
    }

现在是计时部分：

public static void main(String[] args) {
    int[] arr = new int[10000000];
    // Warm up
    withModulus(arr);
    withFlag(arr);
    withAnd(arr);
    withTwoLoops(arr);
    // Timing
    int iterations = 100;
    long meanModulus = 0, meanFlag = 0, meanAnd = 0, meanTwoLoops = 0;
    for (int i = 0; i < iterations; i++) {
        meanModulus += withModulus(arr);
    }
    for (int i = 0; i < iterations; i++) {
        meanFlag += withFlag(arr);
    }
    for (int i = 0; i < iterations; i++) {
        meanAnd += withAnd(arr);
    }
    for (int i = 0; i < iterations; i++) {
        meanTwoLoops += withTwoLoops(arr);
    }
    System.out.println("Modulus: "+(meanModulus/iterations)+" ms");
    System.out.println("Flag: "+(meanFlag/iterations)+" ms");
    System.out.println("And: "+(meanAnd/iterations)+" ms");
    System.out.println("Two loops: "+(meanTwoLoops/iterations)+" ms");
}

您可以尝试使用不同的阵列大小，但对于大于10000的任何阵列，双循环选项都是最快的。

---

经过多次不同的运行和测试后，有时“and”版本最快，有时“two-loop”最快。甚至“模数”版本在其中一项测试中也是最快的。在生产中，它主要取决于您在循环中所做的事情，而不是条件本身。

我不喜欢方法2，因为如果稍后有人意外修改了

标志，会发生什么情况？另一方面，方法1和方法3直接检查实际数字的奇数。谁在乎呢？如果您不在if语句的分支中执行任何操作，则只能获得66%的性能提升。任何像这样的优化——如果它真的有效的话——都高度依赖于运行它的JVM的确切版本、确切的操作系统、机器配置（CPU、缓存等）。而且在绝大多数应用程序中，它不太可能影响应用程序的整体性能，正如他们所说，在一个大团队的生产环境中？请注意，您引用的关于66%性能提升的文章是关于ActionScript的，它是一种与Java完全不同的语言，运行时与Java完全不同。事实上，这个家伙通过ActionScript获得了这个结果，这并不意味着Java也得到了同样的结果。我认为，在一个拥有大型团队的生产环境中，这可能产生的最大影响是，你会因为明显缺乏技能/经验/理解而被解雇。但这个问题不值得回答，但这里有一些阅读材料给你：谢谢你的阅读材料！我已经开始让代码运行这些方法好几次，并采取措施获得更可靠的计时。不过，我不知道
nanoTime（）
！关于JMH，我的“学习”清单上有它，但老实说，我现在不想下载和学习使用它（除了写答案）。我会尽快看一看：）@NickWarke你知道你的问题完全无关，对吧？测试“不做任何事情”循环的速度是浪费时间。假设你得到了实习机会，开始写“最快”的循环。任何一个有能力的程序员都会问你为什么用这种奇怪的方式编写它们，如果你说“因为它更快”，你肯定会得到一个对话的机会。
int[] arr = new int[10];
for(int i = 0; i < arr.length; i++) {
    if((i & 1) == 1)
       // do stuff
    else
       // do stuff
}

int[] arr = new int[10];
for(int i = 0; i < arr.length; i+=2) {
   // do stuff for even numbers
}
for(int i = 1; i < arr.length; i+=2) {
   // do stuff for odd numbers
}

    for(int i = 0; i < arr.length; i+=2) {
        // do even stuff
    }
    for(int i = 1; i < arr.length; i+=2) {
        // do odd stuff
    }

private static long withModulus(int[] arr) {
    long elapsedTime = System.nanoTime();
    for(int i = 0; i < arr.length; i++) {
        List list;
        if ((i % 2) == 0) {
            list = new ArrayList<>();
            list.add(new Object());
        } else {
            list = new LinkedList<>();
            list.add(new Object());
        }
    }
    return (System.nanoTime() - elapsedTime);
}

private static long withFlag(int[] arr) {
    long elapsedTime = System.nanoTime();
    for(int i = 0; i < arr.length; i++) {
        List list;
        boolean flag = true;
        if (flag) {
            list = new ArrayList<>();
            list.add(new Object());
            flag = false;
        } else {
            list = new LinkedList<>();
            list.add(new Object());
            flag = true;
        }
    }
    return (System.nanoTime() - elapsedTime);
}

private static long withAnd(int[] arr) {
    long elapsedTime = System.nanoTime();
    for(int i = 0; i < arr.length; i++) {
        List list;
        if ((i & 1) == 1) {
            list = new ArrayList<>();
            list.add(new Object());
        } else {
            list = new LinkedList<>();
            list.add(new Object());
        }
    }
    return (System.nanoTime() - elapsedTime);
}

private static long withTwoLoops(int[] arr) {
    long elapsedTime = System.nanoTime();
    for(int i = 0; i < arr.length; i+=2) {
        List list;
        list = new ArrayList<>();
        list.add(new Object());
    }
    for(int i = 1; i < arr.length; i+=2) {
        List list;
        list = new LinkedList<>();
        list.add(new Object());
    }
    return (System.nanoTime() - elapsedTime);
}

public static void main(String[] args) {
    int[] arr = new int[10000000];
    // Warm up
    withModulus(arr);
    withFlag(arr);
    withAnd(arr);
    withTwoLoops(arr);
    // Timing
    int iterations = 100;
    long meanModulus = 0, meanFlag = 0, meanAnd = 0, meanTwoLoops = 0;
    for (int i = 0; i < iterations; i++) {
        meanModulus += withModulus(arr);
    }
    for (int i = 0; i < iterations; i++) {
        meanFlag += withFlag(arr);
    }
    for (int i = 0; i < iterations; i++) {
        meanAnd += withAnd(arr);
    }
    for (int i = 0; i < iterations; i++) {
        meanTwoLoops += withTwoLoops(arr);
    }
    System.out.println("Modulus: "+(meanModulus/iterations)+" ms");
    System.out.println("Flag: "+(meanFlag/iterations)+" ms");
    System.out.println("And: "+(meanAnd/iterations)+" ms");
    System.out.println("Two loops: "+(meanTwoLoops/iterations)+" ms");
}

Modulus: 82331604 ms
Flag: 96305740 ms
And: 80845864 ms
Two loops: 79633999 ms