Java中的二维数组

二维数组

 一、二维数组的定义格式：

    数据类型[] [] 数组名 = new 数据类型[m][n] ;
            m:代表当前二维数组中有多少个一维数组
            n:代表每一个一维数组中的长度
            
    定义的方式还有以下两种情况
        数据类型[]  数组名[] = new 数据类型[m][n]
        数据类型  数组名[][] = new 数据类型[m][n]
例：

public class ArrayTwo {
     public static void main(String[] args) {   //二位数组的三种定义格式
      int [][] arr1=new int[2][3];
      int [] arr2[]=new int[3][4];
      int  arr3[][]=new int[4][5];
     }
   }

 二、二维数组的初始化

    1）动态初始化

public class ArrayTwo {
     public static void main(String[] args) {
      int [][] arr1=new int[2][2];//格式1
       arr1[0][0]=3;
       arr1[0][1]=6;
       arr1[1][0]=8;
       arr1[1][1]=2;
     int[][] arr2=new int[2][];//格式2主要用于定义不规则数组
        arr2[0]=new int[2];
        arr2[1]=new int[3];
        arr2[0][0]=1;
        arr2[0][1]=2;
        arr2[1][0]=3;
        arr2[1][1]=4;
        arr2[1][2]=5;
     }
 }

2)静态初始化

      数据类型[][] 数组名称 = {{元素1,元素2,元素3},{....}} ;

public class ArrayTwo {
     public static void main(String[] args) {
      int [][] arr1={ {2,3},{2,5},{6,8}};//静态初始化

     }
  }

 三、二维数组的遍历

    1）使用for循环嵌套遍历二维数组

  public class ArrayTwo {
     public static void main(String[] args) {
    	 int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
    	 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();
 		}
     }
    }

 显示：
    	1 2 3 
	4 5 6 
	7 8 9 

 2）使用for each改进

 public class ArrayTwo {
     public static void main(String[] args) {
    	 int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
    	 for(int x = 0 ; x < arr.length ; x ++) {
 			for(int p:arr[x]) {
 				System.out.print(p+"  ");
 			}
 			System.out.println();
 		}
     }
   }

显示；
	1  2  3  
	4  5  6  
	7  8  9

 四、例题

   1）求二维数组中的最大值

public class ArrayTwo {
     public static void main(String[] args) {
    	 int[][] arr = {{4,3,5},{1,2,7},{6,8,0}};//静态初始化一个数组
    	 int max=0;//定义一个最大值
    	 for(int x = 0 ; x < arr.length ; x ++) {//控制二维数组的层（每层相当一个一维数组）
 			for(int p:arr[x]) {//将每层中的元素与最大值进行比较
 				if(max<p) {
 					max=p;
 				}
 			}
 		
 		}
    		System.out.println(max);
     }
  }

  结果：8

2）冒泡从小到大排序二维数组中的元素

 public class ArrayTwo {
     public static void main(String[] args) {
    	 int[][] arr = {{4,3,5},{6,2,7},{9,8,1}};//静态初始化一个数组
    	 for( int q=0;q<arr.length;q++) {   //循环层间冒泡排序
    	 for(int x = 0 ; x < arr.length ; x ++) {//控制二维数组的层（每层相当一个一维数组）
    		
    			 for(int w=0, j=0;j<arr.length;j++) {
    				 for(int t=0, y=0;y<arr[x].length-1;y++) {//循环每层冒泡排序
    					 if(arr[x][y]>arr[x][y+1]) {//从大到小冒泡排序
    						  t=arr[x][y+1];
    						  arr[x][y+1]=arr[x][y];
    						  arr[x][y]=t;
    					             }
    				          }
    				   if(x<arr.length-1) {//控制层间比较次数
    				    if(arr[x][arr[x].length-1]>arr[x+1][0]) {//上层末与下层首元素比较大小
    				    	    w=arr[x][arr[x].length-1];
    				    	    arr[x][arr[x].length-1]=arr[x+1][0];
    				    	    arr[x+1][0]=w;
    				    }
    				   }
  			        }
  			
 			}
    	 }
    	 for(int x = 0 ; x < arr.length ; x ++) {
  			for(int p:arr[x]) {//使用for each循环语句输出
  				System.out.print(p+"  ");
  			}
  			System.out.println();
  		}
 		}
    		
     }

结果：1  2  3  
     4  5  6  
     7  8  9

3）求两个矩阵之和

 public class ArrayTwo {
     public static void main(String[] args) {
    	 int[][] arr = {{4,3,5},{6,2,7},{9,8,1}};//静态初始第1个矩阵数组
    	 int[][] brr= {{3,4,5},{7,8,9},{1,2,4}};//静态初始第2个矩阵数组
    	 int[][] crr=new int[3][3];//定义一个和数组
    	for(int x=0;x<arr.length;x++) {
    		for(int y=0;y<arr[x].length;y++) {
    			crr[x][y]=arr[x][y]+brr[x][y];//个元素求和
    		}
    	}
    	for(int x=0;x<crr.length;x++) {
    		for(int h:crr[x]) {
    			System.out.print(h+"     ");
    		}
    		System.out.println();
    	}
     }
  }

}
  结果：7     7     10     
      13     10     16     
      10     10     5 

 五、多维数组

   多维数组将使用多个下标方问元素。
   如二维数组： int[][] a=new int[m][n];
            int[][] a={{1,1,1},{2,2,2},{3,3,3}};
     三维数组： int[][][] b=new int[x][y][z];
        int[][][] b={{{1,1,1},{2,2,2}},{{3,3,3},{4,4,4}},{{5,5,5},{6,6,6}}};
     四维数组   int[][][][] c=new int[a][b][c][d];

        int[][][][] c={{{{1,1,1},{2,2,2}},{{3,3,3},{4,4,4}},{{5,5,5},{6,6,6}}},

                           {{{1,1,1},{2,2,2}},{{3,3,3},{4,4,4}},{{5,5,5},{6,6,6}}}，

                           {{{1,1,1},{2,2,2}},{{3,3,3},{4,4,4}},{{5,5,5},{6,6,6}}}};

     以此类推就可以定义任意维数数组，维数越多越复杂。