酸奶的Java学习日记 | 二维数组篇

​

前情提要

众所周知，数组，尤其是二维数组的索引是个令人着迷的小家伙，它经常把人迷的晕头转向，为了不再当史上无敌大迷糊，今天势必把索引与数组长度搞清楚。

索引 从0开始 （一定一定要记住是从0开始）

数组长度 正常数数，从一开始计数（应该没有哪个迷糊虫说自己吃了0个苹果吧Σ( ° △ °|||)︴ ）

检测数组长度可以用Java中的length方法

int arr[]=new int [5];

这里的5就指的是数组长度。

例题

下面来几道我这个小白写了2个半小时写出来的题（实在是一言难尽……bug的生产者在此）

利用随机函数产生16个随机数，给一个4*4的二维数组赋值
按行列输出数组
求最外一圈元素之和
求主对角线中最大元素的值及其位置

利用随机函数产生16个随机数，给一个4*4的二维数组赋值

//        1.利用随机函数产生16个随机数，给一个4*4的二维数组赋值
        int array[][]=new int[4][4];
//        已知array.length=4

        Random r=new Random();
        for (int i=0;i<array.length;i++){
            for (int j=0;j<array[i].length;j++){
                int num = r.nextInt(100);
                array[i][j]=num;
            }
        }

1.这里已知数组长度，所以行和列可以都写上去

2.利用随机数随机产生数的特性，将数值范围设定到0~100，也就是
int num =r.nextInt(100);

3.利用循环，给每一个数组元素赋值

4.把二维数组看成是一个特殊的一维数组，array[i].length的含义也就显而易见了，它表示的是array数组第i行共有几列，也就是第i行共有多少个元素（是数组长度哦）

按行列输出数组

//        2.按行列输出数组
        for (int i=0;i<array.length;i++){
            for (int j=0;j<array[i].length;j++){
                System.out.print(array[i][j]+"\t");
            }
            System.out.println();
        }

这一步只需要双层for循环逐行输出即可，内层for循环结束代表一行输出完毕，需要在外层for循环执行换行操作。

\t 就相当于键盘上的Tab制表键，简洁美观 (u‿ฺu✿ฺ)

求最外一圈元素之和

初步设想
这个就上升难度了，首先来分析一下，一个一个元素加肯定是可以的，毕竟元素少嘛，就16个，抛去中间4个，简简单单呐~

但是，写代码不仅仅是为了解决眼下的问题，更是要体现出代码的特点——复用性。

所以挨个相加不是很好的样子……不行，咱换一个嘛。

我一开始是动了让所有元素相加到最后减去不需要元素的心思，毕竟减4个比加一整个外圈简单，考虑到复用性，我放弃了……

不就是外圈相加嘛，who怕who！！！
再步设想
外圈相加，也就是找到所有外圈元素所在位置的规律，这样问题就轻而易举解决了！

我为了找规律，还专门为此创作了一张惊天地泣鬼神的神作，如图所示……

呐，就是它，根据这张图，可以发现它的行和列都是有规律的在变化，我只需要写四个for循环把两行两列的所有数据加上就大功告成了！

所以我写出了漏洞百出的代码 (⊙﹏⊙)

以下代码块中行注释是解释说明步骤，块注释全是错代码，经过我仔细研究，仔细拿计算器相加（无意间暴露了什么），终于……发现问题出在哪了！

//        3.求最外一圈元素之和
//        3.1 求第一行的和 i不变 j变
        int sum=0;
//        array.length--4
//        array[0].length-1--3
       for (int j=0;j<array[0].length-1;j++){
            sum+=array[0][j];
        }

        /*int sum=0;
        for (int i=0;i<array.length;i++){
            for (int j=0;j<array[i].length;j++){
                sum+=array[0][j];
            }
        }*/

//        3.2 求第一列的和 j不变 i变
        for (int i=1;i<array.length;i++){
            sum+=array[i][0];
        }
        /*for (int i=0;i<array.length;i++){
            for (int j=0;j<array[i].length;j++){
                sum+=array[i][0];
            }
        }*/
//        3.3 求第四行的和 i不变 j变
//        array.length-1--3
//        array[array.length-1].length---4
        for (int j=1;j<array[array.length-1].length;j++){
            sum+=array[array.length-1][j];
        }
        /*for (int i=0;i<array.length;i++){
            for (int j=0;j<array[i].length;j++){
                sum+=array[array.length-1][j];
            }
        }*/
//        3.4 求第四列的和 j不变 i变
//        array.length--4
//        array.length-1--3
       for (int i=0;i<array.length-1;i++){
            sum+=array[i][array.length-1];
        }
       /* for (int i=0;i<array.length;i++){
            for (int j=0;j<array[i].length;j++){
                sum4+=array[i][array.length-1];
            }
        }*/

        System.out.println("该随机数组最外圈元素和为:"+sum);

看了一遍又一遍之后，我发现在四个角落里的数被重复计算了四次！！！

其实在这之前，没有考虑到只有行或列的变化，还出现过把16个数全部相加并且乘以4的情况……bug生产家是我没错了( * /ω＼*)

多亏了debug调试功能，让我及时更正，没有酿下大错。

