JavaSE學習總結（四）二維數組概述/二維數組動態初始化/二維數組靜態初始化/二維數組遍歷/遞歸解決問題的思想

一、二維數組

（一）二維數組概述

二維數組其實就是每一個元素爲一維數組的數組。

（二）二維數組初始化格式

1.動態初始化

1.1 二維數組格式1

數據類型[][] 變量名 = new 數據類型[m][n];
m表示這個二維數組有多少個一維數組 必須寫上
n表示每一個一維數組的元素個數 可選

舉例:
int[][] arr = new int[3][2];
定義了一個二維數組arr
這個二維數組有3個一維數組，名稱是arr[0],arr[1],arr[2]
每個一維數組有2個元素，可以通過arr[m][n]來獲取
表示獲取第m+1個一維數組的第n+1個元素

注意事項
(1)以下格式也可以表示二維數組

• 數據類型 數組名[][] = new 數據類型[m][n];
• 數據類型[] 數組名[] = new 數據類型[m][n];
  這兩種格式不推薦使用

(2)注意下面定義的區別

int x,y;
int[] x,y[];

區別是:
int[] x,y[];
定義了兩個數組 一個是一維數組x 一個是二維數組y

案例演示

public class ArrayDemo {
    public static void main(String[] args) {
        //二維數組：數組中的元素是一維數組，數組嵌套數組
        //動態初始化

        //3 表示這個二維數組裏面，放了3個一維數組
        //2 表示二維數組中的一維數組的長度
        int[][] arr=new int[3][2];
        arr[0]=new int[]{10,20};//爲第一個一維數組賦值
        System.out.println(arr[0]);//二維數組裏第一個一維數組的地址
        System.out.println(arr[1]);//二維數組裏第二個一維數組的地址
        System.out.println(arr[0][0]);//輸出第一個一維數組的第一個元素值
        System.out.println(arr[0][1]);//輸出第一個一維數組的第二個元素值
        System.out.println(arr.length); //二維數組的長度
        System.out.println(arr[0].length);//二維數組中的第一個一維數組的長度
    }
}

內存解析：

  首先，程序編譯好後生成了字節碼文件(.class文件)，JVM將字節碼文件加載進內存的方法區，而main方法是程序的入口，需要被執行，於是調用main方法進棧執行。接着，執行第一句代碼，創建了一個長度爲3的int型二維數組，其每個元素爲長度爲2的一維數組。於是堆內存爲該二維數組開闢空間，並將3個元素都初始化爲null，內存空間地址爲0x12345678(此處隨意寫的一個地址)，然後再初始化3個長度爲2的一維數組，開闢完空間以後將每個一維數組的引用覆蓋掉二維數組的初始值null，於是這個二維數組的每個元素都指向對應的一維數組。再將0x12345678賦給二維數組的引用arr，則名爲arr的這個數組便指向了地址爲0x12345678的空間。main方法執行完畢後，main方法彈棧，此時就沒有引用指向堆內存中地址爲0x12345678的空間了，也就沒有引用指向這三個一維數組了，於是最後垃圾回收器回收了該空間，釋放內存。

1.2 二維數組格式2

數據類型[][] 變量名 = new 數據類型[m][];
m表示這個二維數組有多少個一維數組
這種格式沒有直接給出一維數組的元素個數，可以動態的給出。

舉例：

int[][] arr = new int[3][];
arr[0] = new int[2];//二維數組裏的第一個一維數組長度爲2
arr[1] = new int[3];//二維數組裏的第二個一維數組長度爲3
arr[2] = new int[1];//二維數組裏的第三個一維數組長度爲1

案例演示

