图片 4

Java 多维数组遍历详解

数组是Java中的一种容器对象,它拥有多个单一类型的值。当数组被创建的时候数组长度就已经确定了。在创建之后,其长度是固定的。下面是一个长度为10的数组:

本文由 ImportNew –
LynnShaw 翻译自
dzone。欢迎加入翻译小组。转载请见文末要求。

定义

二维数组定义的一般形式是:

类型说明符 数组名[常量1][常量2]
  • 常量1:第一维下标的长度

  • 常量2:第二维下标的长度

    int a[3][4];
    

这个二维数组表示一个三行四列的整形变量集合,数组名为a,下标变量的类型为整型。该数组的下标变量共有3×4个,即:

a[0][0],  a[0][1],  a[0][2],  a[0][3]
a[1][0],  a[1][1],  a[1][2],  a[1][3]
a[2][0],  a[2][1],  a[2][2],  a[2][3]

仔细看这个二维数组,我们可以把它理解为一个二维坐标系的位置。这个二维坐标系的原点在左上角,x轴向右递增,y轴向下递增。(在计算机UI设计中,这种二维坐标系经常被使用)

如图所示:

二维数组看做一个坐标系

public class ArrayDemo {
    private int arraySize=10;
    public int[] arrayOfIntegers = new int[arraySize];
}

多维数组

数组是Java中的一种容器对象,它拥有多个单一类型的值。当数组被创建的时候数组长度就已经确定了。在创建之后,其长度是固定的。下面是一个长度为10的数组:

public class ArrayDemo {
    private int arraySize=10;
    public int[] arrayOfIntegers = new int[arraySize];
}

上面的代码是一维数组的例子。换句话说,数组长度只能在一个方向上增长。很多时候我们需要数组在多个维度上增长。这种数组我们称之为多维数组。为简单起见,我们将它称为2维数组。当我们需要一个矩阵或者X-Y坐标系的时候,二维数组是非常有用的。下面就是一个二维数组的例子:

public class TheProblemOf2DArray {
    private static final int ARR_SIZE=10;
    public static void main(String[] args) {
        int arr[][]=new int[ARR_SIZE][ARR_SIZE];
    }
}

想象一下,一个二维数组看起来就像一个X-Y坐标系的矩阵。

图片 1

然而,可能让Java开发者们感到惊讶的是,Java实际上并没有二维数组。

在一个真正的数组中,所有的元素在内存中都存放在连续的内存块中,但是在Java的二维数组并不是这样。Java中所有一维数组中的元素占据了相邻的内存位置,因此是一个真正的数组。

在Java中,当我们定义:

int singleElement // 表示一个int变量
int[] singleDArray // 表示一个int变量数组(一维)
int[][] twoDArray // 表示一个int变量数组的数组(二维)

这意味着,在上面的例子中,二维数组是一个数组的引用,其每一个元素都是另一个int数组的引用。

这张图片清楚地解释了这个概念。

由于二维数组分散在存储器中,所以对性能有一些影响。为了分析这种差异,我写了一个简单的Java程序,显示遍历顺序的重要性。

package arrayTraverse;
/**
 * 二维数组的问题
 * 
 * 我们在初始化一个任意大小的2维数组。(为简化分析我们使用二维方阵)我们将用两种不同方式迭代同一个数组,分析结果
 * 两种迭代方式的性能差距很大
 * @author mohit
 *
 */
public class TheProblemOf2DArray {
    //数组大小:数组越大,性能差距越明显
    private static final int ARR_SIZE=9999;
    public static void main(String[] args) {
        //新数组
        int arr[][]=new int[ARR_SIZE][ARR_SIZE];
        long currTime=System.currentTimeMillis();
        colMajor(arr); 
        System.out.println("Total time in colMajor : "+(System.currentTimeMillis()-currTime)+" ms");
        //新数组,与arr完全相同
        int arr1[][]=new int[ARR_SIZE][ARR_SIZE];
        currTime=System.currentTimeMillis();
        rowMajor(arr1); // this is the only difference in above
        System.out.println("Total time in col : "+(System.currentTimeMillis()-currTime) +" ms");
    }

    /**
     * 下面的代码按列为主遍历数组
     * 即在扫描下一行之前先扫描完本行
     * 
     */
    private static void colMajor(int arr[][]) {
        for(int i=0;i<ARR_SIZE;i++){
            for (int j=0;j<ARR_SIZE;j++){
                //See this, we are traversing j first and then i
                arr[i][j]=i+j;
            }
        }
    }

