JAVA 二维数组（含二维数组典型题）

二维数组

就是一个由行和列组成的一个表格而已，矩阵Matrix。

 

我们在这个矩阵中访问元素的话，是根据元素的行角标和列角标所确定的。

1、那么对于二维数组是如何存储的呢？

无论是二维数组，还是多维数组，它们本身就是一个一维数组；尤其对于二维数组而言，无非就是一个一维数组，只不过该一维数组中的每一个元素是另一个一维数组罢了！

int[][] matrix=new int[m][n];

内存中一共有m+1个一维数组 

class Test01{
    public static void main(String[] args){
        int[][] matrix={
            {1,2,3,4},
            {5,6,7,8},
            {8,7,6,5},
            {4,3,2,1}
        };
        //matrix.length 表示的就是最外层那个一维数组的长度 行数
        //matrix[i] 表示的是最外层那个一维数组当中角标i的那个元素 只不过这个元素也是一个一维数组
        //matrix[i].length 表示的是这个一维数组元素的长度(当前行的长度)
        //matrix[i][j] 表示的就是这个一维数组元素中角标j的那个元素
        for(int i=0;i<matrix.length;i++){
            for(int j=0;j<matrix[i].length;j++){
                System.out.print(matrix[i][j]+" ");
            }
            System.out.println();
        } 
    }
}

 

既然以上二维数组的遍历（打印）已经出现，那么现在我们再来讲一讲如何创建二维数组：

1.int[][]  matrix=new int[3][4];//创建一个3行4列的二维数组，元素默认都是0

创建个指定元素的二维数组（3种方式都可以）

2.int[][] matrix=new int[][]{

    {1,2,3,4} ,

    {5,6,7,8} ,

    {9,10,11,12}

};

___________________

3.int[][] matrix={

    {1,2,3,4} ,

    {5,6,7,8} ,

    {9,10,11,12}

};

____________________

锯齿矩阵/二维数组

int[][] matrix={

    {1,2,3,4} ,

    {5,6,7} ,

    {8,9},

    {10}

};

注意：特别的，如果一个二维数组的行和列相等的话，也称之为是方阵。矩阵一定是二维数组，二维数组不一定是矩阵。

二维数组典例

import java.util.*;
class Demo05_09{
    public static void main(String[] args){
        /*
            (0,0) (0,1) (0,2) (0,3)
            (1,0) (1,1) (1,2) (1,3)
            (2,0) (2,1) (2,2) (2,3)
            累加行的时候 行不动 列动
            累加列的时候 列不动 行动
        */
        //1.输入一个3*4的矩阵
        Scanner scanner=new Scanner(System.in);
        System.out.println("Enter numbers:");
        double[][] matrix=new double[3][4];
        for(int i=0;i<matrix.length;i++){
            for(int j=0;j<matrix[i].length;j++){
                matrix[i][j]=scanner.nextDouble();
            }
        }
        //2.打印每列的和
        for(int col=0;col<matrix[0].length;col++){
            System.out.println(sumColumn(matrix,col));
        }
    }
    public static double sumColumn(double[][] m,int col){
        double sum=0;
        for(int row=0;row<m.length;row++){
            sum+=m[row][col];
        }
        return sum;
    }
}

 

class Demo05_10{
    public static void main(String[] args){
        /*
            (0,0) (0,1) (0,2) 
            (1,0) (1,1) (1,2) 
            (2,0) (2,1) (2,2)
            主对角线上的元素 行列角标是相等的
        */
        int[][] m={
            {1, 2, 3, 4},
            {5, 6, 7, 8},
            {9, 10,11,12},
            {13,14,15,16}
        };
        //主对角线
        int sum=0;
        for(int i=0;i<m.length;i++){
            sum+=m[i][i];
        }
        System.out.println(sum);
        //副对角线
        int subsum=0;
        for(int i=0;i<m.length;i++){
            subsum+=m[i][m.length-1-i];
        }
        System.out.println(subsum);
        /*
        for(int i=0;i<m.length;i++){
            for(int j=0;j<m[i].length;j++){
                if(i==j){
                    sum+=m[i][j];
                }
            }
        }
        */
    }
}

 

