Java二维数组以及多维数组的定义及应用

一、二维数组以及多维数组

1、二维数组的定义：

​ 在一维数组中定义每一个元素也是一个数组元素，这样的数组称为”二维数组“

​ 多维数组就是在一维数组上再次定义二维数组或三位数组等。

​ 一维数组定义 int [] array={1,2,3}

//定义三个长度的二维数组，其数组的每一个元素是一个一维数组
int [][] arrays={{},{},{}};
或者
int [][] arrays=new int [3][2];//等号右边的左边[]中表示二维数组的长度，其中2可以省略，3不能省略
//注意：等号左边有几个[]就表示几维

//1、定义二维数组
	int [][] array;
//定义时给二维数组赋值 3个长度的二维数组里面的一维数组的长度不一定相等
	int [][] array2={{1,2,3},{4,5},{7,8}}
//定义时只指定大小，不给定初始值
int [][]array3=new int[3][];//等价{{},{},{}}
//array3[0][0]=1;//赋值时 空指针异常，因为里面的一维数组是空的
//定义一个3个长度的二维数组，里面的元素长度是2
int array4[][]=new int[3][2];
//给元素赋值
array4[0][0]=1;
//输出二维数组中的所有元素
for(int i=0;i<array4.length;i++){
    //System.out.println(array4[i]);
    for(int j=0;j<array4[i].length;j++){
        System.out.println(array[i][j]);
    }
}

二、二维数组的应用

1、定义5*5的矩阵，计算最大值最小值

public class Test{
    public static void main(String[] args) {
        //定义一个5*5的二维数组
       int [][] array=new int[5][5];
       //定义最大值，并初始化
       int max=0;
       //定义最小值，并初始化
       int min=0;
       //为二维数组中的每一个元素赋上一个0-100的整数值，并遍历输出二维数组
        for (int i = 0; i <array.length ; i++) {
            for (int j = 0; j <array[i].length ; j++) {
                array[i][j]=(int)(Math.random()*100);
                System.out.print(array[i][j]+"	");
            }
            System.out.println();//换行
        }
        //将数组中的第一个元素赋值给max
        max =array[0][0];
        for (int i = 0; i <array.length ; i++) {
            for (int j = 0; j <array[i].length ; j++) {
                //如果数组中元素大于max，则将元素赋值给max
                if(array[i][j]>=max){
                    max=array[i][j];
                }
            }
        }
        //输出二维数组中的最大值
        System.out.println("最大值为："+max);
        //将数组中的第一个元素赋值给min
        min =array[0][0];
        for (int i = 0; i <array.length ; i++) {
            for (int j = 0; j <array[i].length ; j++) {
                //如果元素小于min，则将元素赋值给min
                if(array[i][j]<=min){
                    min=array[i][j];
                }
            }
        }
        //输出二维数组中的最小值
        System.out.println("最小值为："+min);
    }
}

2、五子棋游戏