所以，现在只需要将每一行或列少计算一个元素，形成闭环，就可以取得最外圈元素的和了！

如图所示……

咳咳，那第三部分就完成了，接下来看最后一个

求主对角线中最大元素的值及其位置

我查了那么一查，发现好像没有二维数组返回索引值的方法，于是……那自己定义一个吧！！！

说干就干，定义方法，两个明确，一是返回值类型，二是参数。

返回值类型肯定是void啦，参数，一个是之间求出来的最大值，另一个就是生成好的二维数组，知道了这些，火速写了一个方法。

这第四部分的代码就都在此了

//        4.求主对角线中最大元素的值及其位置
        int max=array[0][0];
        for (int i=1;i<array.length;i++){
            int yuansu = array[i][i];
            if (yuansu>max){
                max=yuansu;
            }
        }
        System.out.println("主对角线最大元素为"+max);
        getAddress(array,max);

   /*定义一个方法，实现获取查找元素获得位置的需求
    * 两个明确
    * 返回值类型 void
    * 参数 int array[][] int max*/
    public static void getAddress(int array[][],int max){
        for (int i=0;i<array.length;i++){
            for (int j=0;j<array[i].length;j++){
                if (max==array[i][j]){
                    System.out.println("该最大元素的在数组内的位置为:["+i+"] ["+j+"]");
                    System.out.println("该最大元素的在矩阵内的位置为:["+(i+1)+"] ["+(j+1)+"]");
                }
            }
        }
    }

​

代码汇总

package classCode.arrays;

import java.util.Arrays;
import java.util.Random;

/*
* 1.利用随机函数产生16个随机数，给一个4*4的二维数组赋值
2.按行列输出数组
3.求最外一圈元素之和
4.求主对角线中最大元素的值及其位置
* */
public class Shuzu {
    public static void main(String[] args) {
//        1.利用随机函数产生16个随机数，给一个4*4的二维数组赋值
        int array[][]=new int[4][4];
//        已知array.length=4

        Random r=new Random();
        for (int i=0;i<array.length;i++){
            for (int j=0;j<array[i].length;j++){
                int num = r.nextInt(100);
                array[i][j]=num;
            }
        }
//        2.按行列输出数组
        for (int i=0;i<array.length;i++){
            for (int j=0;j<array[i].length;j++){
                System.out.print(array[i][j]+"\t");
            }
            System.out.println();
        }

//        3.求最外一圈元素之和
//        3.1 求第一行的和 i不变 j变
        int sum=0;
//        array.length--4
//        array[0].length-1--3
       for (int j=0;j<array[0].length-1;j++){
            sum+=array[0][j];
        }

        /*int sum=0;
        for (int i=0;i<array.length;i++){
            for (int j=0;j<array[i].length;j++){
                sum+=array[0][j];
            }
        }*/

//        3.2 求第一列的和 j不变 i变
        for (int i=1;i<array.length;i++){
            sum+=array[i][0];
        }
        /*for (int i=0;i<array.length;i++){
            for (int j=0;j<array[i].length;j++){
                sum+=array[i][0];
            }
        }*/
//        3.3 求第四行的和 i不变 j变
//        array.length-1--3
//        array[array.length-1].length---4
        for (int j=1;j<array[array.length-1].length;j++){
            sum+=array[array.length-1][j];
        }
        /*for (int i=0;i<array.length;i++){
            for (int j=0;j<array[i].length;j++){
                sum+=array[array.length-1][j];
            }
        }*/
//        3.4 求第四列的和 j不变 i变
//        array.length--4
//        array.length-1--3
       for (int i=0;i<array.length-1;i++){
            sum+=array[i][array.length-1];
        }
       /* for (int i=0;i<array.length;i++){
            for (int j=0;j<array[i].length;j++){
                sum4+=array[i][array.length-1];
            }
        }*/

        System.out.println("该随机数组最外圈元素和为:"+sum);


//        4.求主对角线中最大元素的值及其位置
        int max=array[0][0];
        for (int i=1;i<array.length;i++){
            int yuansu = array[i][i];
            if (yuansu>max){
                max=yuansu;
            }
        }
        System.out.println("主对角线最大元素为"+max);
        getAddress(array,max);


    }
    /*定义一个方法，实现获取查找元素获得位置的需求
    * 两个明确
    * 返回值类型 void
    * 参数 int array[][] int max*/
    public static void getAddress(int array[][],int max){
        for (int i=0;i<array.length;i++){
            for (int j=0;j<array[i].length;j++){
                if (max==array[i][j]){
                    System.out.println("该最大元素的在数组内的位置为:["+i+"] ["+j+"]");
                    System.out.println("该最大元素的在矩阵内的位置为:["+(i+1)+"] ["+(j+1)+"]");
                }
            }
        }
    }

}

以上就是俺分享的全部内容了，两个半小时，是坐在座位上的时间，但是有可能是专注度不够，所以还需要加油提高效率啦！

在写代码的过程中，出现了无数的bug，皆是因为考虑不周导致，为了减少出错率，需要提前想好应该怎么把代码写出来，独立思考以及画示意图都非常的重要！好多都是因为索引和数组长度引起的索引越界……（下回不操心可真的要废了）

感谢父老乡亲们可以看到这儿，比心~