    /**
     * 如果我们转换内外循环
     * 程序就以行为主顺序遍历数组
     * 即在扫描下一列之前先扫描完本列
     * 这意味着我们访问数组时每次都在访问不同的行(因此也在访问不同的页)
     * 代码微小的改变将导致这个程序花费更多的时间完成遍历
     */
    private static void rowMajor(int arr[][]) {
        for(int i=0;i<ARR_SIZE;i++){
            for (int j=0;j<ARR_SIZE;j++){
            /*看这个,我们先遍历j,然后遍历i,但是对于访问元素来说
             * 它们在更远的位置,所以需要花费的更多
             */
            arr[j][i]=i+j;
            }
        }
    }
}

下面是示例的结果:

图片 2

重复上面的例子,它会始终给出类似的结果,不过时间差可能会有所不同。

原文链接: dzone
翻译: ImportNew.com –
LynnShaw
译文链接:
[ 转载请保留原文出处、译者和译文链接。]

存储形式

在内存中,二维数组被保存成一段连续的内存空间。就如同一个一维数组,二维数组也是按一维线性排列的。

具体的存储方式有两种:

  • 按行排列

放完一行之后顺次放入第二行。

  • 按列排列

放完一列之后再顺次放入第二列。

我们再回头看一下这个二维数组:

 int a[3][4];

其实,在内存中它的存储方式相当于:

 int  b[12];

只不过,计算机把它分成了三个部分。

a[0][0] 对应于 b[0]
a[1][0] 对应于 b[4]
a[3][0] 对应于 b[8]

上面的代码是一维数组的例子。换句话说,数组长度只能在一个方向上增长。很多时候我们需要数组在多个维度上增长。这种数组我们称之为多维数组。为简单起见,我们将它称为2维数组。当我们需要一个矩阵或者X-Y坐标系的时候,二维数组是非常有用的。下面就是一个二维数组的例子:

关于作者: LynnShaw

微博:@萧萧萧宁

查看LynnShaw的更多文章
>>

二维数组元素的引用

二维数组的元素也称为双下标变量,其表示的形式为:

数组名[下标][下标]

其中下标应为整型常量或整型表达式。例如:

a[0][2]

表示数组a第一行第三列的元素。

在讲一维数组时,很多人反馈说无法区分数组定义和引用时方括号中的内容,今天我们来说一下这两处用法的区别:

  • 数组声明的方括号中的是某一维的长度,即数组下标最大值 + 1
  • 数组引用中的下标是该元素在数组中的位置标识
  • 前者只能是常量,而后者可以是常量,变量或表达式。

下面我们通过一个具体的例子来讲解。

一个学习小组有5个人(A, B, C, D,
E),三次考试每个人的成绩如下。请编程实现计算这个小组所有人三次考试的平均成绩。

考试成绩

我们用一个二维数组a[5][3]存放五个人三次考试的成绩。再用一个一维数组v[3]存放所求得每次考试的平均成绩,最后求出v中三个成绩的平均值。代码如下:

int main(void)
{
    int i, j, s = 0;
    int average;
    int v[3];
    int a[5][3];

    printf("input score:n");

    for(i = 0; i < 3; i++)
    {
        for(j = 0; j < 5; j++)
        {
            scanf("%d", &a[j][i]);
            s += a[j][i];
        }
        v[i] = s / 5;
        s = 0;
    }

    average = (v[0] + v[1] + v[2]) / 3;

    printf("First:%dnSecond:%dnThird:%dn", v[0], v[1], v[2]);
    printf("Final Average:%dn", average );

    return 0;
}

执行结果如下:

执行结果

大家应该都注意到了,我们通过scanf函数从键盘一个个录入每个成绩保存在二维数组中,这种方法太繁琐。每次调试都需要输入这15个数字,肯定没人愿意。接下来我们看看有没有其他的方法。

public class TheProblemOf2DArray {
    private static final int ARR_SIZE=10;
    public static void main(String[] args) {
        int arr[][]=new int[ARR_SIZE][ARR_SIZE];
    }
}

二维数组初始化

二维数组初始化也是在类型说明时给各下标变量赋以初值。主要有两种方式:

  • 按行分段赋值
  • 按行连续赋值

这两种方式如下:

int a[5][3] = {{80, 75, 92}, {61, 65, 71}, {59, 63, 70}, {85, 87, 90}, {76, 77, 85}};
int a[5][3] = {80, 75, 92, 61, 65, 71, 59, 63, 70, 85, 87, 90, 76, 77, 85};

这两种赋初值的结果是完全相同的。

于是,上面的代码可以改写成这样。

int main(void)
{
int i, j, s = 0;
int average;
int v[3];

int a[5][3]={{80, 75, 92}, {61, 65, 71}, {59, 63, 70}, {85, 87, 90}, {76, 77, 85}};

for(i = 0; i < 3; i++){
    for(j = 0; j < 5; j++){
        s += a[j][i];
    }
    v[i] = s / 5;
    s = 0;
}

average = (v[0] + v[1] + v[2]) / 3;

printf("First:%dnSecond:%dnThird:%dn",v[0],v[1],v[2]);
printf("Final Average:%dn", average );

return 0;
}

