這裡主要寫一些二維陣列的簡單總結，我對二維陣列的理解是：“數組裡面套陣列”；對比一下一維陣列，一維陣列中的元素是基本型別的數值或者是引用，那麼二維陣列的元素即為一維陣列，也就是陣列中套陣列。

      這裡主要分為兩部分來說，1.基本型別的二維陣列；2.引用型別的二維陣列；其中，在內部會使用for迴圈和foreach迴圈進行遍歷。廢話不多說，直接上程式碼。

     1.基本型別的二維陣列

package com.google.array.array06;

/**
 * 基本型別多維陣列的使用
 * 1.靜態初始化
 * 2.動態初始化
 */
public class BaseTypeTwoDimensionArray {

    public static void main(String[] args){

        /**
         *   arr[0][0]=1
             arr[0][1]=2
             arr[0][2]=3
             arr[1][0]=4
             arr[1][1]=5
             arr[1][2]=6
             arr[1][3]=7
             arr[2][0]=8
             arr[2][1]=9
             arr[2][2]=10
             arr[2][3]=11
             arr[2][4]=12
         */
        dynamicInit();


        //1	 2	3	4	5	6	7	8	9	10	11	12
        staticInt();
    }

    /**
     * 動態初始化基本型別的多維陣列：
     */
    public static void dynamicInit(){
        int[] a1={1,2,3};
        int[] a2={4,5,6,7};
        int[] a3={8,9,10,11,12};

        /**
         * 我們要建立的陣列的形式是：{{1,2,3},{4,5,6,7},{8,9,10,11,12}},即為{a1,a2,a3}
         * 抽象出模型結構是：{{},{},{}}；
         * 根據下方的定義：new int[3][]中的3指的是外層的"{}"內部有多少個"{}",易知，有a1,a2,a3這三個，所以是new int[3][],
         * 至於[3]後面跟著的[]這個指的是a1,a2,a3中的元素的個數，由於a1,a2,a3中的元素個數不一致，所以[]內部不用填，若是填了，
         * 則a1,a2,a3的元素個數必須保持一致；
         */
        int[][] arr = new int[3][];

        //給多維陣列賦值：即為數組裡面套陣列
        arr[0]=a1;
        arr[1]=a2;
        arr[2]=a3;
        //arr[3]=a3; //這樣同樣會出現數組索引越界異常

        //呼叫方法，遍歷陣列：
        print01(arr);
    }

    /**
     * 靜態初始化基本型別的陣列：
     */
    public static void staticInt(){
        int[][] arr={{1,2,3},{4,5,6,7},{8,9,10,11,12}};
        print02(arr);
    }

    /**
     * 使用普通的for迴圈遍歷：
     * 注意：arr.length和arr[i].length的寫法：
     * @param arr
     */
    public static void print01(int[][] arr){
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<arr[i].length;j++){
                System.out.println("arr["+i+"]["+j+"]="+arr[i][j]);
            }
        }
    }

    /**
     * 使用foreach迴圈遍歷陣列：
     * @param arr
     */
    public static void print02(int[][] arr){

        for(int[] arr01:arr){
            for(int a:arr01){
                System.out.print(a+"\t");
            }
        }
    }
}
 

2.引用型別的二維陣列：

package com.google.array.array06;

public class Student {

    private String name;
    private int age;

    public Student(){}

    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
 

package com.google.array.array06;

/**
 * 引用型別多維陣列的使用：
 */
public class RefTypeTwoDimensionArray {

    public static void main(String[] args){
        /**
         * studnt[0][0]=Student{name='琴酒', age=13}
           studnt[1][0]=Student{name='雪莉', age=14}
           studnt[1][1]=Student{name='朗姆', age=15}
         */
        dynamicInit();

        /**
         * Student{name='琴酒', age=13}
           Student{name='雪莉', age=14}
           Student{name='朗姆', age=15}
         */
        staticInt();
    }

    /**
     * 動態初始化引用型別的多維陣列：
     */
    public static void dynamicInit(){
        Student[] s1 = {new Student("琴酒",13)};
        Student[] s2 = {new Student("雪莉",14),new Student("朗姆",15)};

        //建立一個二維陣列物件：
        Student[][] student = new Student[2][];

        //給二位陣列賦值：
        student[0]=s1;
        student[1]=s2;

        //迴圈遍歷陣列:
        print01(student);
    }

    /**
     * 靜態初始化引用型別的陣列：
     */
    public static void staticInt(){
        Student[][] student = {{new Student("琴酒",13)},{new Student("雪莉",14),new Student("朗姆",15)}};
        print02(student);
    }

    /**
     * 使用for迴圈遍歷：
     */
    public static void print01(Student[][] student){
        for(int i=0;i<student.length;i++){
            for(int j=0;j<student[i].length;j++){
                System.out.println("student["+i+"]["+j+"]="+student[i][j]);
            }
        }
    }


    /**
     * 使用foreach迴圈遍歷陣列
     */
    public static void print02(Student[][] student){
        for(Student[] s1:student){
            for(Student s2:s1){
                System.out.println(s2);
            }
        }
    }
}