public class Test{
    //定义一个字符串型20*20的二维数组
    static String [][] qipan=new String[20][20];
    public static void main(String[] args) {
        System.out.println("------------------------------五子棋游戏------------------------------");
        //初始化棋盘
        for (int i = 0; i <qipan.length; i++) {
            for (int j = 0; j <qipan[i].length; j++) {
                qipan[i][j]="+";
            }
        }
        printQipan();
        System.out.println("游戏开始：");
        Scanner sc=new Scanner(System.in);
        while(true) {
            System.out.println("请玩家(黑棋)落子：");
            System.out.print("请输入棋子的行数(1-20):");
            int num1 = sc.nextInt();
            System.out.print("请输入棋子的列数(1-20):");
            int num2 = sc.nextInt();
            if (num1 <= 0 || num1 > 20 || num2 <= 0 || num2 > 20 ) {
                System.out.println("落子超出棋盘边界，请重新落子！");
                continue;
            } else {
                if( qipan[num1 - 1][num2 - 1] != "+"){
                    System.out.println("该位置已有棋子，请重新落子！");
                    continue;
                }else{
                    qipan[num1-1][num2-1]="⭕";
                }
            }
            //白棋落子
            int row=0;
            int col=0;
//            System.out.println("白棋思考中...");
            while(true){
                row=(int)(Math.random()*20);
                col=(int)(Math.random()*20);
                if(qipan[row][col]=="+"){
                    break;
                }
            }
            qipan[row][col]="●";
            //打印棋盘
            printQipan();
            //判断输赢
            if(judge()){
                System.out.println(s+"赢了");
                break;
            }
        }
    }
    //打印棋盘
    public static void printQipan(){
        for (int i = 0; i <qipan.length ; i++) {
            for (int j = 0; j <qipan[i].length ; j++) {
                System.out.print(qipan[i][j]+"	");
            }
            System.out.println();
        }
    }
    //判断输赢的方法
    static String s="";
    public static boolean judge(){
        boolean flag=false;
        for (int i = 0; i <qipan.length; i++) {
            for (int j = 0; j <qipan[i].length ; j++) {
                if(qipan[i][j]=="⭕"||qipan[i][j]=="●"){
                    //判断横向
                    if(j<16&&
                            qipan[i][j]==qipan[i][j+1]
                            &&qipan[i][j]==qipan[i][j+2]
                            &&qipan[i][j]==qipan[i][j+3]
                            &&qipan[i][j]==qipan[i][j+4]){
                        s=qipan[i][j];
                        flag=true;
                        break;
                    }
                    //判断右斜下
                    else if(i<16&&j<16&&qipan[i][j]==qipan[i+1][j+1]
                            &&qipan[i][j]==qipan[i+2][j+2]
                            &&qipan[i][j]==qipan[i+3][j+3]
                            &&qipan[i][j]==qipan[i+4][j+4]){
                        s=qipan[i][j];
                        flag=true;
                        break;
                    }
                    //判断纵向
                    else if(i<16&&qipan[i][j]==qipan[i+1][j]
                            &&qipan[i][j]==qipan[i+2][j]
                            &&qipan[i][j]==qipan[i+3][j]
                            &&qipan[i][j]==qipan[i+4][j]){
                        s=qipan[i][j];
                        flag=true;
                        break;
                    }
                    //判断左斜下
                    else if(i<16&&j>3&&qipan[i][j]==qipan[i-1][j-1]
                            &&qipan[i][j]==qipan[i-2][j-2]
                            &&qipan[i][j]==qipan[i-3][j-3]
                            &&qipan[i][j]==qipan[i-4][j-4]){
                        s=qipan[i][j];
                        flag=true;
                        break;
                    }
                }
            }
        }
        return flag;
    }
}

拓展：利用二分法查找数组中的元素

public class Test {
    public static void main(String[] args) {
        // 1、指定一个20个长度的数组 随机数
        int [] array=new int[20];
        for (int i = 0; i <array.length; i++) {
            array[i]=(int)(Math.random()*100);
        }
        //输出数组中的每一个元素
        System.out.println("数组中的元素为：");
        System.out.println(Arrays.toString(array));
        //  2、排序 （升序）
        Arrays.sort(array);
        //输出排序后的数组
        System.out.println("排序后的数组为：");
        System.out.println(Arrays.toString(array));
        //  3、输入一个目标数
        Scanner sc=new Scanner(System.in);
        System.out.print("请输入想要查找的数字：");
        int num=sc.nextInt();
        //  3、比较
        //定义 最小值下标  最大值下标 中间值下标  查找的目标下标
        /**
         *  最小下标    0
         *  *   最大下标   length-1
         *  *
         *  *  循环条件：  最小值小标<=最大值下标
         *     中间下标：  middle = (最小值+最大值)/2
         *  *   如果中间值比目标大  说明 在左边  改变最大值下标 = 中间值下标-1
         *  *   如果中间值比目标小  说明 在右边   改变最小值小标 = 中间值下标+1
         *  *   如果相等   就break
         *  *    一直这样比较 结束的条件是什么
         */
        //最小值小标
        int minIndex=0;
        //最大值下标
        int maxIndex=array.length-1;
        //中间值下标
        int middle;
        //目标值下标
        int index=-1;
        //计数器
        int count=0;
        while(minIndex<=maxIndex){
            count++;
            middle=(minIndex+maxIndex)/2;
            if(num<array[middle]){
                maxIndex=middle-1;
            }else if(num>array[middle]){
                minIndex=middle+1;
            }else {
                index=middle;
                break;
            }
        }
        if(index!=-1){
            System.out.println("目标已找到");
            System.out.print("共查询次数："+count+"
");
            System.out.print("目标数下标为："+index);
        }else{
            System.out.println("目标不存在");
        }
    }
}