二维数组1：java中的二维数组

Posted 2021-08-27 纵横千里，捭阖四方

​我们在java基础里学过Java是没有二维以上的数组的，数组的第一维的元素指向的堆内存地址又是一个数组，从而实现二维的效果。

详细情况在一般的java教程里都有，我们不做赘述，其基本结构图如下所示：

1. 二维数组的初始化

二维数组的初始化有三种常用方式：

1) int intA[][]={{1,2},{2,3},{3,4,5}};

2) int [][] intB=new int[3][5];

3) int []intC []=new int[3][];
intC[0]=new int[2];
intC[1]=new int[3];
intC[2]=new int[5];

上面第一种在面试时进行算法检验非常有用，因为很多时候代码写完之后有些case能过，有些过不了，这时候需要快速将bad case复制过来测试一下为什么，这种初始化方式无疑是最高效的。

第三种可以定义非常灵活的数组结构，但是建议不要这个干，二维数组不同维度的长度还不一样，这种情况极少。而且这么定义了之后，必须非常小心考虑越界等情况，后面可能自己都忘了。

写个代码测试一下吧：

public static void  testInit(){
       //二维数组不是规则的矩阵
       int [] intA[] ={{1,2},{2,3,4},{3,4,5,6}};

       //打印出来的都是地址

       System.out.println(intA);

       //声明一个二维数组，用于存储3个一维数组，每一个一维数据存多少个数组，不知道 
       int [][]intB=new int[3][];
       intB[0]=new int[3];  
       intB[1]=new int[]{1,2,3,4};  
       intB[2]=new int[2];  
     

       //声明一个二维数组，存储三个一维数组，每个一维数组的长度为4
       int []intC[]=new int[3][4];
       System.out.println(intC);
  }

2. 遍历

遍历方法也有三种：

1) 普通 for 循环

2) 加强 for 循环

3) 普通 for 循环+加强 for 循环

可以看到这三种不是二维数组专属的，而是循环的几种方式，如果将for换成while是不是又有很多种呢？所以我们不必关系有几种遍历的方式，重点是采用哪种循环方式更方便。少废话，直接看代码吧：

public static void search(){
       //二维数组
       int [] intA[] ={{1,2},{2,3,4},{3,4,5,6}};
       //(1)普通for循环
       for(int i=0;i<intA.length;i++){ 
           for(int j=0;j<intA[i].length;j++){ 
               System.out.print(intA[i][j]+"\\t");
          }
           System.out.println();
      }
       //(2)加强for循环
       System.out.println("\\n=========================");

       for(int[] arr:intA){  
           for(int i:arr){ 
               System.out.print(i+"\\t");
          }
           System.out.println();
      }
       //(3)普通与加强for循环的混搭
       System.out.println("\\n-------------------------");
       for(int [] arr:intA){//加强for
           for(int i=0;i<arr.length;i++){
               System.out.print(arr[i]+"\\t");
          }
           System.out.println();
      }
       System.out.println("\\n--------------------------");
       for(int i=0;i<intA.length;i++){
           for(int j:intA[i]){//加强for
               System.out.print(j+"\\t");
          }
           System.out.println();
      }
  }

3. 数组拷贝

数组整体拷贝主要有地址拷贝和值拷贝两种方式。

地址的拷贝
int[]array={11,22,33,44};
int[] arrayB=new int[5];
arrayB=array   //两个数组指向同一内存

值的拷贝
int[]array={11,22,33,44};
int[] arrayB=new int[5];
arrayB[0]=array[0];

System 类中的 arraycopy(…)方法：快速，数组大时用此方法。

public class TestArrayCopy3 {
   public static void main(String[] args) {
       int [] arrA={11,22,33,44};//源数组
       int [] arrB=new int[5];//目标数组

       System.out.println("数组拷贝之前");
       for(int num:arrB){
           System.out.print(num+"\\t");
      }
       //0       0       0       0       0
       //拷贝
       System.arraycopy(arrA, 0, arrB, 1, 2);

       System.out.println("\\n数组拷贝之后");
       for(int num:arrB){
           System.out.print(num+"\\t");
      }
       //0       11       22       0       0
  }
}

对于数组来说，还有一个Arrays的copyOf()方法传回的数组是新的数组对象，改变传回数组中的元素值，不会影响原来的数组。

copyOf()的第二个自变量指定要建立的新数组长度，如果新数组的长度超过原数组的长度，则保留数组默认值，例如：

    public static void arrayTest() {        int[] arr1 = {1, 2, 3, 4, 5};        int[] arr2 = Arrays.copyOf(arr1, 5);        int[] arr3 = Arrays.copyOf(arr1, 10);​        System.out.println("arr2.size: "+arr2.length+" arr3.size: "+arr3.length);​        for (int i = 0; i < arr2.length; i++)            System.out.print(arr2[i] + " ");        System.out.println();        for (int i = 0; i < arr3.length; i++)            System.out.print(arr3[i] + " ");​    }

输出结果为：

arr2.size: 5 arr3.size: 101 2 3 4 5 1 2 3 4 5 0 0 0 0 0 

从上面，可以看到copy()方法也定义了新数组的大小，同事进行了赋值，如果你指定的范围超过原始数据的范围，越界的部分就是空了。

这里我开始以为是将越界的部分设置为0，但是看了一下源代码发现是没有管，因此新创建的数组元素默认值都是0。，代码如下：

    public static int[] copyOf(int[] original, int newLength) {        int[] copy = new int[newLength];        System.arraycopy(original, 0, copy, 0,                         Math.min(original.length, newLength));        return copy;    }

可见，这里底层调用的是System.arraycopy()方法来做的，这个方法是native的，我们不必再继续看了。不过传入的大小很有意思，是从（原始数组的长度，指定的长度）选择最小的向下传，而如果newLength超的元素就是没有管了