精华内容
下载资源
问答
  • 二维数组格式1 /* 二维数组:就是元素为一维数组的一个数组。 格式1: 数据类型[][] 数组名 = new 数据类型[m][n]; m:表示这个二维数组有多少个一维数组。 n:表示每一个一维数组的元素有多少个。 注意...

    二维数组格式1

    /*
        二维数组:就是元素为一维数组的一个数组。
        
        格式1:
            数据类型[][] 数组名 = new 数据类型[m][n];
            
            m:表示这个二维数组有多少个一维数组。
            n:表示每一个一维数组的元素有多少个。
            
        注意:
            A:以下格式也可以表示二维数组
                a:数据类型 数组名[][] = new 数据类型[m][n];
                b:数据类型[] 数组名[] = new 数据类型[m][n];
            B:注意下面定义的区别
                int x;
                int y;
                int x,y;
                
                int[] x;
                int[] y[];
                
                int[] x,y[];//这个x是一维数组,y是二维数组
    */
    class Array2Demo {
        public static void main(String[] args) {
             //定义一个二维数组
             int[][] arr = new int[3][2];
             //定义了一个二维数组arr
             //这个二维数组有3个一维数组的元素
             //每一个一维数组有2个元素
             //输出二维数组名称
             System.out.println(arr); //地址值    [[I@175078b
             //输出二维数组的第一个元素一维数组的名称
             System.out.println(arr[0]); //地址值    [I@42552c
             System.out.println(arr[1]); //地址值    [I@e5bbd6
             System.out.println(arr[2]); //地址值    [I@8ee016
             //输出二维数组的元素
             System.out.println(arr[0][0]); //0
             System.out.println(arr[0][1]); //0
        }
    }

    格式1内存图解:

     

     二维数组格式2

    /*
        格式2:
            数据类型[][] 数组名 = new 数据类型[m][];
            
            m:表示这个二维数组有多少个一维数组。
            列数没有给出,可以动态的给。这一次是一个变化的列数。
    */
    class Array2Demo2 {
        public static void main(String[] args) {
            //定义数组
            int[][] arr = new int[3][];
            
            System.out.println(arr);    //[[I@175078b
            System.out.println(arr[0]); //null
            System.out.println(arr[1]); //null
            System.out.println(arr[2]); //null
            
            //动态的为每一个一维数组分配空间
            arr[0] = new int[2];
            arr[1] = new int[3];
            arr[2] = new int[1];
            
            System.out.println(arr[0]); //[I@42552c
            System.out.println(arr[1]); //[I@e5bbd6
            System.out.println(arr[2]); //[I@8ee016
            
            System.out.println(arr[0][0]); //0
            System.out.println(arr[0][1]); //0
            //ArrayIndexOutOfBoundsException
            //System.out.println(arr[0][2]); //错误
            
            arr[1][0] = 100;
            arr[1][2] = 200;
        }
    }

     二维数组格式2  内存图解:

    二维数组格式3 

    /*
        格式3:
            基本格式:
                数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
            简化版格式:
                数据类型[][] 数组名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
                
            举例:
                int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
                int[][] arr = {{1,2,3},{4,5},{6}};
    */
    class Array2Demo3 {
        public static void main(String[] args) {
            //定义数组
            int[][] arr = {{1,2,3},{4,5},{6}};
            
            System.out.println(arr);
            System.out.println(arr[0]);
            System.out.println(arr[1]);
            System.out.println(arr[2]);
            
            System.out.println(arr[0][0]); //1
            System.out.println(arr[1][0]); //4
            System.out.println(arr[2][0]); //6
            
            System.out.println(arr[0][1]); //2
            System.out.println(arr[1][1]); //5
            //越界
            System.out.println(arr[2][1]); //错误
        }
    }

    二维数组格式3  内存图解:

     遍历二维数组

    /*
        需求:二维数组遍历
        
        外循环控制的是二维数组的长度,其实就是一维数组的个数。
        内循环控制的是一维数组的长度。
    */
    class Array2Test {
        public static void main(String[] args) {
            //定义一个二维数组
            int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
            
            //用方法改进
            //调用方法
            printArray2(arr);
        }    
        
        /*
            需求:遍历二维数组
            两个明确:
                返回值类型:void
                参数列表:int[][] arr
        */
        public static void printArray2(int[][] arr) {
            for(int x=0; x<arr.length; x++) {
                for(int y=0; y<arr[x].length; y++) {
                    System.out.print(arr[x][y]+" ");
                }
                System.out.println();
            }
        }
    }

    二维数组求和:

    /*
        公司年销售额求和
        某公司按照季度和月份统计的数据如下:单位(万元)
        第一季度:22,66,44
        第二季度:77,33,88
        第三季度:25,45,65
        第四季度:11,66,99
        
        分析:
            A:把题目的数据用二维数组来表示
                int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
            B:如何求和呢?
                求和其实就是获取到每一个元素,然后累加即可。
            C:定义一个求和变量sum,初始化值是0。
            D:通过遍历就可以得到每一个二维数组的元素。
            E:把元素累加即可。
            F:最后输出sum,就是结果。
    */
    class Array2Test2 {
        public static void main(String[] args) {
            //把题目的数据用二维数组来表示
            int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
            
            //定义一个求和变量sum,初始化值是0。
            int sum = 0;
            
            //通过遍历就可以得到每一个二维数组的元素。
            for(int x=0; x<arr.length; x++) {
                for(int y=0; y<arr[x].length; y++) {
                    //把元素累加即可。
                    sum += arr[x][y];
                }
            }
            
            //最后输出sum,就是结果。
            System.out.println("一年的销售额为:"+sum+"万元");
        }
    }

     

    二维数组树出杨辉三角:打印杨辉三角形(行数可以键盘录入)

    /*
    
        需求:打印杨辉三角形(行数可以键盘录入)
        
        1
        1 1    
        1 2 1
        1 3 3 1
        1 4 6 4 1 
        1 5 10 10 5 1
    
        分析:看这种图像的规律
            A:任何一行的第一列和最后一列都是1
            B:从第三行开始,每一个数据是它上一行的前一列和它上一行的本列之和。
        
        步骤:
            A:首先定义一个二维数组。行数如果是n,我们把列数也先定义为n。
              这个n的数据来自于键盘录入。
            B:给这个二维数组任何一行的第一列和最后一列赋值为1
            C:按照规律给其他元素赋值
                从第三行开始,每一个数据是它上一行的前一列和它上一行的本列之和。
            D:遍历这个二维数组。
    */
    import java.util.Scanner;
    
    class Array2Test3 {
        public static void main(String[] args) {
            //创建键盘录入对象
            Scanner sc = new Scanner(System.in);
            
            //这个n的数据来自于键盘录入。
            System.out.println("请输入一个数据:");
            int n = sc.nextInt();
            
            //定义二维数组
            int[][] arr = new int[n][n];
            
            //给这个二维数组任何一行的第一列和最后一列赋值为1
            for(int x=0; x<arr.length; x++) {
                arr[x][0] = 1; //任何一行第1列
                arr[x][x] = 1; //任何一行的最后1列
            }
            
            //按照规律给其他元素赋值
            //从第三行开始,每一个数据是它上一行的前一列和它上一行的本列之和。
            for(int x=2; x<arr.length; x++) {
                //这里如果y<=x是有个小问题的,就是最后一列的问题
                //所以这里要减去1
                //并且y也应该从1开始,因为第一列也是有值了
                for(int y=1; y<=x-1; y++) {
                    //每一个数据是它上一行的前一列和它上一行的本列之和。
                    arr[x][y] = arr[x-1][y-1] + arr[x-1][y];
                }
            }
            
            //这个时候,要注意了,内循环的变化必须和曾经讲过的九九乘法表类似
            for(int x=0; x<arr.length; x++) {
                for(int y=0; y<=x; y++) {
                    System.out.print(arr[x][y]+"\t");
                }
                System.out.println();
            }
        }
    }

     

    展开全文
  • 二维数组 就是一个由行和列组成的一个表格而已,矩阵Matrix。 我们在这个矩阵中访问元素的话,是根据元素的行角标和列角标所确定的。 1、那么对于二维数组是如何存储的呢? 无论是二维数组,还是多维数组,...

    二维数组

    就是一个由行和列组成的一个表格而已,矩阵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;//四个方向都没有连续的
        }
    }

     

     

    展开全文
  • Java 二维数组

    2020-02-20 19:55:25
    二维数组 二维数组简单来说就是一个由行和列组成的一个表格,也就是数学中的矩阵。我们在这个矩阵中访问元素的话,是根据元素的行角标和列角标所确定的。 那么具体是在内存中如何存储的呢? 无论是二维数组,...

    二维数组

    二维数组简单来说就是一个由行和列组成的一个表格,也就是数学中的矩阵。我们在这个矩阵中访问元素的话,是根据元素的行角标和列角标所确定的。

    那么具体是在内存中如何存储的呢?

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

    二维数组:二维数组行列组成的表格,格子中内容就是二维数组的元素。

    二位数组存储:依旧是在堆内存 ,二维数组就是多个一维数组组成

     创建二维数组:

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

    int[][] matrix=new int[][]{ 

        {1,2,3,4} ,

        {5,6,7,8} ,

        {9,10,11,12} 

    };

    创建个指定元素的二维数组

    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} 

    };
    特别的,如果一个二维数组的行和列相等的话,也称之为是方阵

    示例

    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();
            }
            //int[][] matrix=new int[m][n]; 这个二维数组定义下 
            //内存中一共有几个一维数组  m+1
     
        }
    }
    

    基本数据类型与引用数据类型(区别)

    基本数据类型传参—— 传的是常量在常量池中的地址;引用数据类型传参—— 传的是对象在堆内存中的地址。

    强调一点:实参—>形参 传的永远是地址。

            基本数据类型:是原子型数据 ,也就是说不可再拆分;

            引用数据类型:是复合型数据 ,也就是在当前对象数据中,还包括了其他更多的子数据。
            例如:     int a,b,c;-> arr [a,b,c]       人:姓名 年龄 性别 身高 体重....

            复合型数据 : 指的就是由多个基本数据或其他引用数据组成的一个数据。

             形参变量永远不可能去改变实参中已储存的数据地址 ,除非return 实参且接收, 就算形参变量所存储的数据地址被改变 ,那也是改变形参自己与实参无关。
    无非是:
            实参本身指向的是一个对象, 然后把这个对象的地址传递给了形参;形参就可以通过该地址去堆内存中找对象,可以修改对象中的数据;实参再去访问对象时,对象中的数据就已经被改变; 因为实参和形参目前使用操作的都是同一个对象

      总结:

            无论实参还是形参, 实参就是把变量空间所存的地址给了形参而已;  他们都是变量! 所以对于变量的修改而言,主要分两种!

            1.要么改变该变量空间所存储的地址
                  int a=3; 
                  a=7;
                  int[] arr=new int[]{1,2,3};
                  arr=new int[]{3,2,1};

            2.要么改变该变量空间所存储的地址所指向的那个对象中的数据

                 int[] arr=new int[]{1,2,3};

                 arr[0]=10;  

            对与基本数据类型而言,不能进行第2个操作。

    示例:

    class Test02{
        public static void main(String[] args){
            int a=3;
            int b=7;
            swap(a,b);
            System.out.printf("a=%d,b=%d\n",a,b);//结果是a=3;b=7
     
            int[] arr={3,7};
            swap(arr[0],arr[1]);
            System.out.printf("arr[0]=%d,arr[1]=%d\n",arr[0],arr[1]);//结果是arr[0]=3,arr[1]=7
            swap(arr);
            System.out.printf("arr[0]=%d,arr[1]=%d\n",arr[0],arr[1]);//结果是arr[0]=3,arr[1]=7
            swap2(arr);
            System.out.printf("arr[0]=%d,arr[1]=%d\n",arr[0],arr[1]);//结果是arr[0]=10,arr[1]=20
        }
        public static void swap(int m,int n){
            m=7;
            n=3;
        }
        public static void swap(int[] arr){
            arr[0]=7;
            arr[1]=3;
        }
        public static void swap2(int[] arr){//0xabc
            arr=new int[]{10,20};
        }
    }
    

    习题示例:

    步骤:1.这是一个二维矩阵,输入是两个[]

                2.你先输出行,在行不变的基础上输出列

    import java.util.*;
    class Demo05_09{
        public static void main(String[] args){
            /*
                累加行的时候 行不动 列动
                累加列的时候 列不动 行动
            */
            //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;
        }
    }
    

    5.10

    方法:

    主对角线上的元素,行列角标是相等的

    主对角线是m[i][i];而复对角线是m[i][m.length-1-i]

    class Demo05_10{
        public static void main(String[] args){
            /*
                主对角线上的元素 行列角标是相等的
            */
            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];
                    }
                }
            }
            */
        }
    }
    

    5.11

    //  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
            对于数学上的一些运算公式 如果直接通过看计算流程还是比较麻烦的
            此时推荐使用已知公式计算!

    class Demo05_11{
        public static void main(String[] args){
            //m*n n*p m*p 矩阵相乘 前者的列 必须等于 后者的行
            /*
          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();
            }
        }
    }
            */
            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();
            }
        }
    }
    

    步骤1.输入方针的尺寸 创建方阵

                2.随机的给方阵中填入0或1

                3.让行,列,对角线累加 sum==0 sum==size 表示全相等

    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();
            }
            //
            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);
                }
            }
        }
    

    因为要保证四个连续数字,则小于等于3的那个位置,所以要减4。

    注意这个-4只是针对本题的,并不是固定的。

    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;//四个方向都没有连续的
        }
    }
    

    最后来看一个我们都玩过的经典小游戏

    5.15   五子棋问题

    import java.util.*;
    class Demo05_15{
        /* 
        五子棋 黑白棋 谁先连成5个子 谁就赢
        棋盘 我们用什么去表示棋盘
        +++++++
        +++++++
        +++++++
        那也就是说我们需要创建一个String的二维数组来表示棋盘
        如何下棋呢?
        目前我们的程序是控制台程序,不能说是用点击的方式进行下棋
        只能是输入棋子的坐标进行下棋
        输入 1,1 指的就是在(0,0)处下一个棋子
        
        初始化棋盘 initBoard()
        打印棋盘   printBoard()
        开始游戏   startGame()
        下棋(黑白) putDownChess()
        判断输赢   isGameOver()
        上述方法都会去调用棋盘board数据 
        如果每次讲board当做参数传递个函数的时候 会显得比较麻烦
        我们可以将board数据定义为全局变量 任何函数都可以访问的变量
        全局变量定义在函数的外面 类的里面 必须public static开头
        */
     
        //全局变量 棋盘 方便函数直接调用 而不需要依次传参
        public static String[][] board; //定义为是15*15的棋盘
        public static String BLACK_CHESS="O";   //黑棋
        public static String WHITE_CHESS="X";   //白棋
        public static Scanner scanner=new Scanner(System.in);
     
        public static void main(String[] args){
            //1.初始化棋盘
            initBoard();
            //2.打印棋盘
            printBoard();
            //3.开始游戏
            startGame();
        }
        public static void startGame(){
            /*
            黑方 白方 轮流 下棋 
            */
            int player=0;   //player 偶数 黑 ;奇数 白
            while(true){
                if(player%2==0){    //黑方下棋
                    System.out.print(">>>请黑方下棋:");
                    if(!putDownChess(BLACK_CHESS)){
                        continue;
                    }
                }else{              //白方下棋
                    System.out.print(">>>请白方下棋:");
                    if(!putDownChess(WHITE_CHESS)){
                        continue;
                    }
                }
                if(isGameOver()){
                    break;
                }
                player++;
            }
        }
        public static boolean isGameOver(){
            //你们自己写吧 我写过了 注意和棋的情况
            return false;
        }
        public static boolean putDownChess(String chess){
            //用户输入的 (1,1) -> (0,0)
            //1 B
            int x=scanner.nextInt()-1;
            int y=scanner.next().charAt(0)-'A';
            if(!board[x][y].equals("+")){
                System.out.println(">>>此处已有棋子,请重新下棋");
                //另外一种处理方式 就是讲player定义为全局 此处player--即可
                return false;//意味着下棋不成功
            }
            board[x][y]=chess;
            printBoard();
            return true;    //意味着下棋成功
        }
        public static void printBoard(){
            System.out.print("   ");
            for(int i=0;i<=14;i++){
                System.out.print((char)('A'+i)+" ");
            }
            System.out.println();
            for(int i=0;i<board.length;i++){
                System.out.printf("%2d ",i+1);
                for(int j=0;j<board[i].length;j++){
                   System.out.print(board[i][j]+" ");
                }
                System.out.println();
            }
        }
        public static void initBoard(){
            board=new String[15][15];
            for(int i=0;i<board.length;i++){
                for(int j=0;j<board[i].length;j++){
                    board[i][j]="+";
                }
            }
        }
    }
    

     

     

    展开全文
  • java 二维数组

    2017-12-13 11:11:00
    二维数组 多维数组可以简单地理解为在数组中嵌套数组 二维数组的定义格式 二维数组的定义有很多方式 第一种方式 1 int[][] arr = new int[3][4]; 上面的代码相当于定义了一个3*4的二维数组,即二维数组的...

    二维数组

    多维数组可以简单地理解为在数组中嵌套数组

    二维数组的定义格式

    二维数组的定义有很多方式

    第一种方式

    1 int[][] arr = new int[3][4];

    上面的代码相当于定义了一个3*4的二维数组,即二维数组的长度为3,二维数组中的每个元素又是一个长度为4的数组

    第二种方式

    1 int[][] arr = new int[3][];

    第二种方式和第一种类似,只是数组中每个元素的长度不确定

    第三种方式

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

    上面的二维数组中定义了三个元素,这三个元素都是数组,分别为{1,2}{3,4,5,6}{7,8,9}

    对二维数组中元素的访问也是通过角标的方式,例如访问二维数组中第一个元素数组的第二个元素

    1 arr[0][1];

    二维数组元素的访问

    如何获取二维数组中元素值

    例:

     1 class ArrayDemo08 {
     2     public static void main(String[] args){
     3     
     4         //定义二维数组的方式
     5         int[][] arr = new int[3][4];
     6     
     7         System.out.println( arr );
     8         System.out.println("二维数组的长度: " + arr.length);
     9         //获取二维数组的3个元素
    10         System.out.println( arr[0] );
    11         System.out.println( arr[1] );
    12         System.out.println( arr[2] );
    13         
    14         System.out.println("打印第一个一维数组的元素值");
    15         System.out.println( arr[0][0] );
    16         System.out.println( arr[0][1] ); //访问的为二维数组中第1个一维数组的第2个元素
    17         System.out.println( arr[0][2] );
    18         System.out.println( arr[0][3] );
    19         
    20         System.out.println("打印第二个一维数组的元素值");
    21         System.out.println( arr[1][0] );
    22         System.out.println( arr[1][1] );
    23         System.out.println( arr[1][2] );
    24         System.out.println( arr[1][3] );
    25         
    26         System.out.println("打印第三个一维数组的元素值");
    27         System.out.println( arr[2][0] );
    28         System.out.println( arr[2][1] );
    29         System.out.println( arr[2][2] );
    30         System.out.println( arr[2][3] );
    31     }

    二维数组元素遍历与数组元素累加和

     1 class ArrayDemo09 {
     2     public static void main(String[] args){
     3         //一维数组的求累加和并遍历
     4         int[] arr = {10,20,30,40,50};
     5         int sum = 0; 
     6         for (int i=0; i<arr.length; i++) {
     7               //System.out.println(arr[i]);
     8             sum += arr[i];
     9         }
    10         System.out.println("sum= " + sum);
    11         System.out.println("---------------------");
    12         
    13     //二维数组的求累加和并遍历
    14         int[][] arr2 = { {1,2},{3,4,5},{6,7,8,9,10} };
    15         int sum2 = 0;
    16         for (int i=0; i<arr2.length; i++) {
    17             for (int j=0; j<arr2[i].length; j++) {
    18                  //System.out.println(arr2[i][j])
    19                 sum2 += arr2[i][j];
    20             }
    21         }
    22         System.out.println("sum2= "+ sum2);
    23     }
    24 }
    25 结果:sum=150
    26      sum2=55

     创建的数组实际上是在堆内存中创建了一块空间存放值,并生成一个地址,这个地址指向这个数组

    二维数组:实质就是存储是一维数组。

    转载于:https://www.cnblogs.com/ty-v/p/8031881.html

    展开全文
  • java二维数组

    2018-12-05 11:19:00
    1 二维数组的定义方式 二维数组的定义有很多方式 第一种方式: int[][] arr = new int[3][4]; 上面的代码相当于定义了一个3*4的二维数组,即二维数组的长度为3,二维数组中的每个元素又是一个长度为4的数组...
  • My problem is to add the sum of each row in a 2d array, and put those values in a new 1d array.This is my codepublic static int[] sumRow(int[][] N){int[] rowSum = new int[N.length];...
  • 二维数组:就是元素为一维数组的一个数组。 格式1: 数据类型[][] 数组名 = new 数据类型[m][n]; m:表示这个二维数组有多少个一维数组。 n:表示每一个一维数组的元素有多少个。 注意: A:以下...
  • 二维数组求和并累加,赋值到新数组 //矩阵相乘得到新的二维数组。 public class MatrixMultiply { public static void main(String[] args) { int i, j, k; int[][] a = new int[2][3]; int[][] b = { { 1...
  • 二维数组 习题总结
  • Java二维数组列求和

    千次阅读 2019-07-10 20:33:00
    /定义一个205的二维数组,用来存储某班级20位学员的5门课的成绩;这5门课 按存储顺序依次为:core C++,coreJava,Servlet,JSP和EJB。 (1)循环给二维数组的每一个元素赋0~100之间的随机整数。 (2)按照列表的...
  • Java 二维数组 方法

    2018-09-16 11:51:00
    二维数组 定义 第一种:int[][] arr = new int[3][4]; 第二种:int[][] arr = new int[3][];(了解即可) 第三种:int[][] arr = {{1,2},{3,4,5,6},{7,8,9}}; 访问 int[][] arrt = new int[3][4]; ...
  • 数组的基础知识: 1.什么是数组数组是相同类型的数据按顺序组成的一种引用数据类型 提醒:数组一旦被创建,它的大小是固定的。 2.数组声明: 数组类型[]   数组名 或则 数据类型 数组名[] 3.创建...
  • 二维数组定义格式: 第一种:int[][] arr = new int[3][4]; 第二种:int[][] arr = new int[3][]; 第三种:int[][] arr = {{1,2},{3,4,5,6},{7,8,9}}; 二维数组元素遍历: class demo01 { public static void ...
  • Java二维数组实现学生成绩存储

    千次阅读 2020-07-08 11:02:59
    import java.util.Scanner; public class ScoreReceiveAndOutput { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int scoreArr[][] = new int[2][3]; // 循环接收2个...
  • 由于word里的样式在csdn上调太麻烦了,所以我再次贴图了,后面二维数组那里是文字的,大家将就看吧。 二维数组常见的操作: 1.遍历二维数组 2.对二维数组求和 class Demo { // 定义一个遍历二维...
  • 初识JAVA二维数组相加

    千次阅读 2018-02-15 16:26:06
    今天初学JAVA数组 通过与C语言对比 JAVA与C语言的数组定义大致类似,但是在细节类容上还是稍微有偏差:通过网络课程的自学 进一步了解了JAVA数组知识JAVA代码如下: public class Erweishuzu { //通过对打印结果...
  • 一,二维数组 1,概述 二维数组实际上是一个元素是一维数组的数组。(烟) 一包烟好比是一维数组,一条烟就好比是二维数组了。 2,二维数组的定义格式 格式一:数据类型[][] 数组名 = new 数据类型[x][y]; x表示...
  • 一维数组练习二、二维数组1. 二维数组概述及格式2. 二维数组内存图解3. 二维数组练习三、递归1. 递归概述2. 递归思想图解3.递归练习 一、一维数组 1. 一维数组概念及定义格式 为什么要有数组 数组可以存储同...
  • 一般是3~5天HR会通知你,如果一直没有通知的话也可以在4天左右给招聘公司打一个电话,一来可以加深用人单位对你的印象,来就算没有给你下offer,也可以知道自己有哪些地方不足,这样的话方便下次改正。 今天主要是...
  • [2]*b[2][1]+a[1][3]*b[3][1] 转换成代码则可想到 矩阵可以利用二维数组来实现 下标的改变以及算术累加可以用for循环来实现 在此之上我们可以再思考 z[1][1]计算过后我们将会继续计算z[1][2] 而列下标的改变则可再次...
  • Java基础语法(一维数组、二维数组)1 一维数组1.1 数组语法1.2 数组动态赋值1.3 数组异常1.3.1 下标越界1.3.2 空指针异常1.4 数组常用操作1.5 数组排序算法1.5.1 冒泡排序与 Arrays.sort(array)1.5.2 直接选择排序...
  • hp实训8.03_Java基础之二维数组和方法 二维数组:数组中的数组 1.声明二维数组: 数据类型[][] 数据名; 第一个中括号:二维数组中有几个一维数组 行 第二个中括号:每个一维数组中有多少元素 列 2.初始化二维...
  • 1.编写程序,把下面的数据输入到一个二维数组中: 25 36 78 13 12 26 8我自己编的,用VISUAL C++6.0 测试过了 #include"stdio.h" void Print(int a[4][4]) { int i,j; for(i=0;i输入4行4列的二维数组,CSS布局HTML小...
  • 二维数组 二维数组简单来说就是一个由行和列组成的一个表格而已,通俗的说就是一个矩阵Matrix。 我们在这个矩阵中访问元素的话,是根据元素的行角标和列角标所确定的。 二维数组具体是在内存中如何存储的呢? ...
  • 第十、Java二维数组

    2017-03-15 16:28:10
    数组的特点: 1. 数组只能存储同一种 数据类型的数据。 2. 数组是会给存储到数组中 的元素分配一个索引值的,索引值从0开始,最大...二维数组二维数组就是数组中的数组。 烟 一根 变量 一盒 20根 一维数组 一
  • 1.数组介绍 数组:存储多种数据类型的多个数。 int [ ] arr={80,76,65} 2.数组定义格式和静态初始化 静态初始化:在内存中,为数组容器开辟空间,并将元素存入空间 定义格式: 01完整格式: 数组类型【】 数组名 =...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,807
精华内容 1,922
关键字:

java二维数组累加

java 订阅