1-004-Java陣列筆記
陣列概述
陣列是相同型別資料的有序集合。
每一個數據稱作陣列元素，每個陣列元素可以通過一個下標來訪問他們。
陣列宣告建立
首先必須宣告陣列變數，才能在程式中使用陣列。下面是宣告陣列變數的語法：
dataType[] arrayRefVar; //首選方法
//陣列型別[] 陣列名字;
或
dataType arrayRefVar[]; //效果相同但不是首選方法
//陣列型別 陣列名字[];
Java語言使用new操作符來建立陣列，語法如下：
dataType[] arrayRefVar = new dataType[arraySize];
//陣列型別[] 陣列名 = new 陣列型別[陣列長度];
陣列的元素是通過索引訪問的，陣列索引從0開始。
獲取陣列長度：
arrays.length
//陣列名.length
記憶體分析
Java記憶體：
-
堆：1. 存放new的物件和陣列
2. 可以被所有執行緒共享，不會存放別的物件引用
-
棧：1. 存放基本變數型別（會包含這個基本型別的具體數值）
2. 引用物件的變數（會存放這個引用在堆裡面的具體地址）
-
方法區：1. 可以被所有的執行緒共享
2. 包含了所有的class和static變數
陣列下標越界系統報錯：
java.lang.ArrayIndexOutOfBounds //陣列下標越界
三種初始化
-
靜態初始化：（建立+賦值）
int[] a = {1,2,3,4,5,6};
Man[] mans = {new Man(1,1),new Man(2,2)}; -
動態初始化：（包含預設初始化）
int[] b = new int[10];
b[0] = 1;
b[1] = 2; -
陣列的預設初始化：
陣列是引用型別，他的元素相當於類的例項變數，因此陣列一經分配空間，其中的每個元素也被按照例項變數同樣的方式被隱式初始化。
陣列的四個基本特點
-
陣列的長度是確定的，陣列一旦被建立，它的大小就是不可以被改變的。
-
其元素必須是相同型別，不允許出現混合型別。
-
陣列中的元素可以是任何資料型別，包括基本型別和引用型別。
-
陣列變數屬於引用型別，陣列也可以看成是物件，陣列中的每個元素相當於該物件的成員變數。陣列本身就是物件，Java中物件是在堆中的，因此陣列無論儲存原始型別還是其他物件型別，陣列物件本身是在堆中的
。
陣列邊界
-
下標的合法區間：[0,length-1]，如果越界就會報錯：
java.lang.ArrayIndexOutOfBounds //陣列下標越界 -
小結：
-
陣列是相同資料型別（資料型別可以為任意型別）的有序集合
-
陣列也是物件。陣列元素相當於物件的成員變數
-
陣列長度是確定的，不可變的。如果越界則報：ArrayIndexOutOfBounds
-
陣列使用
package com.king.array;
public class ArrayDemo {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
// For-Each 迴圈 JDK1.5 沒有下標
for (int array : arrays) {
System.out.println(array);
}
System.out.println("===================");
printArray(arrays);
System.out.println();
int[] reverse = reverse(arrays);
printArray(reverse);
}
//陣列作為方法入參 例：列印陣列元素
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+" ");
}
}
//陣列作為返回值 例：反轉陣列
public static int[] reverse(int[] arrays){
int[] result = new int[arrays.length];
for (int i = 0,j = result.length - 1; i < result.length; i++) {
result[j - i] = arrays[i];
}
return result;
}
}
多維陣列
多維陣列可以看成是陣列的陣列。例如二維陣列就是一個特殊的一維陣列，其中每一個元素都是一個一維陣列。
二維陣列的定義
int[][] a = {{1.2},{2,3},{3,4}};
int[][] a2 = new int[2][4]; //定義一個2行4列的一個數組
int a3[][] = new int[2][5]; //定義一個2行5列的一個數組
a.length //獲取行的長度
a[0].length //獲取列的長度
例：
//定義並輸出二維陣列
package com.king.array;
public class ArrayDemo {
public static void main(String[] args) {
int[][] array = {{1,2},{2,3},{3,4},{4,5}};
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.println(array[i][j]);
}
}
}
}
Arrays 類
陣列的工具類java.util.Arrays
-
給陣列賦值：通過fill方法
-
對陣列排序：通過sort方法，按升序
-
比較陣列：通過equals方法比較陣列中元素值是否相等
-
查詢元素：通過binarySearch能對排序好的陣列進行二分查詢操作
-
列印陣列元素：通過toString方法
...
例：
package com.king.array;
import java.util.Arrays;
public class ArrayDemo {
public static void main(String[] args) {
int[] a = {1,2,3,4,9090,31231,543,21,3,23};
System.out.println(a);//[I@1b6d3586
//列印陣列元素 Arrays.toString
System.out.println(Arrays.toString(a));
Arrays.sort(a);// 對陣列進行排序 Arrays.sort
System.out.println(Arrays.toString(a));
Arrays.fill(a,0);//陣列填充
System.out.println(Arrays.toString(a));
}
}
氣泡排序
最出名的演算法之一（共有八大排序演算法）
氣泡排序兩層迴圈，外層冒泡輪數，裡層依次比較。時間複雜度為O(n2)。
例：
package com.king.array;
import java.util.Arrays;
public class ArrayDemo07 {
public static void main(String[] args) {
int[] a = {1,23,5,15,48,46,65,89};
int[] sort = sort(a);//返回一個排序後的陣列
System.out.println(Arrays.toString(sort));
}
//氣泡排序
public static int[] sort(int[] array){
//臨時變數
int temp = 0;
//外層迴圈，判斷要走多少次
for (int i = 0; i < array.length - 1; i++) {
//如果第一個數比第二個數大，則交換位置
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j + 1] < array[j]){
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
return array;
}
}
稀疏陣列
-
當一個數組中大部分元素為0，或者為同一值的陣列時，可以使用稀疏陣列來儲存該陣列。
-
稀疏陣列的處理方式是：
-
記錄陣列有幾行幾列有多少個不同值
-
把具有不同值的元素和行列及值記錄在一個小規模陣列中，從而縮小程式規模
-
-
例：
原始陣列如下
0 0 0 22 0 0 15 0 11 0 0 0 17 0 0 0 0 -6 0 0 0 0 0 0 0 0 39 0 91 0 0 0 0 0 0 0 0 28 0 0 0 0 稀疏陣列
行(row) 列(col) 值(value) [0] 6 7 8 表示原始陣列6行7列有8個有效數字 [1] 0 3 22 有效數字的座標：表示第0行第3列的值為22 [2] 0 6 15 ... [3] 1 1 11 ... [4] 1 5 17 ... [5] 2 3 -6 ... [6] 3 5 39 ... [7] 4 0 91 ... [8] 5 2 28 ...
五子棋遊戲中，存檔退出和續上盤功能：
package com.king.array;
public class ArrayDemo {
public static void main(String[] args) {
//1. 建立一個二維陣列 11*11 0：沒有棋子 ，1：黑棋， 2：白棋
int[][] array1 = new int[11][11];
array1[1][2] = 1; //第2行第3列黑棋
array1[2][3] = 2; //第3行第4列白棋
//輸出原始陣列
System.out.println("輸出原始陣列：");
for(int[] ints : array1){
for(int anInt : ints){
System.out.print(anInt+"\t");
}
System.out.println();
}
System.out.println("======================================");
//轉換為稀疏陣列儲存
//獲取有效值的個數
int sum = 0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[i].length; j++) {
if (array1[i][j] != 0){
sum++;
}
}
}
System.out.println("有效值的個數：" + sum);
//2. 建立一個稀疏陣列的陣列
int[][] array2 = new int[sum + 1][3];
array2[0][0] = array1.length;
array2[0][1] = array1[0].length;
array2[0][2] = sum;
//遍歷二維陣列，將非零的值，存放稀疏陣列中
int count = 0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[i].length; j++) {
if (array1[i][j] != 0){
count++;
array2[count][0] = i;
array2[count][1] = j;
array2[count][2] = array1[i][j];
}
}
}