第81節：Java中的陣列

第81節：Java中的陣列

本節介紹陣列的基本概念，資料就是一種資料結構，可以用來儲存多個資料，每個陣列中可以存放相同型別的資料。比如，在學校，我們是一個班，這裡的班級中每個同學都是這個班級陣列中的元素，都是同樣的型別為學生，對應的學號就是我們的索引，但是在現實中的學號一般都是從1開始的，而在Java中的陣列索引是從0開始的。

定義一個陣列為方括([])，通過陣列元素的索引(或下標，角標)來訪問陣列中的元素，同時可以為陣列賦值和取出陣列的元素值。

問: 在Java中為什麼要有陣列呢?
答: 陣列就是一個容器，是用來儲存同種資料型別的多個值。

陣列的概念

同一種型別的資料的集合，用來裝資料的，陣列就是一個容器。在Java中陣列的好處就是可以用陣列中的元素從0開始編號，可以利用下標(索引)，對齊進行操作，即方便又快捷。

在Java中的陣列是用儲存同種陣列的元素，其指的是資料型別要相同，在陣列中存放的資料型別是唯一的，只能儲存一種資料型別，不能儲存多種資料型別。陣列可以儲存基本資料型別，也可以儲存引用資料型別。

陣列的定義格式：

一般陣列的定義為：

int[] array; 或 int array[];

這兩種定義的語法通常都可以用，但是建議是使用 int[] array 這種語法，因為大多數程式設計師常用，這種語法定義更具有可讀性。

格式1：

資料型別[] 陣列名 = new 陣列型別[元素個數或者陣列的長度];

例如：

int[] arr = new int[5];

格式2：

元素型別[] 陣列名 = new 元素型別[]{元素1，元素2，。。。};

例如：

int[] arr = new int[]{1，2，3，4};

int[] arr = {2，3，4，5};

陣列的定義方式：

陣列的表示：[]，通過關鍵字new來建立陣列

一個陣列一旦初始化建立，那麼陣列就會在記憶體中有一塊空間被固定下來，那麼這塊空間就是這個陣列的，不可變，即陣列的長度將不可改變。就算把這個陣列中的陣列清空，在記憶體中還是這塊空間被儲存下來。比如，一家酒店我們把它定義一個陣列，那麼每個房間就是這家就是的長度，這家酒店我們就把它當做是我們在記憶體中開闢的一塊固定下來的空間，每個房間中入住的人就是這塊空間，也就是陣列的元素，房間號碼我們可以當做的陣列的索引，通過房間號找到相應的入住者。當這家酒店中的每個元素即是客人都走時，這家酒店中的房間依然保留著，依然還是酒店，所以依然還是陣列了。陣列中的長度即酒店中的房間還是這個數量（長度）。

陣列程式碼示例：

package com。dashucoding;
public class DemoArray {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 資料型別[] 陣列名=new 資料型別[陣列的長度];
        int[] arr = new int[5];
        /*
         * int: 代表資料型別
         * []: 代表陣列
         * arr: 合法的識別符號
         * 
         * new: 建立新的實體或物件
         * int: 資料型別
         * []: 代表的陣列
         * 5: 代表陣列的長度
        */
    }

}

陣列的索引

例如：

int[] arr = new int[3];

陣列可以儲存多個資料，並且會對陣列進行編號，從0開始操作元素，可以通過編號（索引，角標，下標）找到該元素。程式碼中會在記憶體空間中開闢3個空間，如三個房子編號，從0開始，第二個房子為1，第三個房子為2。這只是一種比如，我們把它看作三個空間，對應的三個地址編號而已，通過地址是不是就可以找到房子了呢！

陣列也是一種資料型別，為引用型別，如int為一種基本資料型別，那麼int[]這是一種屬於int陣列的一種引用型別，所以int[]是一種資料型別，建立int[]型別的物件為建立陣列。

什麼是陣列的初始化？

就是為陣列開闢連續的記憶體空間，併為每個資料元素賦予值。

