Android，Gradle，产品风味和清单(Android, Gradle, product flavors and the manifest)

 正如其他人所说，问题是存储到数组中的内存位置： x[i][j] 。 这里有一些洞察力为什么： 
 
 你有一个二维阵列，但计算机内存本身就是一维的。 所以当你想像这样你的阵列： 
 
0,0 | 0,1 | 0,2 | 0,3
----+-----+-----+----
1,0 | 1,1 | 1,2 | 1,3
----+-----+-----+----
2,0 | 2,1 | 2,2 | 2,3
 
 您的计算机将其作为单行存储在内存中： 
 
0,0 | 0,1 | 0,2 | 0,3 | 1,0 | 1,1 | 1,2 | 1,3 | 2,0 | 2,1 | 2,2 | 2,3
 
 在第二个例子中，您可以首先循环访问第二个数组，即： 
 
x[0][0] 
        x[0][1]
                x[0][2]
                        x[0][3]
                                x[1][0] etc...
 
 意思是你按顺序击中他们。 现在看第一版。 你在做： 
 
x[0][0]
                                x[1][0]
                                                                x[2][0]
        x[0][1]
                                        x[1][1] etc...
 
 由于C在内存中布置了2-d阵列，所以你要求它跳过这个地方。 但现在为踢球者：为什么这么重要？ 所有内存访问是一样的，对吗？ 
 
 否：因为缓存。 来自您的内存的数据将以小块（称为“高速缓存线”）传递给CPU，通常为64字节。 如果你有4个字节的整数，那就意味着你在一个整齐的小包中连续16个整数。 获取这些内存块实际上相当慢; 您的CPU可以在单个缓存行加载所需的时间内进行大量工作。 
 
 现在回顾一下访问顺序：第二个例子是（1）抓取16个int的块，（2）修改它们，（3）重复4000 * 4000/16次。 这很好，快，CPU总是有一些工作。 
 
 第一个例子是（1）抓住16个int的块，（2）只修改其中一个，（3）重复4000 * 4000次。 这将要求内存中“提取”数量的16倍。 您的CPU实际上必须花时间坐在等待这个记忆显示，而当它坐在你周围浪费宝贵的时间。 
 
 重要的提示： 
 
 现在你有答案，这里有一个有趣的注释：没有固有的原因，你的第二个例子必须是快速的。 例如，在Fortran中，第一个例子是快速的，第二个例子是缓慢的。 这是因为，不要将事情扩展到像C这样的概念“行”，Fortran扩展成“列”，即： 
 
0,0 | 1,0 | 2,0 | 0,1 | 1,1 | 2,1 | 0,2 | 1,2 | 2,2 | 0,3 | 1,3 | 2,3
 
 C的布局叫做“row-major”，Fortran被称为“column-major”。 您可以看到，知道您的编程语言是排行还是列主要都非常重要！ 以下是更多信息的链接： http : //en.wikipedia.org/wiki/Row-major_order 

As others have said, the issue is the store to the memory location in the array: x[i][j]. Here's a bit of insight why:
 
You have a 2-dimensional array, but memory in the computer is inherently 1-dimensional. So while you imagine your array like this:
 
0,0 | 0,1 | 0,2 | 0,3
----+-----+-----+----
1,0 | 1,1 | 1,2 | 1,3
----+-----+-----+----
2,0 | 2,1 | 2,2 | 2,3
 
Your computer stores it in memory as a single line:
 
0,0 | 0,1 | 0,2 | 0,3 | 1,0 | 1,1 | 1,2 | 1,3 | 2,0 | 2,1 | 2,2 | 2,3
 
In the 2nd example, you access the array by looping over the 2nd number first, i.e.:
 
x[0][0] 
        x[0][1]
                x[0][2]
                        x[0][3]
                                x[1][0] etc...
 
Meaning that you're hitting them all in order. Now look at the 1st version. You're doing:
 
x[0][0]
                                x[1][0]
                                                                x[2][0]
        x[0][1]
                                        x[1][1] etc...
 
Because of the way C laid out the 2-d array in memory, you're asking it to jump all over the place. But now for the kicker: Why does this matter? All memory accesses are the same, right?
 
No: because of caches. Data from your memory gets brought over to the CPU in little chunks (called 'cache lines'), typically 64 bytes. If you have 4-byte integers, that means you're geting 16 consecutive integers in a neat little bundle. It's actually fairly slow to fetch these chunks of memory; your CPU can do a lot of work in the time it takes for a single cache line to load.
 
Now look back at the order of accesses: The second example is (1) grabbing a chunk of 16 ints, (2) modifying all of them, (3) repeat 4000*4000/16 times. That's nice and fast, and the CPU always has something to work on.
 
The first example is (1) grab a chunk of 16 ints, (2) modify only one of them, (3) repeat 4000*4000 times. That's going to require 16 times the number of "fetches" from memory. Your CPU will actually have to spend time sitting around waiting for that memory to show up, and while it's sitting around you're wasting valuable time.
 
Important Note:
 
Now that you have the answer, here's an interesting note: there's no inherent reason that your second example has to be the fast one. For instance, in Fortran, the first example would be fast and the second one slow. That's because instead of expanding things out into conceptual "rows" like C does, Fortran expands into "columns", i.e.:
 
0,0 | 1,0 | 2,0 | 0,1 | 1,1 | 2,1 | 0,2 | 1,2 | 2,2 | 0,3 | 1,3 | 2,3
 
The layout of C is called 'row-major' and Fortran's is called 'column-major'. As you can see, it's very important to know whether your programming language is row-major or column-major! Here's a link for more info: http://en.wikipedia.org/wiki/Row-major_order