1.概述

• 定義

  • 相同型別資料的有序集合
  • 描述的相同型別的託幹資料，且有序組合而成
  • 每一個數據稱作陣列元素，每個元素可以通過一個下標訪問他們

  陣列下標從0開始

2.宣告、建立

• 宣告

int[] nums; //一般寫法
int nums1[];//C快速匯入Java

• 建立

//這裡面可以放10個int型別的資料
nums = new int[10];

• 賦值

//給陣列中的元素賦值
nums[0] = 1;
nums[1] = 1;
nums[2] = 1;
nums[3] = 1;

屬性：陣列長度 length

Java記憶體

1. 堆

   • 存放new的物件和陣列
   • 可以被所有的執行緒共享，不會存放別的物件引用

2. 棧

   • 存放基本變數型別(包括數值)
   • 引用物件的變數(會存放這個引用在堆裡面的具體地址)

• 三種初始化

  //1. 靜態初始化
  int[] a = {1,2,3,4,5};
  //2. 動態初始化 包含預設初始化
  int[] b = new int[5];
  b[1] = 1;
  //3. 預設初始化，預設值
  

陣列的而四個基本特點

• 長度是確定的，不可更改
• 元素必須是相同型別
• 陣列中的元素可以是任何資料型別，包括基本型別和引用型別
• 陣列本身就是物件，陣列變數屬於引用型別。

陣列有效區間[0,length-1]

越界會報異常：ArrayIndexOutofBoundsException

3.陣列的使用

• for-each

• for迴圈

• 陣列作為方法的引數

• 陣列作為方法的返回值

4.多維陣列

可以看成陣列的陣列，比如一個二維陣列，其中每一個元素都是一個一維的陣列

int[][] arrays = new int[3][3];

實質

5.Arrays類

• 陣列的工具類java.util.Arrays

public class Demo01 {
    public static void main(String[] args) {
        int[] b = {4,3,6,90,58,45};
        //輸出陣列 Arrays.toString
        System.out.println(Arrays.toString(b));
        Arrays.sort(b);//排序  升序 Arrays.sort
        System.out.println(Arrays.toString(b));
    }
}
 

• 給陣列賦值：fill方法
• 對陣列排序：同各國sort方法，按照升序
• 比較陣列：equals方法 返回boolean
• 查詢陣列元素：binarySearch方法對排序好的陣列進行二分查詢

氣泡排序

public class Demo02 {
    public static void main(String[] args) {
        int[] a = {2,565,11,564,52,3,5456,65};
        int[] sort = sort(a);
        System.out.println(Arrays.toString(a));
    }
    //氣泡排序
    //1. 比較陣列中每兩個相鄰的元素，如果第一個元素比第二個元素大，就交換他們的位置
    //2. 每一次比較都會產生一個最大的數字
    //3. 下一輪比較就可以少一次
    //依次迴圈直到結束！
    public static int[] sort(int[] a){
        //定義臨時變數，方便交換值
        int temp = 0;
        //外層迴圈，控制比較的輪數
        for (int i = 0; i < a.length-1; i++) {
            //內層迴圈，控制每一輪比較的次數
            for (int j = 0; j < a.length-1-i; j++) {
                if(a[j+1]>a[j]){
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
        return a;
    }
}

6.稀疏陣列

• 稀疏陣列是一種資料結構，為了壓縮資料，減少空間的浪費
• 當一個數組中有很多相同值的時候就可以使用稀疏陣列儲存
• 稀疏陣列的處理方式：
  • 記錄陣列一共有幾行幾列，有多少個不同取值
  • 把具有不同取值的元素的行列及值記錄在一個小規模的陣列中，從而縮小程式的規模

public class Demo03 {
    //稀疏陣列
    public static void main(String[] args) {
        //0表示沒有棋子 1表示黑棋 2表示白棋
        int[][] a = new int[11][11];
        a[1][2] = 1;
        a[2][3] = 2;
        //輸出原始陣列
        for (int[] ints : a) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        System.out.println("=================================");

        //建立一個稀疏陣列
        //首先 獲得原始陣列的所有有效值的個數
        int sum = 0;
        for (int[] ints : a) {
            for (int anInt : ints) {
                if(anInt != 0){
                    sum++;
                }
            }
        }
        int[][] b = new int[sum+1][3];//建立稀疏陣列
        //第一行賦值 固定賦值
        b[0][0] = a.length;
        b[0][1] = a[0].length;
        b[0][2] = sum;
        //遍歷原始陣列  給稀疏陣列賦值
        int count = 0;//計數有效元素
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[0].length; j++) {
                if(a[i][j]!=0){
                    count++;
                    b[count][0] = i;
                    b[count][1] = j;
                    b[count][2] = a[i][j];
                }
            }
        }
        //輸出稀疏陣列
        for (int[] ints : b) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        System.out.println("=================================");

        //稀疏陣列還原為原來的原始陣列
        //建立一個數組 稀疏陣列的第一行的資訊為其建立元素做鋪墊
        int[][] c = new int[b[0][0]][b[0][1]];
        //從第二行開始遍歷稀疏陣列，依次給每一個有效元素賦值
        for (int i = 1; i < b.length; i++) {
            c[b[i][0]][b[i][1]] = b[i][2];
        }
        //輸出還原的原始陣列
        for (int[] ints : c) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}