陣列的定義與使用
- 陣列的定義與使用
1.1 陣列基本概念
1.2 陣列引用傳遞
1.3 陣列靜態初始化
1.4 二維陣列
1.5 陣列與方法呼叫
1.6 Java對陣列的支援
1.7 陣列案例：陣列資料統計
1.8 陣列案例：陣列排序
1.9 陣列案例：陣列轉置
1.10 陣列案例：二分查詢（前提：陣列排序）
1.11 物件陣列（核心） - 陣列的定義與使用
1.1 陣列基本概念
陣列指的就是一組相關型別的變數集合，並且這些變數可以按照統一的方式進行操作。陣列本身屬於引用資料型別，因此牽扯到記憶體分配，陣列定義語法有如下兩類：
陣列動態初始化：
宣告並開闢陣列：
1.資料型別 [] 陣列名稱 = new 資料型別 [長度];
2.資料型別 陣列名稱 [] = new 資料型別 [長度];
分步進行陣列空間開闢（例項化）：
宣告陣列：1.資料型別 陣列名稱 [] = null;
2.資料型別 [] 陣列名稱 = null;
開闢陣列空間：陣列名稱 = new 資料型別 [長度];
當陣列開闢空間之後，就可以採用如下的方式進行操作：
陣列的訪問通過索引完成，即：“陣列名稱[索引]”，陣列的索引由0開始。可使用的索引範圍為0~陣列長度-1。
當陣列採用動態初始化開闢空間之後，該陣列每個元素都是該陣列對應資料型別的預設值。
如果此時陣列訪問的時候超過了陣列的索引範圍，則會產生“ArrayIndexOutOfBoundsException”。
陣列本身是一個有序的集合操作，所以對於陣列的內容操作往往採用迴圈的模式完成。陣列是一個有限的集合，應使用for迴圈。
在Java中提供有一種動態取得陣列長度的方法：陣列名稱.length。
範例：定義一個int型陣列
程式碼
public class ArrayDemo {
public static void main (String args[]){
int a [] = new int [3]; // 開闢了一個長度為3陣列空間
System.out.println(a[0]);
System.out.println(a[1]);
System.out.println(a[2]);
// System.out.println(a[3]);
// 超出索引範圍，程式報錯，陣列越界異常：Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException: 3
}
}/* 輸出結果：
0
0
0 */
1
2
3
4
5
6
7
8
9
10
11
12
13
範例：迴圈輸出陣列內容
程式碼
public class ArrayDemo {
public static void main (String args[]){
int a [] = new int [3]; // 開闢了一個數組空間
a [0] = 10; // 第一個元素
a [1] = 20; // 第二個元素
a [2] = 30; // 第三個元素
System.out.println(a.length);
for (int i = 0 ; i < a.length ; i++){
System.out.println(a[i]); // 通過迴圈控制索引
}
}
} /* 輸出結果：
3
10
20
30 */
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
範例：採用分步模式開闢陣列空間
程式碼
public class ArrayDemo {
public static void main (String args[]){
int a [] = null;
a = new int [3]; // 開闢了一個數組空間
for (int i = 0 ; i < a.length ; i++){
System.out.print(a[i] + " ");
}
}
}// 輸出結果：0 0 0
1
2
3
4
5
6
7
8
9
在陣列使用之前一定要開闢空間（例項化），如果使用了沒有開闢空間的陣列，一定會出現“NullPointerException”異常資訊。
1.2 陣列引用傳遞
範例：觀察一道程式
程式碼
public class ArrayDemo {
public static void main (String args[]){
int data [] = null;
data = new int [3]; // 開闢了一個數組空間
data [0] = 10; // 第一個元素
data [1] = 20; // 第二個元素
data [2] = 30; // 第三個元素
}
}
1
2
3
4
5
6
7
8
9
記憶體分析如下：
引用資料型別，就一定能發生引用傳遞，本質：同一塊堆記憶體可以被不同的棧記憶體所指向。
範例：觀察一道程式
程式碼
public class ArrayDemo {
public static void main (String args[]){
int data [] = new int [3]; // 開闢了一個數組空間
int temp [] = null; // 宣告
data [0] = 10; // 第一個元素
data [1] = 20; // 第二個元素
data [2] = 30; // 第三個元素
// 如果要發生引用傳遞，不要出現[]
temp = data; // int temp [] = data;
temp [0] = 99;
for (int i = 0 ; i < data.length ; i++){
System.out.print(data[i] + " ");
}
}
} // 輸出結果：99 20 30
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
記憶體分析如下：
1.3 陣列靜態初始化
之前定義陣列的特點：陣列首先開闢記憶體空間，而後在使用索引進行內容的設定，這屬於陣列動態初始化，如果希望陣列在定義的時候可以同時設定內容，就可以採用靜態初始化完成。
陣列的靜態初始化分為以下兩種：
簡化格式 完整格式（建議使用）
資料型別 陣列名稱 [] = {值,值,···,值}; 資料型別 陣列名稱 [] = new 資料型別 [] {值,值,···,值};
範例：靜態初始化陣列
程式碼
public class ArrayDemo {
public static void main (String args[]){
int data [] = {1,2,23,4,56,34,123,1234,346,54};
for (int i = 0 ; i < data.length ; i++){
System.out.print(data[i] + " ");
}
}
} // 輸出結果：1 2 23 4 56 34 123 1234 346 54
1
2
3
4
5
6
7
8
範例：完整格式靜態初始化陣列並使用匿名物件
程式碼
public class ArrayDemo {
public static void main (String args[]){
System.out.print(new int [] {1,2,23,4,56,34,123,1234,346,54}.length);
}
} // 輸出結果：10
1
2
3
4
5
陣列最大的缺陷：長度固定
1.4 二維陣列
二維陣列本質上指的是一個行列集合，如果需要確定某一個·資料需要行索引和列索引來進行定位。確定一個數據要所要使用的結構：“陣列名稱[行索引][列索引]”，這樣的結構就是一個表。
二維陣列的定義有兩種方式：
動態初始化：
資料型別 陣列名稱 [] [] = new 資料型別 [行個數] [列個數];
靜態初始化:
資料型別 陣列名稱 [] []= new 資料型別 [] [] {{值,···,值},{值,···,值},···,{值,···,值}};
陣列的陣列就是二維陣列。
範例：二維陣列
程式碼
public class ArrayDemo {
public static void main (String args[]){
// 此時的陣列並不是一個等列陣列
int data [] [] = new int [] [] {{1,2,3},{4,5},{6,7,8,9}}
};
// 在輸出的時候一定要使用雙重迴圈,外部迴圈控制行，內部迴圈控制列
for (int i = 0 ; i < data.length ; i++){
for ( int j = 0 ; j < data [i].length ; j++){
System.out.print(data[i][j] + " “);
}
System.out.print(”\n");
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
輸出結果：
1 2 3
4 5
6 7 8 9
1
2
3
1.5 陣列與方法呼叫
範例：使用方法接收陣列
程式碼
public class ArrayDemo{
public static void main(String args[]){
int data [] = new int [] {1,2,3,4,5};
printArray(data); // int temp [] = data;
}
// 定義一個專門進行陣列輸出的方法
public static void printArray(int temp []){
for (int x = 0 ; x < temp.length ; x++ ){
System.out.print(temp[x] + “,”);
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
輸出結果：
1,2,3,4,5
1
範例：方法返回陣列
程式碼
public class ArrayDemo{
public static void main(String args[]){
int data [] = inIt(); // 接收陣列
printArray(data);
}
public static int[] inIt(){
return new int [] {1,2,3,4,5};
}
public static void printArray(int temp[]){
for ( int x = 0 ; x < temp.length ; x++){
System.out.print(temp[x] + " ");
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
輸出結果：
1 2 3 4 5
1
發生了引用傳遞，方法接收陣列之後也可以對陣列內容進行修改。
範例：方法實現陣列內容乘2
程式碼
public class ArrayDemo{
public static void main(String args[]){
int data [] = inIt(); // 接收陣列
inc(data); // 擴大陣列中內容
printArray(data);
}
public static void inc(int arry[]){ // 沒有返回值
for(int x = 0 ; x < arry.length ; x++){
arry[x] *= 2;
}
}
public static int[] inIt(){
return new int [] {1,2,3,4,5};
}
public static void printArray(int temp[]){
for ( int x = 0 ; x < temp.length ; x++){
System.out.print(temp[x] + " ");
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
輸出結果：
2 4 6 8 10
1
記憶體分析如下：
1.6 Java對陣列的支援
1.陣列排序：java.util.Arrays.sort(陣列名稱);
範例：實現陣列排序操作
程式碼
public class ArrayDemo{
public static void main(String args[]){
int data [] = new int [] {6,12,3,1,34};
char arr [] = new char [] {‘A’,‘a’,‘Z’,‘z’};
java.util.Arrays.sort(data);
java.util.Arrays.sort(arr);
printArray(data);
printArray(arr);
}
public static void printArray(int temp[]){
for ( int x = 0 ; x < temp.length ; x++){
System.out.print(temp[x] + " ");
}
}
public static void printArray(char arr[]){
for ( int x = 0 ; x < arr.length ; x++){
System.out.print(arr[x] + " ");
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
輸出結果：
1 3 6 12 34 A Z a z
1
只要是基本資料型別的陣列，Arrays.sort()都可以實現排序。
2.陣列拷貝是指講一個數組的部分內容替換掉另外一個數組的部分內容。
方法（加工後的）：System.arraycopy(源陣列名稱,源陣列開始點,目標陣列名稱,目標陣列開始點,拷貝長度);
範例：實現陣列排序操作
源陣列A：1,2,3,4,5,6,7,8,9
源陣列B：11,22,33,44,55,66,77,88,99
替換後A：1,55,66,77,5,6,7,8,9
程式碼
public class ArrayDemo{
public static void main(String args[]){
int data [] = new int [] {1,2,3,4,5,6,7,8,9};
int arr [] = new int [] {11,22,33,44,55,66,77,88,99};
System.arraycopy(arr,4,data,1,3);
printArray(data);
}
public static void printArray(int temp[]){
for ( int x = 0 ; x < temp.length ; x++){
System.out.print(temp[x] + " ");
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
輸出結果：
1 55 66 77 5 6 7 8 9
1
1.7 陣列案例：陣列資料統計
統計一個數組的最大值、最小值、總和和平均值。通過迴圈操作完成。
程式碼
public class ArrayDemo{
public static void main(String args[]){
int data [] = new int [] {1,2,3,4,5,6,7,8,9};
int max = data[0]; // 假設第一個元素為最大值
int min = data[0]; //假設第一個元素為最小值
int sum = data[0];
for (int i = 1 ; i < data.length ; i++){
sum += data[i];
if (max < data[i]){
max = data [i];
}
if (min > data[i]){
min = data [i];
}
}
System.out.println("max = " + max);
System.out.println("min = " + min);
System.out.println("sum = " + sum);
System.out.println("ave = " + (double)sum/data.length);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
輸出結果：
max = 9
min = 1
sum = 45
ave = 5.0
1
2
3
4
主方法中程式碼太多。修改如下：
程式碼
public class ArrayDemo{
public static void main(String args[]){
int data [] = new int [] {1,2,3,4,5,6,7,8,9};
double result [] = stac(data);
System.out.println("max = " + result[0]);
System.out.println("min = " + result[1]);
System.out.println("sum = " + result[2]);
System.out.println("ave = " + result[3]);
}
public static double[] stac(int data[]){
double retData [] = new double [4];
retData [0] = data [0]; // max
retData [1] = data [0]; // min
retData [2] = data [0]; // sum
for (int i = 1 ; i < data.length ; i++){
retData [2] += data[i];
if (retData [0] < data[i]){
retData [0] = data [i];
}
if (retData [1] > data[i]){
retData [1] = data [i];
}
}
retData [3] = retData [2] / data.length;
return retData;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
輸出結果：
max = 9.0
min = 1.0
sum = 45.0
ave = 5.0
1
2
3
4
在整個進行程式開發的時候，主方法不要涉及過於複雜的程式邏輯，只需關注結果。
1.8 陣列案例：陣列排序
不要寫Arrays.sort();
一般以升序為主，共有7種排序演算法。
範例：氣泡排序
程式碼
public class ArrayDemo{
public static void main(String args[]){
int data [] = new int [] {9,8,5,6,4,2,1,3,0,7};
sort(data);
printArray(data);
}
public static void sort (int arr[]){
for (int x = 0 ; x < arr.length - 1 ; x++){
for (int y = 0 ; y < arr.length - x - 1 ; y++){
if (arr[y] > arr[y+1]){
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
}
public static void printArray(int temp[]){
for ( int x = 0 ; x < temp.length ; x++){
System.out.print(temp[x] + " ");
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
輸出結果：
0 1 2 3 4 5 6 7 8 9
1
1.9 陣列案例：陣列轉置
思路一：兩個陣列
範例：一維陣列反轉
程式碼
public class ArrayDemo{
public static void main(String args[]){
int data [] = new int [] {9,8,7,6,5,4,3,2,1,0};
data = reverse(data);
printArray(data);
}
public static int[] reverse(int arr[]){
int temp [] = new int [arr.length] ;
int foot = 0;
for (int x = arr.length - 1 ; x > = 0 ; x--){
temp [foot ++] = arr[x];
}
return temp;
}
public static void printArray(int temp[]){
for ( int x = 0 ; x < temp.length ; x++){
System.out.print(temp[x] + " ");
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
輸出結果：
0 1 2 3 4 5 6 7 8 9
1
記憶體分析：
此類模式最大問題就是：開闢了兩塊相同的對記憶體空間，造成空間浪費。
思路二：一個數組上完成
程式碼
public class ArrayDemo{
public static void main(String args[]){
int data [] = new int [] {9,8,7,6,5,4,3,2,1,0};
reverse(data);
printArray(data);
}
public static void reverse(int arr[]){
int temp = 0;
for (int x = 0 , y = arr.length-1 ; x < arr.length/2 ; x++,y--){
temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
public static void printArray(int temp[]){
for ( int x = 0 ; x < temp.length ; x++){
System.out.print(temp[x] + " ");
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
輸出結果：
0 1 2 3 4 5 6 7 8 9
1
原地轉置二維陣列前提：行列相等
程式碼
public class ArrayDemo{
public static void main(String args[]){
int data [][] = new int [][] {{9,8,7},{6,5,4},{3,2,1}};
reverse(data);
printArray(data);
}
public static void reverse(int arr[][]){
int temp = 0;
for (int i = 0 ; i < arr.length ; i++){
for (int j = i ; j < arr[i].length ; j++ ){
if ( i != j){
temp = arr[i][j];
arr[i][j] = arr[j][i];
arr[j][i] = temp;
}
}
}
}
public static void printArray(int temp[][]){
for ( int x = 0 ; x < temp.length ; x++){
for (int y = 0 ; y < temp[x].length ; y++ ){
System.out.print(temp[x][y] + " ");
}
System.out.print("\n");
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
輸出結果：
9 6 3
8 5 2
7 4 1
1
2
3
1.10 陣列案例：二分查詢（前提：陣列排序）
範例：實現二分查詢（遞迴完成）
程式碼
public class ArrayDemo{
public static void main(String args[]){
int data [] = new int [] {1,2,3,4,5,6,7,8};
int search = 6;
System.out.println(binarySearch(data,1,data.length-1,6));
}
public static int binarySearch(int arr[],int from,int to,int key){
int mid = (from/2) + (to/2);
if (from < to){
if (key == arr[mid]){
return mid;
}else if (key < arr[mid]){
return binarySearch(arr,from,mid-1,key);
}else if (key > arr[mid]){
return binarySearch(arr,mid+1,to,key);
}}
return -1;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
輸出結果：
5
1
1.11 物件陣列（核心）
之前定義的陣列都屬於基本資料型別的陣列，那麼物件也可以將其定義為陣列，這樣的操作叫物件陣列。物件陣列往往是以引用資料型別為主的定義，例如：類、介面。物件陣列分為兩種定義格式：
物件陣列動態初始化：類名稱 物件陣列名稱 [] = new 類名稱 [長度];
物件陣列動態初始化：類名稱 物件陣列名稱 [] = new 類名稱 [] {例項化物件,…};
範例：物件陣列的動態初始化
.> 程式碼
class Person{
private String name;
private int age;
public Person(String n,int a){
name = n;
age = a;
}
public void setName(String n){
name = n;
}
public void setAge(int a){
age = a;
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
public String getInfo(){
return "name = " + name + " " + "age = " + age;
}
}
public class ArrayDemo{
public static void main(String args[]){
// 動態初始化之後物件陣列中的每一個元素都是其對應資料型別的預設值
Person per [] = new Person [3]; // 動態初始化
per[0] = new Person(“Jack”,20);
per[1] = new Person(“Rose”,20);
per[2] = new Person(“Sara”,20);
for (int x =0 ;x < per.length ; x++){
System.out.println(per[x].getInfo());
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
輸出結果：
name = Jack age = 20
name = Rose age = 20
name = Sara age = 20
1
2
3
範例：物件陣列的靜態初始化
.> 程式碼
class Person{
private String name;
private int age;
public Person(String n,int a){
name = n;
age = a;
}
public void setName(String n){
name = n;
}
public void setAge(int a){
age = a;
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
public String getInfo(){
return "name = " + name + " " + "age = " + age;
}
}
public class ArrayDemo{
public static void main(String args[]){
Person per [] = new Person [] {new Person(“Jack”,20),new Person(“Rose”,20),new Person(“Sara”,20)};
for (int x =0 ;x < per.length ; x++){
System.out.println(per[x].getInfo());
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
輸出結果：
name = Jack age = 20
name = Rose age = 20
name = Sara age = 20
作者：SophiaJZ
來源：CSDN
原文：https://blog.csdn.net/SophiaJZ/article/details/79427575
版權宣告：本文為博主原創文章，轉載請附上博文連結！