高效的循环代码？此外，有关“for each”循环的查询

Question

以下代码编译并完成我的要求。它遍历基于int的多维数组（称为nums），并搜索值1的所有出现。该程序的输出如下所示。有三点需要注意：

  
• 关于“outer for”循环语句，我使用了Java的逗号运算符来声明另外两个变量。
  
• 同样关于这个“外部为”，我在“迭代部分”中使用了另一个逗号运算符来重置其中一个附加变量。
  
• 关于“inner for”，我在“迭代部分”中使用了另一个逗号运算符来增加此附加变量。

int[][] nums = {{1,1,2},{3,4},{5},{6,7,8},{9,1,1}};

for (int i=0, elsSearched=0, foundCount=0; i < nums.length; i++, elsSearched=0) {
    for (int j=0; j < nums[i].length; j++, elsSearched++) {
        if (nums[i][j] == 1) {
            foundCount++;
        }
    }
    System.out.println("Searched " + elsSearched + 
" elements, and found \'number one\' a total of " + foundCount + " times..");
}       

节目输出：

这段代码可以更有效/优雅地编写吗？

我的另一个问题是关于Java的“for each”循环。我尝试使用逗号运算符使用“for each”循环重写上面的代码，但代码无法编译。我很快得出了明显的结论，但是如果逗号运算符可以与它一起使用，那么“for each”循环会更好吗，还是只会引入“令人分心的杂乱”？

Answer 1

编辑：请注意，foundCount是到目前为止找到的元素总数，因为它永远不会重置为零。是这个意图吗？

您是否同意此代码更易于阅读且更简洁？ （注意：效率与您的代码相同）

int[][] nums = {{1,1,2},{3,4},{5},{6,7,8},{9,1,1}};

int foundCount = 0; 
for(int[] inner : nums){
    for(int i : inner){
        if (i == 1){
            foundCount++;
        }
    }
    System.out.println("Searched " + inner.length + 
                " elements, and found \'number one\' a total of " + foundCount + " times..");
}

输出：

Searched 3 elements, and found 'number one' a total of 2 times..
Searched 2 elements, and found 'number one' a total of 2 times..
Searched 1 elements, and found 'number one' a total of 2 times..
Searched 3 elements, and found 'number one' a total of 2 times..
Searched 3 elements, and found 'number one' a total of 4 times..

Answer 2

首先，您可能不应该优化某些东西，直到您已经证明它是您的程序运行时的重要贡献者。话虽如此，为什么不尝试这个......

int foundCount = 0;
int totalCount = 0;
for (final int[] i : nums) { // foreach int[] in nums
  for (final int v : i) {    // foreach value v in the int[] from nums
    switch (v) {             // switch on a constant int...
    case 1:                  // The value we seek.
      ++foundCount;          // Add to the foundCount, and fall through!
    default:
      ++totalCount;
    }
  }
}
System.out.println("Searched a total of " + totalCount + 
            " elements and found '#1' a total of " + foundCount);

Answer 3

如果您遇到性能问题，可以尝试在子阵列上使用二进制搜索（如果您的数组始终排序）。

int valueToSearch = 1;

for(int[] inner : nums){

     int foundIndex = Arrays.binarySearch(inner, valueToSearch);

      if (foundIndex >= 0){
          foundCount ++;
       }

}

因此，您将获得O（n * log（n））而不是O（n ^ 2）的性能。

我想你必须做一些基准测试。但最重要的是知道你的输入是怎样的。你可以找到最好的算法。