1.陣列基本用法
1.1什么是陣列
陣列本質上就是讓我們能 “批量” 創建相同型別的變數，
例如:
如果需要表示兩個資料, 那么直接創建兩個變數即可 int a; int b ，
如果需要表示五個資料, 那么可以創建五個變數 int a1; int a2; int a3; int a4; int a5;
但是如果需要表示一萬個資料, 那么就不能創建一萬個變數了，這時候就需要使用陣列, 幫我們批量創建，
1.2創建陣列
基本語法：
//靜態初始化
陣列型別[]陣列名稱 = {初始化資料}；//用逗號間隔
//動態初始化
資料型別[]陣列名稱 = new 資料型別[]{初始化資料}；
//未初始化
資料型別[]陣列名稱 = new 資料型別[陣列大小]; //這里必須指定大小，不然會報錯，
代碼示例：
int[] arr = new int[]{1, 2, 3};
int[] arr = {1, 2, 3};
int[] arr = new int[4];
注意：
靜態初始化的時候, 陣列元素個數和初始化資料的格式是一致的，不能在前面的中括號中寫具體的數字，
其實陣列也可以寫成：
int arr[] = {1,2,3};
但是這樣就和C/C++語言沒什么區別了，所以我們還是更推薦寫成 int[] arr 的形式，int和 [ ]是一個整體，
1.3陣列的使用
代碼示例：獲取陣列長度&訪問元素
int[] arr = {1, 2, 3};
// 獲取陣列長度
System.out.println("length: " +arr.length); // 執行結果: 3
// 訪問陣列中的元素
System.out.println(arr[1]); // 執行結果: 2
System.out.println(arr[0]); // 執行結果: 1
arr[2] = 100;
System.out.println(arr[2]); //執行結果：100
注意：
- 在java中使用 arr.length 能夠直接獲取到陣列的長度，. 運算子這個操作為成員訪問運算子. 后面在面向物件中會經常用到，
- 使用 [ ] 按下標取陣列元素. 需要注意, 下標從 0 開始計數，
- 使用 [ ] 操作既能讀取資料, 也能修改資料，
- 下標訪問操作不能超出有效范圍 [0, length - 1] , 如果超出有效范圍, 會出現下標越界例外，
代碼示例：陣列越界
int[] arr = {1, 2, 3}; System.out.println(arr[3]);
// 執行結果
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100
at Test.main(Test.java:4)
拋出了java.lang.ArrayIndexOutOfBoundsException 例外，所以使用陣列一定要防止下標越界，
代碼示例：遍歷陣列
通常需要用到回圈陳述句，
方法1：
int[] arr = {1, 2, 3};
for (int i = 0; i < arr.length; i++) { System.out.print(arr[i]+" ");
}
// 執行結果 1 2 3
方法2：
使用 for-each 遍歷陣列
int[] arr = {1, 2, 3};
for (int x : arr) {
System.out.print(x+" ");
}
// 執行結果 1 2 3
for-each 是for回圈的另外一種使用方式，能夠更方便的完成對陣列的遍歷，可以避免回圈條件和更新陳述句寫錯，
2.陣列作為方法的引數
2.1基本用法
代碼示例：
public static void main(String[] args) {
int[] arr = {1, 2, 3};
printArray(arr);
}
public static void printArray(int[] a) {
for (int x : a) {
System.out.print(x+" ");
}
}
// 執行結果 1 2 3
在這個代碼中：
- int[] a 是函式的形參，其作用域在printArray這個函式中，int[] arr 是函式實參，
- 在printArray()中，想要獲取陣列長度，同樣可以使用 a.length，
2.2理解參考型別(重點)
關于傳參型別我已經在 java中方法的使用 中談到當傳遞引數型別為內置型別時也就是簡單型別時，可以發現修改形參的值是不會改變實參的值的，
代碼示例：引數傳陣列型別
public static void func(int[] a) {
a[0] = 10;
System.out.println("a[0] = " + a[0]);
}
public static void main(String[] args) {
int[] arr = {1, 2, 3};
func(arr);
System.out.println("arr[0] = " + arr[0]);
}
// 執行結果
a[0] = 10
arr[0] = 10
我們發現, 在函式內部修改陣列內容, 函式外部也發生改變，
此時陣列名 arr 是一個 “參考” ，當傳參的時候, 是按照參考傳參，
這里我們要先從記憶體開始說起：
記憶體就是指我們熟悉的 “記憶體”. 記憶體可以直觀的理解成一個宿舍樓，有一個長長的大走廊, 上面有很多房間，
每個房間的大小是 1 Byte (如果計算機有 8G 記憶體, 則相當于有 80億 個這樣的房間)，每個房間上面又有一個門牌號, 這個門牌號就稱為地址，
參考是什么：
參考相當于一個 “別名”, 也可以理解成一個指標，
創建一個參考只是相當于創建了一個很小的變數, 這個變數保存了一個整數, 這個整數表示記憶體中的一個地址，
關于參考，可以參考 C++入門知識點詳談，
那么針對 int[] arr = new int[]{1,2,3}; 這段代碼，記憶體布局如圖：
(a) 當我們創建 new int[]{1, 2, 3} 的時候, 相當于創建了一塊記憶體空間保存三個 int，
(b) 接下來執行 int[] arr = new int[]{1, 2, 3} 相當于又創建了一個 int[] 變數, 這個變數是一個參考型別, 里面只保存了一個整數(陣列的起始記憶體地址)，
? 接下來我們進行傳參相當于 int[] a = arr , 記憶體布局如圖:
(d) 接下來我們修改 a[0] , 此時是根據 0x100 這樣的地址找到對應的記憶體位置, 將值改成 100，
此時已經將 0x100 地址的資料改成了 100 ，也就是說通過a[0]修改，arr[0]也會改變，那么根據實參 arr 來獲取陣列內容 arr[0] , 本質上也是獲取 0x100，地址上的資料, 也是 100，
總結: 所謂的 “參考” 本質上只是存了一個地址.，Java 將陣列設定成參考型別, 這樣的話后續進行陣列引數傳參, 其實只是將陣列的地址傳入到函式形參中. 這樣可以避免對整個陣列的拷貝(陣列可能比較長, 那么拷貝開銷就會很大)，
2.3認識null
null 在 Java 中表示 “空參考”,也就是一個無效的參考，
int[] arr = null;
System.out.println(arr[0]);
// 執行結果 Exception in thread "main" java.lang.NullPointerException
at Test.main(Test.java:6)
null 的作用類似于 C 語言中的 NULL (空指標), 都是表示一個無效的記憶體位置. 因此不能對這個記憶體進行任何讀寫操作，一旦嘗試讀寫, 就會拋出 NullPointerException，
注意: Java 中并沒有約定 null 和 0 號地址的記憶體有任何關聯，
2.4初識 JVM 記憶體區域劃分(重點)
JVM 的記憶體被劃分成了幾個區域：
- 程式計數器 (PC Register): 只是一個很小的空間, 保存下一條執行的指令的地址，
- 虛擬機堆疊(JVM Stack): 重點是存盤區域變數表(當然也有其他資訊). 我們剛才創建的 int[] arr 這樣的存盤地址的參考就是在這里保存，
- 本地方法堆疊(Native Method Stack): 本地方法堆疊與虛擬機堆疊的作用類似. 只不過保存的內容是Native方法的區域變數. 在有些版本的 JVM 實作中(例如HotSpot), 本地方法堆疊和虛擬機堆疊是一起的. 堆(Heap): JVM所管理的最大記憶體區域. 使用 new 創建的物件都是在堆上保存 (例如前面的 new int[]{1, 2, 3} )，
- 方法區(Method Area): 用于存盤已被虛擬機加載的類資訊、常量、靜態變數、即時編譯器編譯后的代碼等資料，方法編譯出的的位元組碼就是保存在這個區域，
- 運行時常量池(Runtime Constant Pool): 是方法區的一部分, 存放字面量(字串常量)與符號參考. (注意 從 JDK1.7開始，運行時常量池在堆上)，
Native 方法:
JVM 是一個基于 C++ 實作的程式. 在 Java 程式執行程序中, 本質上也需要呼叫 C++ 提供的一些函式進行和作業系統底層進行一些互動. 因此在 Java 開發中也會呼叫到一些 C++ 實作的函式，
這里的 Native 方法就是指這些 C++ 實作的, 再由 Java 來呼叫的函式，
- 區域變數和參考保存在堆疊上, new 出的物件保存在堆上，
- 堆的空間非常大, 堆疊的空間比較小，
- 堆是整個 JVM 共享一個, 而堆疊每個執行緒具有一份(一個 Java 程式中可能存在多個堆疊)，
3.陣列作為方法的回傳值
代碼示例：寫一個方法，將陣列中的每個元素都 * 2
// 直接修改原陣列
class Test {
public static void printArray(int[] arr) { //列印這個陣列
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
}
public static void transform(int[] arr) {
for (int i = 0; i < arr.length; i++) {
arr[i] = arr[i] * 2;
}
}
public static void main(String[] args) {
int[] arr = {1, 2, 3};
transform(arr);
printArray(arr);
}
}
//運行結果：
2 4 6
可以看到這個代碼固然可行，但是破壞了原有的陣列內容，有時候我們不希望不破壞原陣列，就需要在方法內部創建一個新的陣列，并由方法回傳出來，
代碼示例：
//回傳一個新的陣列
class Test {
public static void printArray(int[] arr) { //列印這個陣列
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
}
public static int[] transform(int[] arr) {
int[] ret = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
ret[i] = arr[i] * 2;
}
return ret;
}
public static void main(String[] args) {
int[] arr = {1, 2, 3};
int[] ret = transform(arr);
printArray(ret);
System.out.println();
printArray(arr);
}
}
//運行結果:
2 4 6
1 2 3
這樣的話就不會破壞原有陣列了,另外由于陣列是參考型別, 回傳的時候只是將這個陣列的首地址回傳給函式呼叫者, 沒有拷貝陣列內容, 從而比較高
效，
4.陣列常見操作
4.1陣列轉字串
代碼示例：
import java.util.Arrays
int[] arr = {1,2,3,4,5,6};
String newArr = Arrays.toString(arr); System.out.println(newArr);
// 執行結果
[1, 2, 3, 4, 5, 6]
使用這個方法列印陣列變的更簡單一些，
Java 中提供了 java.util.Arrays 包, 其中包含了一些操作陣列的常用方法，自己可以把Arrays包里的每個方法都試試，
當然我們也可以自己實作一個陣列轉字串：
public static String toString(int[] arr) {
String ret = "[";
for (int i = 0; i < arr.length; i++) {
// 借助 String += 進行拼接字串
ret += arr[i];
// 除了最后一個元素之外, 其他元素后面都要加上 ", "
if (i != arr.length - 1) {
ret += ", ";
}
}
ret += "]";
return ret;
}
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6};
System.out.println(toString(arr));
}
//運行結果:
[1, 2, 3, 4, 5, 6]
4.2陣列拷貝
首先實作自己的拷貝陣列，用常用for回圈即可：
public static int[] copyOf(int[] arr) {
int[] ret = new int[arr.length]; //創建一個和arr一樣大小的新陣列
for (int i = 0; i < arr.length; i++) {
ret[i] = arr[i];
}
return ret;
}
當然，也有本地方法，更快速：
public static void main(String[] args) {
int []arr = {1,2,3,4,5};
int []dest = new int[arr.length];
//方法1：本地方法
//System.arraycopy(src,srcPos,dest,destPos,length);
//src：源陣列 srcPos: 從源陣列的pos位置開始拷貝
//dest：拷貝到目的陣列 destPos：拷貝到目的陣列的pos位置
//length： 拷貝長度
System.arraycopy(arr, 0, dest, 0, arr.length);
//方法2:(速度最快)
//Arrays.copyOf(src,length);
//src: 源陣列 length:拷貝長度
int []dest = Arrays.copyOf(arr, arr.length);
//方法3:
//陣列名.clone(); 產生需要克隆的物件的一個副本
int []dest = arr.clone();
System.out.println(Arrays.toString(dest));
}
4.3檢查陣列有序性
給定一個整型陣列, 判斷是否該陣列是有序的(升序)：
public static boolean isSorted(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
if (arr[i] > arr[i + 1]) {
return false;
}
}
return true;
}
public static void main(String[] args) {
int[] arr = {1,2,3,10,5,6};
System.out.println(isSorted(arr));
}
//運行結果：false
4.4陣列排序(冒泡排序)
給定一個陣列, 讓陣列升序 (降序) 排序，
具體參考 簡單冒泡排序 和冒泡排序改進版
冒泡排序性能較低. Java 中內置了更高效的排序演算法，
代碼示例：
public static void main(String[] args) {
int[] arr = {9, 5, 2, 7};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
}
運行結果: [2, 5, 7, 9]
4.5陣列數字排列
給定一個整型陣列, 將所有的偶數放在前半部分, 將所有的奇數放在陣列后半部分，
例如
{1, 2, 3, 4}
調整后得到
{4, 2, 3, 1}
基本思路
設定兩個下標分別指向第一個元素和最后一個元素，用前一個下標從左往右找到第一個奇數, 用后一個下標從右往左找到第一個偶數, 然后交換兩個位置的元素,依次回圈即可，
具體參考:
將一個陣列的奇數放在偶數前面 ，這個是將奇數放在偶數前面，如果要將偶數放在奇數前面，將判定條件一改就ok了，
5.二維陣列
二維陣列本質上也就是一維陣列, 只不過每個元素又是一個一維陣列，
基本語法：
資料型別[][] 陣列名稱 = new 資料型別 [行數][列數] { 初始化資料 };
代碼示例：
int[][] arr = new int[2][3];
int[][] arr = { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12} };
int[][] arr = new int[2][3]{{1,2},{3,4}};
int[][] arr = new int[2][]; //不規則陣列，列數需要自己指定
arr[0] = 2; //第一列
arr[1] = 3; //第二列
二維陣列的用法和一維陣列并沒有明顯差別，二位陣列遍歷與C/C++有些許不同，
代碼示例：
for (int row = 0; row < arr.length; row++) { //arr.length 這里指的是二維陣列的行數
for (int col = 0; col < arr[row].length; col++) {//arr[row].length 這里指每一行的列數
System.out.printf("%d\t", arr[row][col]);
}
System.out.println("");
}
//將二位陣列轉為字串列印
System.out.println(Arrays.deepToString(陣列名));
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/173269.html
標籤：其他