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));
    }
}