Java数组之二维数组

Java中除了一维数组外，还有二维数组，三维数组等多维数组。本文以介绍二维数组来了解多维数组。

1.二维数组的基础

二维数组的定义：二维数组就是数组的数组，数组里的元素也是数组。

二维数组表示行列二维结构

2.二维数组的声明

二维数组有三种声明方式。

2.1.根据二维数组的定义

 import java.util.Arrays;
 public class Test05{
     public static void main(String[] args){
         //根据二维数组的定义
         //二维数组
         //int[] arr;
         //(int[])[]arr;

         //声明
         int[][] arr;
         //初始化一个能存三个一维数组的二维数组
         arr = new int[3][];
         //赋值
         int[] arr1 = {3,4,5,7};
         int[] arr2 = {3,4,6};
         int[] arr3 = {3,4,7,8};

         arr[0] = arr1;
         arr[1] = arr2;
         arr[2] = arr3;

         System.out.print(arr);
         System.out.println(Arrays.toString(arr));
     }
 }

此时arr = new int[3][];只分配了二维数组的空间，一维数组没有分配空间。

2.2.声明一个规则的二维数组

 import java.util.Arrays;
 public class Test06{
     public static void main(String[] args){
         //声明一个规则的二维数组，3行4列
         int[][] arr = new int[3][4];
         arr[0][0]=10;
         arr[0][1]=10;
         arr[0][2]=10;
         arr[0][3]=10;

         arr[1][0]=10;
         arr[1][1]=10;
         arr[1][2]=10;
         arr[1][3]=10;

         arr[2][0]=10;
         arr[2][1]=10;
         arr[2][2]=10;
         arr[2][3]=10;

         System.out.println(Arrays.toString(arr));
     }
 }

此时，二维数组已经分配好空间，同时一维也分配好空间。

2.3.当已知二维数组元素的数值，可以考虑字面量声明

 import java.util.Arrays;
 public class Test02{
     public static void main(String[] args){
         //已知数组元素，二维数组的声明方式
         int[][] arr ={
             {10,20,30,40},
             {100,200,300},
             {1000,2000,3000,4000}
         };
         System.out.println(Arrays.toString(arr));
     }
 }

3.二维数组的遍历

 import java.util.Arrays;
 public class Test02{
     public static void main(String[] args){
         //已知数组元素，二维数组的声明方式
         int[][] arr ={
             {10,20,30,40},
             {100,200,300},
             {1000,2000,3000,4000}
         };
         //遍历二维数组
         for(int i = 0;i<arr.length;i++){          //行数遍历二维数组
             for(int j = 0;j<arr[i].length;j++){   //列的元素
                 System.out.print(arr[i][j] + "\t");
             }
             System.out.println();
         }
     }
 }

总结：

二维数组是行列结构，使用双层for循环，外层for用于控制行，内层for用于控制列=>行列结构 => 双层for遍历。

以上，我们就了解完二维数组的基本知识了。

此外，在学习数组知识的时候有一些细节是需要我们注意的，就是基本数据类型和引用数据类型赋值的区别。接下来我们通过一些小练习来讲解一下基本数据类型和引用数据类型赋值的区别。

4.基本数据类型和引用数据类型赋值的区别

 import java.util.Arrays;
 public class Test09{
     public static void main(String[] args){

         // 基本数据类型的赋值
         int a = 10;
         int b;
         b = a;
         // a? b?
         b = 20;
         // a? b?

         // 引用数据类型的赋值
         int[] arr = {1,3,5};
         int[] arr2 = arr;
         arr2[0] = 100;

         System.out.println("arr:"+arr);
         System.out.println("arr2:"+arr2);
         System.out.println("arr[0]:"+arr[0]);
     }
 }

通过图解来加深理解。

总结:

基本数据类型赋值时，复制的是值

引用数据类型赋值时，复制的是引用。

 5.Arrays类

在上面，我们运用了Array类，关于Array类我们也来讲解一下关于Array类的用法。

jdk中为了便于开发，给开发者提供了Arrays类，其中包含了很多数组的常用操作。例如快速输出、排序、查找等。

 5.1常用用法

 import java.util.Arrays;
 public class Test00{
     public static void main(String[] args){
         //Arrays类的常用方法
         int[] arr = {4,3,7,8};
         //【1】数组的字符串形式
         String str = Arrays.toString(arr);
         System.out.println(str);

         //【2】sort对数组进行排序（只能是升序）->内部使用快速排序
         Arrays.sort(arr);
         System.out.println(Arrays.toString(arr));

         /*【3】fill 填充数组 Arrays.fill(arr,fromIndex，toIndex，填充的值);
         *toIndex:结束下标不包含，(含头不含尾)
         */
         //Arrays.fill(arr,0,4,2);
         //System.out.println(Arrays.toString(arr));

         //【4】equals(arr1,arr2)判断两个数组是否相等。
         //数组相等的条件是：a.长度相等 b.两个数组对应位置的元素相等
         int[] arr3 = {3,4,7,8};
         System.out.println(Arrays.equals(arr,arr3));
     }
 }

5.2.二分法查找

 import java.util.Arrays;
 public class Test03{
     public static void main(String[] args){
         //二分法查找，二分法查找必须是有序的数组，如果找到返回索引；
         //源码
         /*private static int binarySearch0(long[] a, int fromIndex, int toIndex,
                                      long key) {
         int low = fromIndex;
         int high = toIndex - 1;

         while (low <= high) {
             int mid = (low + high) >>> 1; //除2
             long midVal = a[mid];

             if (midVal < key)
                 low = mid + 1;
             else if (midVal > key)
                 high = mid - 1;
             else
                 return mid; // key found
         }
         return -(low + 1);  // key not found.  low为插入点，即Key应该放在数组中的位置
         }
         */

         /*二分法查找数组的元素(有序的数组)，返回的是元素的下标，binarySearch(arr,fromIndex,toIndex,key)
         *a - 要搜索的数组
             key - 要搜索的值
         */
         int[] arr = {1,2,4,5,7,8};
         int a = Arrays.binarySearch(arr,4);//找4的索引
         System.out.println("要找的值的位置为："+a);
     }
 }

5.3数组的复制

 import java.util.Arrays;
 public class Test01{
     public static void main(String[] args){
         //数组的复制
         int[] arr = {1,3,4,6,8};
         int[] newArr = Arrays.copyOf(arr,5);//复制到一个新数组
         System.out.println(Arrays.toString(newArr));

         //copyOfRange(arr,from,to) from:开始的位置(包含) to:目标位置(不包含) 含头不含尾

         int[] newArr2 = Arrays.copyOfRange(arr,1,3);
         System.out.println(Arrays.toString(newArr2));

         //其中System也提供了赋值数组的方法。
         //arraycopy(object str,int srcPos,object dest,int destPos,int length)
         /*
         *arraycopy(srcArr,srcPos,destArr,destPos,len)
             srcArr:要复制的源数组
             srcPos:从srcArr的srcPos位置开始复制
             destArr:复制到的目标数组
             destPos:目标数组从destPos开始存放
             len:从源数组中复制len个长度
         */
         int[] arr2 = new int[arr.length];
         System.arraycopy(arr,1,arr2,0,4);
         System.out.println(Arrays.toString(arr2));
     }
 }