只要陣列進行分配，就具有初始化值，陣列變數一旦在記憶體空間分配了區域，就會在每個空間裡儲存陣列的初始化值，就算記憶體空間為空，也會有一個初始化的值為null，這裡的值會根據變數型別來給定初始化值，初始化值可以有系統進行自動分配，如果我們不給定值的話，另一種就是由我們程式設計師給定初始化值。

如何對陣列進行初始化？

動態初始化就是程式設計師指定陣列的長度，有系統進行陣列元素的分配初始值。

例如： int[] arr = new int[5];

格式如下：

arrayName = new type[length];

使用動態初始化過程如下：

int[] array = new int[5];

靜態初始化就是程式設計師給定初始化值，然後由系統進行決定長度。

靜態初始化的語法格式：

array = new type[]{元素1，元素2，元素3，。。。};

定義一個int陣列型別的變數：

int[] intArray;

靜態初始化，給定陣列元素的初始化值，不給定陣列長度，由系統決定陣列長度：

intArray = new int[]{2，3，4，5，6}; 或 intArray = {2，3，4，5，6};

在程式設計師的通常寫法中，陣列的定義和陣列進行初始化都是同時完成如：

int[] a = {1，2，3，4};

程式碼案例：

package com。dashucoding;
public class DemoArray {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 資料型別[] 陣列名 = new 資料型別[陣列長度];
        int[] arr = new int[5]; // 動態初始化，在記憶體中開闢連續的5塊空間
        System。out。println(arr[0]); // 系統會給出預設的初始化值
        // 整數型別都為0
        arr[0] = 12;
        System。out。println(arr[0]);
    }

}

結果：

結果在記憶體中開闢連續的5塊空間，在記憶體中進行儲存，這5塊空間有自己的地址，用於方便去找到，可以通過地址先找到該陣列，如找一棟樓，需要地址，然後找陣列中的元素，如每個房間，通過編號找到每個元素。

案例：