public class ArrayDemo2 {
    public static void main(String[] args) {
        int[][] arr=new int[3][];
        System.out.println(arr);//二維數組地址
        System.out.println(arr[0]);//二維數組中第一個元素的值（初值null）
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        arr[0]=new int[3];
        arr[1]=new int[5];
        arr[2]=new int[4];
        System.out.println(arr[0]);//動態賦值後第一個一維數組地址
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

內存解析:

這種格式，沒有直接給出一維數組的元素個數，因此在創建二維數組時只會爲二維數組開闢空間並初始化，不會爲一維數組開闢空間和初始化。

注意事項：數組的長度不宜過長，否則會報堆內存不足的錯誤

public class Demo1 {
    public static void main(String[] args) {
        int[][] arr=new int[999999999][];
    }
}

2.靜態初始化

2.1 二維數組格式3

數據類型[][] 變量名 = new 數據類型[][]{{元素…},{元素…},{元素…}...};

簡化版:
數據類型[][] 變量名 = {{元素…},{元素…},{元素…}};
這個格式屬於靜態初始化:由我們指定具體的元素值,由系統給分配長度

舉例:
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
int[][] arr = {{1,2,3},{5,6},{7}};

案例演示

public class ArrayDemo {
    public static void main(String[] args) {
        //二維數組靜態初始化
        int[][] arr=new int[][]{{2,4},{10,30},{10,30,40},{10,1}};
        System.out.println(arr.length);
        System.out.println(arr[3][1]);
        //簡寫方式
        int[][] arr2 ={{2, 4}, {10, 30}, {10, 30, 40}, {10, 1},{2,5}};
        System.out.println(arr2.length);
        System.out.println(arr2[2][2]);
    }
}

（三）二維數組的遍歷

案例演示
1.

public class ArrayDemo {
    public static void main(String[] args) {
        int[][] arr = {{2, 4}, {10, 30}, {10, 30, 40}, {10, 1}};
        //二維數組的遍歷
        //外循環控制的是二維數組的長度，其實就是一維數組的個數。
		//內循環控制的是一維數組的長度。
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j]);
            }
        }
    }
}

2.公司年銷售額求和
某公司按照季度和月份統計的數據如下：單位(萬元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99

public class ArrayDemo {
    public static void main(String[] args) {
        int[][] arr={{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
        int sum=0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                sum+=arr[i][j];
            }
        }
        System.out.println("公司年銷售額爲："+sum);
    }
}

3.需求：打印楊輝三角形(行數可以鍵盤錄入)
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1

import java.util.Scanner;

public class Demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入一個數字");
        int x = sc.nextInt();
        int[][] a=new int[x][x];
        for(int i=0;i<a.length;i++){//任何一行的第一列和最後一列都是1
            a[i][0]=1;
            a[i][i]=1;
        }
        //從第三行開始，每一個數據是它上一行的前一列和它上一行的本列之和。
        for(int i=2;i<a.length;i++){
            for(int j=1;j<i;j++){//第一列和最後一列已賦值
                a[i][j]=a[i-1][j-1]+a[i-1][j];
            }
        }
        //遍歷二維數組 輸出結果  
        for (int i = 0; i < a.length; i++) {
            for(int j=0;j<=i;j++){
                System.out.print(a[i][j]+" ");
            }
            System.out.println();
        }
    }
}

（四）思考題

看程序寫結果，並畫內存圖解釋

public static void main(String[] args) {
		int a = 10;
		int b = 20;
		System.out.println("a: " + a + ",b: " + b);
		change(a,b);
		System.out.println("a: " + a + ",b: " + b);
		int[] arr = {1,2,3,4,5};
		change(arr);
		System.out.println(arr[1]);
}
public static void change(int a,int b)  {
		System.out.println("a: " + a + ",b: " + b);
		a = b;
		b = a + b;
		System.out.println("a: " + a + ",b: " + b);
}
public static void change(int[] arr){
		for(int x = 0 ; x < arr.length ; x++){
			if(arr[x]%2 == 0){
				arr[x] *= 2;
			}
		}
}

答案

內存解析