class Demo05_11{
    public static void main(String[] args){
        //m*n n*p m*p 矩阵相乘 前者的列 必须等于 后者的行
        /*
        1 2 3        1 2    1*1+2*3+3*5   1*2+2*4+3*6
                ×    3 4  = 
        4 5 6        5 6    4*1+5*3+6*5   4*2+5*4+6*6
        对于数学上的一些运算公式 如果直接通过看计算流程还是比较麻烦的
        此时推荐使用已知公式计算！
        */
        double[][] A={ //m*p
            {1,2,3},
            {4,5,6},
            {7,8,9}
        };
        double[][] B={ //p*n
            {0,2.0,4.0},
            {1,4.5,2.2},
            {1.1,4.3,5.2}
        };
        double[][] C=new double[A.length][B[0].length];//m*n
        for(int i=0;i<C.length;i++){
            for(int j=0;j<C[i].length;j++){
                double sum=0;
                for(int k=0;k<B.length;k++){
                    sum+=A[i][k]*B[k][j];
                }
                C[i][j]=sum;
                System.out.print(C[i][j]+"　");
            }
            System.out.println();
        }
    }
}

 

import java.util.*;
class Demo05_12{
    public static void main(String[] args){
        //1.输入方针的尺寸 创建方阵
        Scanner scanner=new Scanner(System.in);
        System.out.print("Enter size:");
        int size=scanner.nextInt();
        int[][] m=new int[size][size];
        //2.随机的给方阵中填入0或1
        Random random=new Random();
        for(int i=0;i<size;i++){
            for(int j=0;j<size;j++){
                m[i][j]=random.nextInt(2);
                System.out.print(m[i][j]+" ");
            }
            System.out.println();
        }
        //3.让行，列，对角线累加 sum==0 sum==size 表示全相等
        checkRow(m);
        checkCol(m);
        checkDiagonal(m);
        checkSubDiagonal(m);
    }
    public static void checkSubDiagonal(int[][] m){
        int sum=0;
        for(int i=0;i<m.length;i++){
            sum+=m[i][m.length-1-i];
        }
        if(sum==m.length||sum==0){
            System.out.printf("副主对角线全相等且是%d\n",sum==0?0:1);
        }
    }
    public static void checkDiagonal(int[][] m){
        int sum=0;
        for(int i=0;i<m.length;i++){
            sum+=m[i][i];
        }
        if(sum==m.length||sum==0){
            System.out.printf("主对角线全相等且是%d\n",sum==0?0:1);
        }
    }
    public static void checkRow(int[][] m){
        for(int i=0;i<m.length;i++){
            int sum=0;
            for(int j=0;j<m[i].length;j++){
                sum+=m[i][j];
            }
            if(sum==m.length||sum==0){
                System.out.printf("第%d行全相等且是%d\n",i+1,sum==0?0:1);
            }
        }
    }
    public static void checkCol(int[][] m){
        for(int j=0;j<m.length;j++){
            int sum=0;
            for(int i=0;i<m.length;i++){
                sum+=m[i][j];
            }
            if(sum==m.length||sum==0){
                System.out.printf("第%d列全相等且是%d\n",j+1,sum==0?0:1);
            }
        }
    }
}

连续相等

 

对于这中连续相等的问题（本来有8个方向，但有一半会重复，所以用四个方向来考虑）：首先先画图分析、找出每个方向上满足（角标不越界）的最大角标。例如这道题：

import java.util.*;
class Demo05_13{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        System.out.print("Enter row ,col:");
        int row=scanner.nextInt();
        int col=scanner.nextInt();
        int[][] m=new int[row][col];
        for(int i=0;i<row;i++){
            for(int j=0;j<col;j++){
                m[i][j]=scanner.nextInt();
            }
        }
        System.out.println(isConsecutiveFour(m));
    }
    public static boolean isConsecutiveFour(int[][] m){
        for(int i=0;i<m.length;i++){
            for(int j=0;j<m[i].length;j++){
                //向右
                if(j<=m[i].length-4){
                    boolean flag=true;
                    for(int c=j+1;c<=j+3;c++){
                        if(m[i][j]!=m[i][c]){
                            flag=false;
                            break;
                        }
                    }
                    if(flag){
                        return true;
                    }
                }
                //向下
                if(i<=m.length-4){
                    boolean flag=true;
                    for(int r=i+1;r<=i+3;r++){
                        if(m[i][j]!=m[r][j]){
                            flag=false;
                            break;
                        }
                    }
                    if(flag){
                        return true;
                    }
                }
                //向右下
                if(i<=m.length-4&&j<=m[0].length-4){
                    boolean flag=true;
                    for(int r=i+1,c=j+1;r<=i+3;r++,c++){
                        if(m[i][j]!=m[r][c]){
                            flag=false;
                            break;
                        }
                    }
                    if(flag){
                        return true;
                    }
                }
                //向右上
                if(i>=3&&j<=m[0].length-4){
                    boolean flag=true;
                    for(int r=i-1,c=j+1;c<=j+3;r--,c++){
                        if(m[i][j]!=m[r][c]){
                            flag=false;
                            break;
                        }
                    }
                    if(flag){
                        return true;
                    }
                }
            }
        }
        return false;//四个方向都没有连续的
    }
}