System。out。println(arr);// 列印結果
[I@7852e922// 16進位制的表現形式// [ 代表陣列// I 代表是int型別// @ 固定的// 7852e922 代表16進位制的地址值

在Java中執行程式會進行劃分空間進行執行程式：五塊記憶體空間

1.棧：用來儲存區域性變數的
2.堆：儲存new出來的陣列或物件
3.方法區：物件導向
4.本地方法區：和系統相關
5.暫存器：供給CPU使用（不需要了解）

區域性變數是定義在方法宣告上或方法中的變數，在棧記憶體中，儲存的都是區域性變數，只要在方法中定義的變數都是區域性變數，一旦變數的生命週期結束該變數就會被釋放，用完就會被刪掉了。

堆記憶體，儲存的都是實體，就是物件，凡是用new 建立的都是在堆裡面。

new，一個new指在記憶體中進行開闢空間，在堆記憶體中每個實體都是一個首地址值，堆記憶體的變數都是有預設的初始化值的，不同型別都不一樣，當實體不在使用時，堆中的變數不會馬上刪除，會由Java系統中的垃圾回收機制進行回收（Java中有個垃圾回收機制，自動回收垃圾）

陣列地址，例如：0x0011，可以通過索引找到每個值，系統會給初始化值。

整數型別：

byte， short， int， long 的預設初始化值都為0

浮點型別：

float， double 的預設初始化值都為0。0

布林型別：

boolean的預設初始化值為false

字元型別：

char預設初始化值為 “u0000”，char在記憶體中是佔兩個位元組，是16個二進位制位。u0000每個0代表16進位制的0，那麼四個0就是代表16個二進位制位。

一個位元組代表8個二進位制位，那麼兩個位元組，就代表16個二進位制位。`u0000`每個0代表16進位制的0，那麼四個0就是代表16個二進位制位。

char在記憶體中佔兩個位元組

代表16個二進位制位， 兩個位元組代表16個二進位制位。
一個位元組代表8個二進位制位，那麼兩個位元組就代表16個二進位制位。

u0000:
每個0代表16進位制的0，那麼四個0就代表16個二進位制位。
兩個位元組就代表16個二進位制位，那麼四個0代表16個二進位制位。

char:就代表16個二進位制位。
u0000`:就代表16個二進位制位 = 四個0就代表16個二進位制位。
每個0就代表16個進位制的二進位制數。1個0就代表4位，16進位制是4位代表一位的，4個就代表16個二進位制數。

16個二進位制位: 0000
一個就代表4個二進位制位，那麼4個就代表16個二進位制位。

陣列元素如果是引用資料型別為類，介面和陣列，那麼陣列元素的初始化值是null。

注意：靜態初始化和動態初始化不能同時用，不要在進行陣列初始化值是，既要分配陣列元素初始化值，還要給定陣列的長度，千萬不要，知道嗎！

槍

槍中的彈夾，子彈是一顆一顆地壓進去的，第一顆壓進的子彈是最後打出來的，最後一顆的子彈先發射出來。所以java中的方法就想彈夾一樣，而主方法，是先進入記憶體的，虛擬機器呼叫主方法，程式執行起來，首先進入記憶體的，進入棧的，是主方法。

主方法就像子彈一樣，放入到棧低，壓進棧，壓棧。主方法直接壓入棧底，執行完之後會彈出去，就叫彈棧。棧是先進後出。主方法壓進棧。方法裡的區域性變數，型別為陣列型別。

程式碼案例：

package com。dashucoding;
public class DemoArray {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // int x = 12; // x就是區域性變數
        int[] arr = new int=[3]; 
        // 動態初始化，建立3塊連續的空間
        // 方法裡的區域性變數
    }
}

在棧中存放主方法，主方法內有區域性變數，這個區域性變數為陣列型別:

int[] arr;

然後在堆中是陣列型別new出來的值。

記憶體分析案例：

程式碼案例：

package com.dashucoding;
public class DemoArray {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // int x = 12; // x就是區域性變數
        int[] arr = new int[3]; 
        // 動態初始化，建立3塊連續的空間
        // 方法裡的區域性變數
        arr[0] = 10;
        arr[1] = 20;
        System.out.println(arr[0]);
        System.out.println(arr[1]);
    }
}

製作記憶體圖：

地址值是賦予給arr，只是通過地址找到實體的。

程式碼案例：

package com.dashucoding;
public class DemoArray {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] arr1 = new int[3]; // 建立陣列長度為3
        int[] arr2 = new int[3];
        
        System.out.println(arr1); // 列印陣列的地址值
        System.out.println(arr2);
        
        arr1[0] = 10; // 給第一個陣列中的第一個元素賦值
        arr2[1] = 20; // 給第二個陣列中的第二個元素賦值
        
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
        
        System.out.println("-----------");
        
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
    }
}

製作記憶體圖：

程式碼案例：

package com.dashucoding;
public class DemoArray {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] arr1 = new int[3];
        int[] arr2 = new int[5];
        int[] arr3 = arr2;
        
        System.out.println(arr1);
        System.out.println(arr2);
        System.out.println(arr3);
        
        arr1[0] = 10;
        arr1[1] = 20;
        
        arr2[1] = 30;
         
        arr3[1] = 40;
        arr3[2] = 50;
        
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
        System.out.println("--------------");
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
        System.out.println(arr2[3]);
        System.out.println(arr2[4]);
        System.out.println("--------------");
        System.out.println(arr3[0]);
        System.out.println(arr3[1]);
        System.out.println(arr3[2]);
        System.out.println(arr3[3]);
        System.out.println(arr3[4]);
    }
}

結果：

製作記憶體圖：

程式碼案例：

package com.dashucoding;
public class DemoArray {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 資料型別[] 陣列名=new 資料型別[]{元素1，元素2，...};
        // int[] arr = new int[] {1，23，45，67，28};
        // int[] arr2 = {2，35，6，12}; // 靜態初始化的簡寫形式
        
        // int[] arr; //宣告陣列引用
        // arr = new int[] {11，22，33，44}; // 可以不同行
        
        // int [] arr2;
        // arr2 = {23，43，55}; // 簡寫形式宣告和賦值必須在同一行
        
        // int[] arr = new int[3]{23，22，1}; //會報錯，不允許動靜結合
        // 應該寫成 int[] arr = new int[3]; 為動態初始化
        // int[] arr = new int[]{23，44，2}; 為靜態初始化
        
    }
}
package com.dashucoding;
public class DemoArray {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 資料型別[] 陣列名=new 資料型別[]{元素1，元素2，...};
        // int[] arr = new int[] {1，23，45，67，28};
        // int[] arr2 = {2，35，6，12}; // 靜態初始化的簡寫形式
        
        int[] arr = {12，23，34};
        System.out.println(arr);
        System.out.println(arr[0]);
    }
}

製作記憶體圖：

陣列中的異常問題：

程式設計師寫程式不能保證自己寫的程式碼是正確的，總會出現一些錯誤，這時我們要學會調式這些程式碼程式保證可以正常的執行。

陣列索引越界異常
ArrayIndexOutOfBoundsException，指你訪問的索引不存在。

int arr = {1，34，234};
System.out.println(arr[23]);

空指標異常
NullPointerException，指陣列已經不在指向堆記憶體了，而你還用陣列名去訪問元素。

int[] arr = {1，2，3};
arr = null;
System.out.println(arr[0]);
package com.dashucoding;
public class DemoArray {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] arr = new int[5];
        System.out.println(arr[5]); // 當訪問陣列中不存在的索引，就會出現索引越界異常.
    }
}

結果圖：

當訪問陣列中不存在的索引的時候就會導致陣列越界異常。

同理

System.out.println(arr[-1]); 同樣導致陣列越界異常。

程式碼案例：

package com.dashucoding;
public class DemoArray {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] arr = new int[5];
        // System.out.println(arr[5]);
        arr = null;
        System.out.println(arr[0]); // 當陣列引用賦值為null，在去呼叫陣列中的元素就會出現空指標異常.
    }
}

結果圖片：

陣列的遍歷：

迴圈陣列中的每個陣列元素。

使用foreach迴圈，這種迴圈遍歷陣列是非常方便的，foreach迴圈的格式如下：

for (type variableName : array ){
 // 訪問每個元素
}

程式碼案例：

public class ForeachTest {
 public static void main(String[] args){
  String[] names = { “dashu”, “dashucoding”};
  // 使用foreach迴圈遍歷陣列中的每個元素
  for(String name : names){
   System.out.println(name);
  }
 }
}

程式碼案例：

package com.dashucoding;/*
 *  陣列的遍歷：依次輸出陣列中的每個元素
 *  陣列的屬性：arr.length陣列的長度
 *  陣列的最大索引：arr.length-1;
 * */public class DemoArray {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] arr = {11，22，33，44，55};
        /*      System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println(arr[4]);*/
        
        for(int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        
        System.out.println("---------");
        
        // arr.length 代表陣列的長度
        System.out.println(arr.length);
        
        System.out.println("---------");
        
        int[] arr2 = {1，2，3};
        print(arr2);
    }

    /*
     * 遍歷陣列的方法
     * 返回值型別為void
     * 引數列表int[] arr
     * */
    private static void print(int[] arr) {
        // TODO Auto-generated method stub
        for(int i = 0;i<arr.length;i++) {
            System.out.println(arr[i]);
        }
    }

}

結果圖片：

最大值

程式碼案例：

package com.dashucoding;/*
 * 陣列
 * 如何獲取陣列的最大值
 * */public class DemoArray {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] arr = {23，34，12，33};
        int max = getMax(arr);
        System.out.println(max);
    }
    
    /*
     * 獲取陣列最大值
     * 返回值型別為int
     * 引數列表為int[] arr
     * */
    public static int getMax(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) { // 從陣列的第二個元素開始遍歷
            if(max < arr[i]) { // 如果max記錄的值小於陣列中的元素，就max記錄記錄最大的
                max = arr[i];
            }
        }
        return max;
    }
}

結果圖：

分析製圖：

陣列的操作反轉：

操作反轉，就是前後倒置

package com.dashucoding;/*
 * 陣列
 * 如何獲取陣列的最大值
 * */public class DemoArray {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] arr = {22，33，44，55};
        reverseArray(arr);
        print(arr);
    }
        /*
         * 陣列元素的反轉
         * 返回值型別void
         * 明確引數列表int[] arr
         * */
    public static void reverseArray(int[] arr) {
        for(int i=0; i < arr.length / 2; i++) {
            // arr[0] 第一個 和 arr[arr.length-1-0] 最後一個 交換
            // arr[1] 和 arr[arr.length-1-1] 交換
            // arr[2] 和 arr[arr.length-1-2] 交換
            // ...
            
            /*int temp = arr[0];
            arr[0] = arr[arr.length-1];
            arr[arr.length-1] = temp;*/
            
            int temp = arr[i];
            arr[i] = arr[arr.length-1-i];
            arr[arr.length-1-i] = temp;
            
        }
    }
    
    /*
     * 陣列遍歷
     * 明確返回值型別void
     * 明確引數列表int[] arr
     * */
    public static void print(int[] arr) {
        for(int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

結果圖片：

根據鍵盤錄入索引，查詢對應的星期：

程式碼案例：

package com.dashucoding;
import java.util.Scanner;
/*
 * 陣列
 * 如何進行陣列查表（根據鍵盤錄入索引，查詢對應的星期)
 * */public class DemoArray {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("星期" + getWeek(2));
        
        System.out.println("----------");
        
        // 鍵盤錄入
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入對應的星期範圍，對應1至7");
        int week = sc.nextInt();
        System.out.println("星期" + getWeek(week));
    }
    
    /*
     * 根據索引返回對應的星期
     * 返回值的型別char
     * 能儲存中文的char
     * 引數列表int week
     * 通過索引獲取陣列中的元素
     * */
    public static char getWeek(int week) {
        char[] arr = {` `，`一`，`二`，`三`，`四`，`五`，`六`，`日`}; // 定義一張星期表
        return arr[week]; // 通過索引獲取陣列中的元素
    }
}

陣列元素查詢：

package com.dashucoding;
import java.util.Scanner;
/*
 * 陣列
 * 陣列元素查詢
 * 查詢指定元素第一次在陣列中出現的索引
 * */public class DemoArray {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] arr = {11，22，33，44，55};
        int index = getIndex(arr，22);
        System.out.println(index);
        
        System.out.println("----------");
        
        int index2 = getIndex(arr，10);
        System.out.println(index2);
    }
    
    /*
     * 查詢元素索引
     * 返回值型別int
     * 引數列表int[] arr， 要查詢的值int value
     * */
    public static int getIndex(int[] arr， int value) {
        for(int i = 0; i < arr.length; i++) { // 陣列的遍歷
            if(arr[i] == value) { // 如果陣列中的元素與查詢元素匹配，就是這個元素
                return i; // 返回索引
            }
        }
        // 如果沒有查到，沒找到返回給你一個-1，如果返回值為-1，就知道沒在陣列中找到
        return -1;
    }
}

結果圖片：

二維陣列的格式：

int[][] arr = new int[3][2];

表示二維陣列的格式:

資料型別 陣列名[][] = new 資料型別[m][n];
資料型別[] 陣列名[] = new 資料型別[m][n];

// 建議這麼寫
int[][] arr = new int[3][2];
// 一維陣列
int[] x; // 二維陣列int[] x，y[];int[] y[];

二維陣列案例:

package com.dashucoding;
public class DemoArray {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /*
         * 二維陣列
         * 二維陣列中有3個一維陣列
         * 每個一維陣列中有2個元素
         * */
        int[][] arr = new int[3][2];
        // 列印二維陣列
        System.out.println(arr);
        // 列印二維陣列中的第一個一維陣列
        System.out.println(arr[0]);
        // 列印二維陣列中的第一個一維陣列的第一個元素
        System.out.println(arr[0][0]);
        
        // 列印結果
        /*
         * [[I@7852e922 // 二維陣列的地制值
         * [I@4e25154f // 一維陣列的地址值
         * 0 // 元素值
         * */ 
    }
}

結果圖片：

二維陣列：

package com.dashucoding;
import java.util.Scanner;
public class DemoArray {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[][] arr = new int[3][2];
        
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[0][0]);
    }
}

記憶體分析：

程式碼案例：

package com.dashucoding;
public class DemoArray {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 二維陣列，二維陣列中有3個一維陣列，三個一維陣列都沒有被賦值
        int[][] arr = new int[3][];
        // 列印二維陣列中的三個一維陣列
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        
        arr[0] = new int[3]; // 第一個一維陣列中儲存三個int值
        arr[1] = new int[5]; // 第二個一維陣列中儲存五個int值
        
        System.out.println("-----");
        
        // 列印二維陣列中的三個一維陣列
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

結果圖片：

程式碼案例：

package com.dashucoding;
public class DemoArray {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 二維陣列，二維陣列中有3個一維陣列，三個一維陣列都沒有被賦值
        int[][] arr = new int[3][];
        // 列印二維陣列中的三個一維陣列
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

分析記憶體圖：

二維陣列格式：

int[][] arr = { {1，2，3}， {4，5}， {6，7，8，9} };

程式碼案例：

package com.dashucoding;
public class DemoArray {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 二維陣列
        int[][] arr = { {1，2，3}， {4，5}， {6，7，8，9} };
        System.out.println(arr); //二維陣列的地址值
        System.out.println(arr[0]); //一維陣列的地址值
        System.out.println(arr[0][0]); //元素
    }
}

結果圖：

記憶體分析圖：

二維資料的遍歷：

package com.dashucoding;
public class DemoArray {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 二維陣列的遍歷
        int[][] arr = { {1，2，3}， {4，5}， {6，7，8，9} };
        for(int i = 0; i < arr.length; i++) {
            // 獲取每個二維陣列中的一維陣列
            // 獲取一維陣列中的元素
            for(int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

結果圖：

二維陣列的求和：

package com.dashucoding;
public class DemoArray {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 二維陣列求和
        int[][] arr = { {1，2，3}， {4，5，6}， {7，8，9} };
        int sum = 0;
        for(int i = 0; i < arr.length; i++) {
            // 獲取每個一維陣列
            for(int j = 0; j < arr[i].length; j++) {
                //獲取每個一維陣列
                sum = sum + arr[i][j];
            }
        }
        System.out.println(sum);
    }
}

結果圖：

基本資料型別的值傳遞，不會改變原值，因為呼叫後會彈棧，區域性變數就會隨之消失，而引用資料型別的值傳遞，會改變原值，因為使用方法彈棧，但是堆記憶體陣列物件還在，可以通過地址繼承訪問。

陣列的綜合應用

程式碼案例：

// 列印陣列public static void printArray(int[] arr){
 for(int x=0;x<arr.length;x++)
 {
    if(x!=arr.length-1){
     System.out.print(arr[x]+",");
    }else{
     System.out.print(arr[x]);
    }
  }
}

陣列轉字串：

// 陣列轉換成為字串// 結果返還為字串，引數為陣列public static String toString (int[] arr){
 // 定義字串變數
 String temp = "[";
 for(int x = 0; x<arr.length; x++){
  // 判斷是否為最後一位元素
  if(x != arr.length - 1){
   temp = temp + arr[x] + ",";
  }else{
    temp = temp + arr[x] + "]";
   }
 }
}
public static String getWeek(int num){
 String[] weeks = { "1", "2", "3", "4", "5", "6", "7" };
 if(num>7 || num<1){
  return num + "沒有對應的星期";
 }
 return weeks[num];
}

選擇排序

選擇排序是第一個人和後續排序的人進行比較，若第一個人大於第二個人，就進行交換，那麼這時第一人就是最小的，然後這時的第一個人和第三個人進行比較，若這時的第一個人大於第三個人，就進行交換位置，這時第一個人又換人了，也變得更小了，就這樣，把剩下的人以這種方法進行比較，直到最後，第一輪結束，在第一位的就是最小的值。

這種就是排序演算法，比如有6個人，第一輪要進行5次比較。小的值往前跑嘛。

//第一輪  for(int index=1;index<arr.length;index++)  
{  if(arr[0]>arr[index])  
{  
  int temp = arr[0];  
  arr[0] = arr[index];  
  arr[index] = temp;  
}  
}  
print(arr);  
  //第二輪  for(int index=2;index<arr.length;index++)  
{  if(arr[1]>arr[index])  
{  
  int temp = arr[1];  
  arr[1] = arr[index];  
  arr[index] = temp;  
}  
}  
print(arr);  
  //第三輪  for(int index=3;index<arr.length;index++)  
{  if(arr[2]>arr[index])  
{  
  int temp = arr[2];  
  arr[2] = arr[index];  
  arr[index] = temp;  
}  
}  
print(arr);  
  //第四輪  for(int index=4;index<arr.length;index++)  
{  if(arr[3]>arr[index])  
{  
  int temp = arr[3];  
  arr[3] = arr[index];  
  arr[index] = temp;  
 }  
}  
print(arr);  
  //第五輪  for(int index=5;index<arr.length;index++)  
{  if(arr[4]>arr[index])  
{  
  int temp = arr[4];  
  arr[3] = arr[index];  
  arr[index] = temp;  
 }  
}  
print(arr);  
  //第六輪沒有，我們arr.length=6舉例  //int index = 6;index<arr.length; false  

優化：

public static void selectionSort(int[] arr)  {  
 for(int count=1;count<arr.length;count++)  
{  
 for(int index=count;index<arr.length;index++)  
 {  
  if(arr[count-1]>arr[index])  
  {  
    int temp = arr[count-1];  
    arr[count-1] = arr[index];  
    arr[index] = temp;  
  }  
 }  
}  
for(int x = 0;x<arr.length-1;x++)
{
 for(int y=x+1;y<arr.length;y++){
  if(arr[x]>arr[y]){
    int temp = arr[x];
    arr[x] = arr[y];
    arr[y] = temp;
  }
 }
}

氣泡排序

為什麼這個排序要叫冒泡呢？為什麼不叫其他名詞呢？

其實這個取名是根據排序演算法的基本思路命名的，見名知意，氣泡排序，就是想泡泡在水裡一樣，在水裡大的泡泡先浮出水面，就是大的先排出來，最小的最慢排出。

氣泡排序，是對排序的各個元素從頭到尾依次進行相鄰的大小比較，比如你是隊長，在你的面前有一排人，你要將其進行排序，依次按照從小到大排序。

怎麼理解最大的值被排除，你是隊長，你對面前的一群人看不慣，進行排序，從左到右開始，第一個和第二個進行比較，大的那個就被挑出來，與第三個進行比較，接下來就是依次按照這個方法比較，就能把那個最大的值，最高的給挑出來不是，這就是第一輪的比較。

接下來，最大的就不用跟他比較了，上面所述，在排序時，你面前的人，是不能亂動的，一旦比較哪個大，兩者就換位，如果第一比第二個小，就是第二個大時，兩者不用換位，第二個就與第三個進行比較。

依照這個方法，兩兩比較，大的都被排到了最後，那麼一旦排完，是不是都依照從小到大，（從低到高）的順序在你面前排好了。

程式碼示例

我們用索引下標來解釋

//第一輪  for(int index=0;index < arr.length-1; index++）{  //相鄰兩個比較  
 if(arr[index] > arr[index+1]){  
   int temp = arr[index];  
   arr[index] = arr[index+1];  
   arr[index+1] = temp;  
 }  
}  
  
print(arr);  
  for(int index=0;index < arr.length-2;index++){  //這裡arr.length-2,為什麼比上一次多減了1呢？  //因為第一輪，把最大的排出來了，就不用比較了，少了一個人  
 if(arr[index] > arr[index+1]){  
   int temp = arr[index];  
   arr[index] = arr[index+1];  
   arr[index+1] = temp;  
 }  
}  
  
print(arr);  
  for(int index=0;index < arr.length-3;index++){  
 if(arr[index]>arr[index+1]){  
   int temp = arr[index];  
   arr[index] = arr[index+1];  
   arr[index+1] = temp;  
 }  
}  
  
print(arr);  

優化：

for(int num=1;num<arr.length;num++){  
  
 for(int index=0;index<arr.length-num;index++){  
  
   if(arr[index]>arr[index+1]){  
     int temp = arr[index];  
     arr[index] = arr[index+1];  
     arr[index+1] = temp;  
   }  
 }  
}  
for(int x=0;x<arr.length-1;x++){
 for(int y=0;y<arr.length-1-x;y++){
  if(arr[y]>arr[y+1]){
   int temp = arr[y];
   arr[y] = arrp[y+1];
   arr[y+1] = temp;
   }
  }
}

二分查詢，折半查詢

什麼是二分查詢，折半查詢呢？就是我說一個數，你來猜，你答一個數，我說大了，或小了，直到找到為止。

public static int searchKey(int[] arr, int key){
 for(int x=0;x<arr.length;x++){
   if(arr[x] == key){
    rerurn x;
   }
  return -1;
  }
}

二分

public static int binarySearch(int[] arr, int key){
 int max,min,mid;
 min = 0;
 max = arr.length - 1;
 mid = (max+min)>>1;

 while(arr[mid] != key){
  if(key>arr[mid]){
    min = mid + 1;
  }else if(key<arr[mid])
    max = mid - 1;

   mid = (max+min)>>1;
  }
 return mid;
 }
}
public static int binarySearch(int[] arr, int key）{
 int max, min , mid;
 min = 0;
 max = arr.length - 1;

 while(min <= max){
   mid = (min+max)>>1;
   if(key>arr[mid]){
    min = mid + 1;
   }else if(key < arr[mid])
    max = mid - 1;
   } else {
    return mid;
 }
 return -1;
}

二維陣列

格式：

int[][] arr = new int[2][3];
int[][] arr = { {3,5,6}, {33,44,66}, {23,21,6} };
for(int x=0; x<arr.length; x++){
 for(int y=0; y<arr[x].length; y++){
   sum += arr[x][y];
  }
}
public static void revese(int[] arr){
 for(int start=0, end = arr.length-1; start<end; start++,end--){
  swap(arr,start,end);
 }
}
public static void swap(int[] arr, int a, int b){
 int temp=arr[a];
 arr[a] = arr[b];
 arr[b] = temp;
}

本章小結

本章主要介紹了陣列的定義，初始化，使用等基本知識，結合了大量的分析記憶體圖用來分析陣列在記憶體中的執行機制，陣列的引用變數和陣列直接的關係，大量講解多維陣列的實質性問題，文章中給出了多種程式碼案例來展示陣列的運用擴充套件。

結言

好了，歡迎在留言區留言，與大家分享你的經驗和心得。

感謝你學習今天的內容，如果你覺得這篇文章對你有幫助的話，也歡迎把它分享給更多的朋友，感謝。

達叔小生：往後餘生，唯獨有你
You and me, we are family !
90後帥氣小夥，良好的開發習慣；獨立思考的能力；主動並且善於溝通
簡書部落格： 達叔小生
https://www.jianshu.com/u/c785ece603d1

結語

• 下面我將繼續對 其他知識 深入講解 ，有興趣可以繼續關注
• 小禮物走一走 or 點贊