首先main方法被調用進棧，然後定義了兩個變量a和b並賦了值。當main方法調用change(int a,int b)方法時，此方法進棧，並執行其中代碼，修改了兩個變量的值，執行完以後便出棧了。返回主方法中繼續執行代碼，此時輸出a和b的值時只能找到主方法中的a和b，因此a和b的值仍然不變。接着創建一個int型數組並賦值，在堆內存中開闢了空間並賦上各元素值，並將該空間的地址賦給數組的引用arr，於是arr便指向該空間的數組。當調用change(int[] arr)時，此方法進棧，並執行其中代碼，修改了數組中兩個元素的值，執行完以後方法彈棧，但堆內存中數據的改動仍然保留，返回主方法繼續執行代碼，找到arr指向地址的數組，找到索引爲1的元素，輸出。
基本數據類型，作爲參數傳遞，形參的改變，不影響實參
引用數據類型，作爲參數傳遞，形參的改變，會影響實參

二、遞歸

（一）遞歸概述

方法定義中調用該方法本身的現象

遞歸注意事項：

• 要有出口，否則就是死遞歸，會造成棧內存溢出
• 遞歸次數不能太多，否則也會造成棧內存溢出

死遞歸：

public class Demo1 {
    public static void main(String[] args) {
        test();
    }
    public static void test(){
        System.out.println("這是一個死遞歸");
        test();
    }
}

遞歸在生活中的舉例:
從前有座山，山裏有座廟，廟裏有個老和尚，老和尚給小和尚在講故事：從前有座山，山裏有座廟…

（二）遞歸解決問題的思想

遞歸解決問題的思想即“拆分合並”
也就是將一個大問題拆分成一個個小問題，解決完小問題後再合併，便解決了大問題。

案例演示

1.求5的階乘

方法1：利用循環

public class MyTest {
    public static void main(String[] args) {
        //問題求 5的階乘  5！=5*4*3*2*1；
        //循環做
        int r=1;
        for (int i = 1; i <= 5; i++) {
            r*=i;
        }
        System.out.println("結果是"+r);
    }
}

方法2：利用遞歸

public class MyTest {
    public static void main(String[] args) {
        //求 5的階乘
        //用遞歸來做
       int r= jieCheng(5);
        System.out.println("結果是"+r);

    }
    public static int jieCheng(int i) {
        if(i==1){
            return 1;
        }else{
            return i*jieCheng(i-1);
        }
    }
}

遞歸和循環的區別和聯繫

遞歸算法：
優點：代碼簡潔、清晰，並且容易驗證正確性。
缺點：它的運行需要較多次數的方法調用，如果調用層數比較深，會對執行效率有一定影響。並且調用次數過多會出現堆內存溢出的現象。

循環算法：
優點：速度快，結構簡單。
缺點：並不能解決所有的問題。

用循環能實現的，遞歸一般可以實現，但是能用遞歸實現的，循環不一定能。

2.兔子問題(斐波那契數列)
題目：有一對兔子，從出生後第3個月起每個月都生一對兔子，小兔子長到第三個月後每個月又生一對兔子，假如兔子都不死，問第二十個月的兔子對數爲多少？

分析：由此可見兔子對象每個月的對數分別是：1 , 1 , 2 , 3 , 5 , 8, 13 …
從中找到規律：前兩個數都是1，從第三個數開始，這個數等於前兩個數之和 （斐波那契數列）

方法1：

public class MyTest {
    public static void main(String[] args) {
		//採用數組方法來做，到第20個月有多少對兔子
        int[] arr=new int[20];
        arr[0]=1;
        arr[1]=1;
        for (int i =2; i < arr.length; i++) {
            arr[i]=arr[i-1]+arr[i-2];
        }
        System.out.println("兔子的對數"+arr[19]);
    }
}

方法2：遞歸

public class MyTest2 {
    public static void main(String[] args) {
        //遞歸來做
        int sum = sumRabbit(20);
        System.out.println("兔子的對數" + sum);
    }
    public static int sumRabbit(int i) {
        if (i == 1 || i == 2) {
            return 1;
        } else {
            return sumRabbit(i - 1) + sumRabbit(i - 2);
        }
    }
}