二维数组

1，编写一个方法，求整数矩阵中特定列的所有元素的和，使用下面的方法头
public static double sumColumn(double [][] m,int columnIndex){
编写一个测试的程序,读取一个3*4的矩阵,然后显示每列元素的和
思路：1，求列的元素和，就是列不变，行改变
2，求行元素的和,就是行不变，列改变

class test59{
    public static void main(String [] args){
        //求一个3*4矩阵的列之和And行之和
        double [][]m={
            {1,2,3,4},
            {5,6,7,8},
            {3,4,5,2}
        };
        //遍历列
        for(int columnIndex=0;columnIndex<m[0].length;columnIndex++){
                  System.out.println(sumColumn(m, columnIndex));
        }

    }
    public static double sumColumn(double [][] m,int columnIndex){
          int sum=0;
          //求出特定列元素的和
        for(int row=0;row<m.length;row++){
           sum+=m[row][columnIndex];
        }
        return sum;
    }
}

2，编写一个方法，求nn的double类型矩阵主对角线上所有元素的和，使用下面的方法头：
public static double sumMajorDiagonal(double [] [] m)
编写一个程序，读取一个44矩阵对角线上所有元素的和

class test510{
    public static void main(String[] args){
        double [][] a={
            {1,2,4,5},
            {3,2,1,5},
            {4,2,7,8},
            {2,4,1,6}
        };
         sumMajorDiagonal(a);
    }
    public static double sumMajorDiagonal(double [][] a){
        double sum1=0;
        double sum2=0;
         //对角线左下方向的
         for(int i=0;i<a.length;i++){
            sum1+=a[i][i];
         }
         System.out.println(sum1);
         //右上方向的
         for(int i=a.length-1;i>=0;i--){
             sum2+=a[i][a.length-1-i];
         } 
         System.out.println(sum2);
         return sum1+sum2;
    }
}

3，代数方面，两个矩阵相乘，编写两个矩阵相乘的方法，方法头如下：
public static double[][] multiplyMatrix(double [][] a,double [][] b)
为使矩阵a和矩阵b能够相乘，矩阵a的列数必须和矩阵b的行数相同

import java.util.*;
class test511{
    public static void main(String[] args){
        double [][]a={
            {1.0,2.0,3,4},
            {3,1,1,5},
            {2,3,1,7}
        };
        double [][]b={
            {1.0,2.0,3,4},
            {3,1,1,5},
            {2,3,1,7}
        };
    }
    public static double [][] multiplyMatrix(double[][]a,double[][]b){
        //创建一个新数组
        double [][] c=new double[a.length][b[0].length];
        //遍历数组c
        for(int i=0;i<c.length;i++){//遍历数组的行数
             for(int j=0;j<c[0].length;j++){
                 double sum=0;
                 for(int k=0;k<b.length;k++ ){
                      sum+=a[i][k] * b[k][j];
                 }
                 c[i][j]=sum;
             }
        }
             return c;
    }
}

4,编写程序,提示用户输入一个方阵的长度，随机的在方阵中填入0或者1，打印这个方阵，然后找出整行，整列或者对角线都是0或1的行，列和对角线
思路：
对角线分为主对角线和副对角线，主对角线的元素是a[i][i],副对角线是a[i]a.length-1-i
行的元素是a[i]][j],j的范围是for(int j=0;j<a[i].length;j++)
列的元素是a[j]][i],j的范围是for(int j=0;j<a.length;j++).i的范围是for(int i=0;i<a.length;i++)

import java.util.*;
class test512{
    public static void main(String[] args){
        Random random=new Random();
      Scanner scanner =new Scanner(System.in);
      System.out.print("请输入方阵的长度 ");
      int size=scanner.nextInt();
      double [][] a=new double[size][size];
      for(int i=0;i<size;i++){
          for(int j=0;j<size;j++){
              a[i][j]=random.nextInt(2);//取值只取到0 1 取不到2
              System.out.print(a[i][j]);
          }
          System.out.println();
      }  
      checkSubDiagonal(a);
    }
    public static void checkSubDiagonal(double [][]a){
         //比较副对角线的元素是否全零还是全1
         int sum1=0;
         int sum2=0;
         int sum3=0;
         int sum4=0;
    for(int i=0;i<a.length;i++){
        sum1+=a[i][a.length-1-i];
    }
    if(sum1==0|| sum1==a.length){
        System.out.printf("副对角线全相等且等于%d\n",sum1==0?0:1);
    }
    //主对角线元素是否全0还是1
    for(int i=0;i<a.length;i++){
        sum2+=a[i][i];
    }
    if(sum2==0|| sum2==a.length){
        System.out.printf("主对角线全相等且等于%d\n",sum2==0?0:1);
    }
    //行元素是否全0还是1
    for(int i=0;i<a.length;i++){
        for(int j=0;j<a[i].length;j++){
          sum3+=a[i][j];
        }
        if(sum3==0|| sum3==a.length){
            System.out.printf("第%d行全相等且等于%d\n",i+1,sum3==0?0:1);
        } 
    }
    //列元素是否全0还是1
    for(int i=0;i<a.length;i++){
        for(int j=0;j<a.length;j++){
            sum4+=a[j][i];
        }
        if(sum4==0|| sum4==a.length){
            System.out.printf("第%d列全相等且等于%d\n",i+1,sum4==0?0:1);
        }
    }
    }

}

5，编写方法，测试一个二维数组是否有四个连续的数字具有相同的数值，这四个数可以是水平方向的，垂直方向的，对角线方向的
public static boolean isConsecutiveFour(int [][] values)
编写一个测试程序，提示用户输入一个二维数组的行数，列数以及数组中的值，如果这个数组具有四个连续相同的数值，就显示为true，否则显示为false,
思路：主要搞懂这几个方向的元素的下标进行比较即可
这是我写的代码

import java.util.*;
class test513{
    public static void main(String[] args){
      Scanner scanner =new Scanner(System.in);
      System.out.print("请输入row col");
      int row=scanner.nextInt();
      int col=scanner.nextInt();
      int [] [] m=new int[row][col];
      for(int i=0;i<m.length;i++){
          for(int j=0;j<m[i].length;j++){
              m[i][j]=scanner.nextInt();
              System.out.print(m[i][j]+" ");
          }
          System.out.println();
      }
    }
    public static boolean isContinousFour(int [][] m){
        //向右
          for(int i=0;i<m.length;i++){
              boolean flag=true;
              for(int j=0;j<m[i].length;j++){
                  if(j<=m[i].length-4){
                    for(int k=j+1;k<=j+3;k++){
                        if(m[i][j]!=m[i][k]){//反向思维判断
                              flag=false;
                              break;
                        }
                    }
                    if(flag){
                        return true;
                    }
                  }
                  //向下
                  if(i<=m.length-4){
                    for(int r=j+1;r<=j+3;r++){
                        if(m[i][j]!=m[i][r]){//反向思维判断
                              flag=false;
                              break;
                        }
                    }
                    if(flag){
                        return true;
                    }
                  }
              //向右上
              if(i>=3&&j<=m[i].length-4){
                for(int k=j+1,c=i-1;k<=j+3;j++,c++){
                    if(m[i][j]!=m[c][k]){//反向思维判断
                          flag=false;
                          break;
                    }
                }
                if(flag){
                    return true;
                }
              }
              //向右下
              if(i<=m.length-4&&j<=m.length-4){
                for(int r=j+1,c=i+1;c<=i+3;r++,c++){
                    if(m[i][j]!=m[c][r]){//反向思维判断
                          flag=false;
                          break;
                    }
                }
                if(flag){
                    return true;
                }
              }
          }
    }
}