Java學習筆記：8、陣列
阿新 • • 發佈：2021-06-29
九、陣列
1、什麼是陣列
陣列是相同資料型別的有序集合
陣列描述的是相同型別的若干個資料，按照一定的先後順序排列組合而成
每一個數據稱為一個數組元素，每個陣列元素可以通過一個下標訪問
2、陣列宣告建立
宣告陣列變數的方法
dataType[] arrayRefVar; //首選方法
&&
dataType arrayRefVar[]; //效果相同但不是首選
-
靜態初始化
//建立+賦值 int[] a = {1,2,3,4,5,6,7,8,9}; -
動態初始化
//包含預設初始化 int[] b = new int[10]; b[0] = 10; ... -
預設初始化
陣列是引用型別，它的元素相當於類的例項變數，因此陣列一經分配空間，其中的每個元素也被按照例項變數同樣的方式被隱式初始化
int型別初始化值為0,String型別初始化值為null
Java使用new操作符來建立陣列
dataType[] arrayRefVar = new dataType[arratSize];
陣列的元素都是通過索引訪問的，陣列索引從0開始
獲取陣列長度
arrays.length
-
Java記憶體分析
陣列的四個基本特點
- 其長度是確定的，陣列一旦被建立，它的大小就是不可以改變的
- 陣列元素必須是相同型別，不允許出現混合型別
- 陣列中的元素可以是任何資料型別，包括基本型別和引用型別
- 陣列的變數屬於引用型別，陣列可以看成是物件，陣列中的每個元素相當於該物件的成員變數。陣列本身就是物件，Java物件是在堆中的，因此陣列無論儲存原始型別還是其他物件型別，陣列物件本身實在堆中的。
陣列邊界區間
- 下標的合法區間：
[0,length-1]，如果越界就會報錯
ArrayIndexOutOfBoundsException：陣列下標越界異常！
3、陣列使用
計算陣列之和
int[] array = {1,2,3,4,5};
int sum=0;
for(int i=0;i<array.length;i++){
sum+=array[i];
}
System.out.println("sum="+sum);
查詢陣列最大元素
int[] array = {1,2,3,4,5}; int max=array[0]; for(int i=0;i<array.length;i++){ if(max<array[i]){ max=array[i]; } } System.out.println("max="+max);
反轉陣列
public static int[] reverse(int[] arrays) {
int[] resault = new int[arrays.length];
for (int i = 0, j = arrays.length - 1; i < arrays.length; i++, j--) {
resault[j] = arrays[i];
}
return resault;
}
4、多維陣列
多維陣列可以看成是陣列的陣列，二維陣列就是一個特殊的一維陣列，其每個元素都是一個一維陣列
-
二維陣列
//兩行五列的陣列 int a[][] = new int[2][5];
二維陣列使用
package com.kuang.array;
public class ArrayDemo03 {
public static void main(String[] args) {
int [][] array = {{1,2},{2,3},{3,4},{4,5}};
/*
* 1,2 array[0]
* 2,3 array[1]
* 3,4 array[2]
* 4,5 array[3]
*/
printArray(array);
}
public static void printArray(int[][] arrays) {
for (int j = 0; j < arrays.length; j++) {
for (int i = 0; i < arrays[j].length; i++) {
System.out.print(arrays[j][i]+ " ");
}
System.out.println();
}
}
}
5、Arrays類
陣列的工具類
java.util.Arrays
package com.kuang.array;
import java.util.Arrays;
public class ArrayDemo04 {
public static void main(String[] args) {
int[] a={1,2,3,4,9999,3333,444,22121,412};
System.out.println(a);
//輸出效果相同
System.out.println(Arrays.toString(a));
printArray(a);
}
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
if(i==0){
System.out.print("[");
}
if(i== arrays.length-1){
System.out.print(arrays[i]+"]");
}else{
System.out.print(arrays[i]+", ");
}
}
}
}
6、氣泡排序
package com.kuang.array;
import java.util.Arrays;
public class ArrayDemo05 {
public static void main(String[] args) {
int[] a = {1, 2, 3, 4, 9999, 3333, 444, 22121, 412};
printArray(a);
int[] b = bubbleSort(a);
printArray(b);
}
public static void printArray(int[] arrays) {
for (int i = 0; i < arrays.length; i++) {
if (i == 0) {
System.out.print("[");
}
if (i == arrays.length - 1) {
System.out.print(arrays[i] + "]");
} else {
System.out.print(arrays[i] + ", ");
}
}
System.out.println();
}
public static int[] bubbleSort(int[] arrays) {
//1. 比較陣列中兩個相鄰元素，如果第一個比第二個大，交換位置
//2. 每次比較，會產生一個最大或最小的數
//3. 下一輪可以少一次排序
//4. 一次迴圈，直到結束
int temp = 0;
for (int i = 0; i < arrays.length - 1; i++) {
boolean flag = false; //通過flag標識位減少沒意義的比較
for (int j = 0; j < arrays.length - i - 1; j++) {
if (arrays[j + 1] > arrays[j]) {
temp = arrays[j + 1];
arrays[j + 1] = arrays[j];
arrays[j] = temp;
flag=true;
}
}
//兩個數已經交換過一次,a0,a1,a2,a3===>a0,a2,a1,a3,
//不需要再比較a2和a3,直接開始下一個迴圈比較a1和a3
if(flag==true){
break;
}
}
return arrays;
}
}
7、 稀疏陣列
當一個數組中大部分元素為0，或者同一值的陣列時，可以使用稀疏陣列來儲存該陣列。
稀疏陣列的處理方式是：
記錄陣列一共有幾行幾列，有多少個不同的值
把具有不同值的元素和行列及值記錄在一個小規模的陣列中，從而縮小程式的規模
package com.kuang.array;
import java.util.concurrent.ForkJoinPool;
public class ArrayDemo06 {
public static void main(String[] args) {
//1. 建立一個二維陣列，11*11,0無棋，1黑棋，2白棋
int[][] array1=new int[11][11];
array1[1][2]=1;
array1[2][3]=2;
//輸出原始陣列
System.out.println("輸出原始的陣列：");
printArray(array1);
//稀疏陣列
int[][] xishu=xiShuArray(array1);
System.out.println("輸出稀疏陣列：");
printArray(xishu);
//還原稀疏陣列
System.out.println("還原稀疏陣列：");
int[][] huanyuan=huanYuan(xishu);
printArray(huanyuan);
}
public static void printArray(int[][] array){
for (int i = 0; i < array.length; i++) {
for (int j = 0; j <array[i].length; j++) {
System.out.print(array[i][j]+"\t");
}
System.out.println();
}
}
//轉換為稀疏陣列儲存
public static int[][] xiShuArray(int[][] array1){
//獲取有效值個數
int sum=0;
for(int i=0;i<11;i++){
for(int j=0;j<11;j++){
if(array1[i][j]!=0){
sum++;
}
}
}
System.out.println("有效值的個數："+sum);
//建立一個稀疏陣列的陣列
int[][] array2=new int[sum+1][3];
array2[0][0]=11;
array2[0][1]=11;
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];
}
}
}
return array2;
}
//根據稀疏陣列還原原始陣列
public static int[][] huanYuan(int[][] array){
//1. 讀取稀疏陣列
int[][] array3=new int[array[0][0]][array[0][1]];
//2. 給其中的元素還原它的值
for (int i = 1; i < array.length; i++) {
array3[array[i][0]][array[i][1]]=array[i][2];
}
return array3;
}
}