执行结果完全相同,只不过不需要输入。

在对二维数组赋初值时,我们还要注意几点:

  • 可以只对部分元素赋初值,未赋初值的元素自动取0值。

    int a[3][3] = {{1}, {2}, {3}};
    int a[3][3] = {{0, 1}, {0, 0, 2}, {3}};

这句话可以得到下面这两个数组:

1  0  0
2  0  0
3  0  0 

0  1  0
0  0  2
3  0  0
  • 如对全部元素赋初值,第一维的长度可以不给出。

例如:

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

可以写为:

int a[][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
  • 数组是一种构造类型的数据

二维数组可以看作是由一维数组的嵌套而构成的。因此,一个二维数组也可以分解为多个一维数组。

如二维数组a[3][4],可分解为三个一维数组,其数组名分别为:

a[0]
a[1]
a[2]

这三个一维数组都有4个元素,例如:一维数组a[0]的元素为a[0][0],a[0][1],a[0][2],a[0][3]。

为什么是这么奇怪的数组名呢,其实是这样,a[0]中保存的是a[0][0]的地址,那么其实就是a[0][0]~a[0][3]这4个元素组成的一维数组的第一块空间的地址,那么它就是这个一维数组的数组名。

注意,a[0],a[1],a[2]不能当作下标变量使用,它们是数组名,不是一个单纯的下标变量。

我是天花板,让我们一起在软件开发中自我迭代。
如有任何问题,欢迎与我联系。


上一篇:C语言从零开始(十四)-字符串处理
下一篇:C语言从零开始(十六)-指针1

想象一下,一个二维数组看起来就像一个X-Y坐标系的矩阵。

图片 3

然而,可能让Java开发者们感到惊讶的是,Java实际上并没有二维数组。

在一个真正的数组中,所有的元素在内存中都存放在连续的内存块中,但是在Java的二维数组并不是这样。Java中所有一维数组中的元素占据了相邻的内存位置,因此是一个真正的数组。

在Java中,当我们定义:

int singleElement // 表示一个int变量
int[] singleDArray // 表示一个int变量数组(一维)
int[][] twoDArray // 表示一个int变量数组的数组(二维)

这意味着,在上面的例子中,二维数组是一个数组的引用,其每一个元素都是另一个int数组的引用。

这张图片清楚地解释了这个概念。

由于二维数组分散在存储器中,所以对性能有一些影响。为了分析这种差异,我写了一个简单的Java程序,显示遍历顺序的重要性。

package arrayTraverse;
/**
 * 二维数组的问题
 * 
 * 我们在初始化一个任意大小的2维数组。(为简化分析我们使用二维方阵)我们将用两种不同方式迭代同一个数组,分析结果
 * 两种迭代方式的性能差距很大
 * @author mohit
 *
 */
public class TheProblemOf2DArray {
    //数组大小:数组越大,性能差距越明显
    private static final int ARR_SIZE=9999;
    public static void main(String[] args) {
        //新数组
        int arr[][]=new int[ARR_SIZE][ARR_SIZE];
        long currTime=System.currentTimeMillis();
        colMajor(arr); 
        System.out.println("Total time in colMajor : "+(System.currentTimeMillis()-currTime)+" ms");
        //新数组,与arr完全相同
        int arr1[][]=new int[ARR_SIZE][ARR_SIZE];
        currTime=System.currentTimeMillis();
        rowMajor(arr1); // this is the only difference in above
        System.out.println("Total time in col : "+(System.currentTimeMillis()-currTime) +" ms");
    }

    /**
     * 下面的代码按列优先遍历数组
     * 即在扫描下一列之前先扫描完本列
     * 
     */
    private static void colMajor(int arr[][]) {
        for(int i=0;i<ARR_SIZE;i++){
            for (int j=0;j<ARR_SIZE;j++){
                //See this, we are traversing j first and then i
                arr[i][j]=i+j;
            }
        }
    }

    /**
     * 如果我们转换内外循环
     * 程序就以行优先顺序遍历数组
     * 即在扫描下一行之前先扫描完本行
     * 这意味着我们访问数组时每次都在访问不同的列(因此也在访问不同的页)
     * 代码微小的改变将导致这个程序花费更多的时间完成遍历
     */
    private static void rowMajor(int arr[][]) {
        for(int i=0;i<ARR_SIZE;i++){
            for (int j=0;j<ARR_SIZE;j++){
            /*看这个,我们先遍历j,然后遍历i,但是对于访问元素来说
             * 它们在更远的位置,所以需要花费的更多
             */
            arr[j][i]=i+j;
            }
        }
    }
}

下面是示例的结果:

图片 4

重复上面的例子,它会始终给出类似的结果,不过时间差可能会有所不同。

发表评论

电子邮件地址不会被公开。 必填项已用*标注