java（七）数组（二维数组）

最新推荐文章于 2024-05-03 19:26:57 发布

[(-o-)]

最新推荐文章于 2024-05-03 19:26:57 发布

阅读量3.9k

点赞数

分类专栏： javase

本文链接：https://blog.csdn.net/lijin786/article/details/104397833

版权

javase 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

二维数组

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

二维数组具体是在内存中如何存储的呢？

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

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

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

创建二维数组：

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.

/*
数据： 输入的二维数组
步骤：
1.输入一个3*4的矩阵
2.打印每列的和
分析：
        (0,0) (0,1) (0,2) (0,3)
        (1,0) (1,1) (1,2) (1,3)
        (2,0) (2,1) (2,2) (2,3)
        累加行的时候 行不动 列动
        累加列的时候 列不动 行动
 */
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;
    }
}

2 .

/*
数据： 输入的二维数组
步骤：
1.输入一个4*4的矩阵
2.主对角线
3.副对角线
二位数组      主      副
1 2 3 4     (0,0)  (0,3)
1 2 3 4     (1,1)  (1,2)
1 2 3 4     (2,2)  (2,1)
1 2 3 4     (3,3)  (3,0)
          主(i,i)  副(i,matrix.length-1-i)
 主对角线上的元素 行列角标是相等的
*/
import java.util.*;
class Demo05_10{
    public static void main(String[] args){
         //1.输入一个4*4的矩阵
         Scanner scanner=new Scanner(System.in);
         System.out.print("请输入二维数组");
         double[][] matrix= new double [4][4];
         for (int i=0;i<matrix.length;i++){
            for (int j=0;j<matrix[i].length;j++){
               matrix[i][j] = scanner.nextDouble();
            }
         }
               //2.主对角线
               double sum=0;
               for (int i=0;i<matrix.length;i++){
               sum+=matrix[i][i];
               }
               System.out.println(sum);
               //3.副对角线
                double pum=0;
               for (int i=0;i<matrix.length;i++){
               pum+=matrix[i][matrix.length-1-i];
               }
               System.out.println(pum);
        }
    }

3.

/*
数据：二维数组A 二维数组B
步骤：
1.定义数组A、B
2.计算A数组与B数组乘积
*/
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
        对于数学上的一些运算公式 如果直接通过看计算流程还是比较麻烦的
        此时推荐使用已知公式计算！
        */
        //1.定义数组A、B
        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}
        };
        //2.计算A数组与B数组乘积
        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();
        }
    }
}

4.

/*
数据：数组行列、随机数组由01组成
步骤：
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();
        }
        //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);
            }
        }
    }
}

5.

/*
数据：row col 二维数组
步骤：
1.输入数组的行列、输入数组元素
2.对于数组中存在4个相同的元素就结束查找。
*/
import java.util.*;
class Demo05_13{
    public static void main(String[] args){
        //1.输入数组的行列、输入数组元素
        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));
    }
    //2.对于数组中存在4个相同的元素就结束查找。
    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;//四个方向都没有连续的
    }
}

6.

五子棋问题

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(){//15*15
     for(int i=0;i<board.length;i++){
            for(int j=0;j<board[i].length;j++){
                //向右看
                if(j<=board[i].length-4){//向右的列数的限制
                    boolean flag=true;
                    for(int c=j+1;c<=j+4;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+4;r++){
                        if(m[i][j]!=m[r][j]){
                            flag=false;
                            break;
                        }
                    }
                    if(flag){
                        return true;
                    }
                }
                //向右下看
                if(i<=m.length-5&&j<=m[0].length-5){ //对行数列数的限制
                    boolean flag=true;
                    for(int r=i+1,c=j+1;r<=i+5;r++,c++){
                        if(m[i][j]!=m[r][c]){
                            flag=false;
                            break;
                        }
                    }
                    if(flag){
                        return true;
                    }
                }
                //向右上
                if(i>=4&&j<=m[0].length-5){对行数列数的限制
                    boolean flag=true;
                    for(int r=i-1,c=j+1;c<=j+5;r--,c++){
                        if(m[i][j]!=m[r][c]){
                            flag=false;
                            break;
                        }
                    }
                    if(flag){
                        return true;
                    }
                }
            }
        }
        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]="+";
            }
        }
    }
}

[(-o-)]

关注

0
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
java（七）数组（二维数组）

二维数组二维数组简单来说就是一个由行和列组成的一个表格而已，通俗的说就是一个矩阵Matrix。我们在这个矩阵中访问元素的话，是根据元素的行角标和列角标所确定的。二维数组具体是在内存中如何存储的呢？无论是二维数组，还是多维数组，它们本身就是一个一维数组尤其对于二维数组而言，无非就是一个一维数组，只不过该一维数组中的每一个元素是另一个一维数组罢了！二维数组：二...
复制链接

扫一扫