文章目錄

一、陣列基本用法
- 1.什么是陣列
- 2.陣列的創建
- 3.定義陣列的方式
- 4.陣列的使用
- - 4.1 獲取陣列的長度
  - 4.2 遍歷陣列的兩種方式
  - 4.3 for回圈和foreach(增強for回圈)的區別
  - 4.4 以字串列印陣列
  - 4.5 陣列下標越界訪問例外
- 5.陣列在記憶體中的存盤
二、陣列作為方法的引數
- 1.基本用法
- 2.理解參考型別
- - 2.1 傳內置型別
  - 2.2 傳參考型別
  - 2.3 認識 null
  - 2.4 初識 JVM 記憶體區域劃分
三、陣列作為方法的回傳值
四、陣列的拷貝
- 1.什么是包
- 1. for回圈拷貝
- 2. copyof拷貝
- 3. copyOfRange拷貝
- 4. arraycopy拷貝
- - 4.1 native：本地方法
- 5. clone拷貝
- 6.深拷貝和淺拷貝
五、陣列的練習（經典題型）
- 1.二分查找(折半查找)
- 2.陣列排序(冒泡排序）
- 3.判斷兩個陣列是否相等
- 4.陣列填充
六、二維陣列
- 1.定義二維陣列
- 2.二維陣列在記憶體中的存盤
- 3.二維陣列的列印方式
- - 3.1 for回圈列印
  - 3.2foreach列印
  - 3.3 deepToString(深度列印)
- 4.不規則的二維陣列
- - 1.不規則二維陣列的創建
  - 2.不規則的二維陣列在陣列中的存盤
完結！

一、陣列基本用法

1.什么是陣列

陣列就是一組相同型別的元素的集合
當我們需要定義多個變數時

	int a = 10;
	int b = 20;
	int c = 30;
	int d = 40;
	int e = 50;

如果定義幾十甚至幾百個變數，那么就不能這樣創建變數了，這個時候我們就需要用到陣列了

	int[] array = {10,20,30,40,50};

這就是創建了一個簡單的整形陣列

2.陣列的創建

在這里插入圖片描述
C語言的創建陣列方式

int array[] = {1,2,3,4,5};

java的創建陣列方式

int[] array = {1,2,3,4,5};

其實java中也可以使用C語言的創建陣列方式，但是我們還是更推薦寫成 int[] arr 的形式. int和 [] 是一個整體，這也是是一種語法規范吧！

3.定義陣列的方式

定義陣列共有三種方式
第一種：靜態初始化

	int[] array = {1,2,3,4,5};

第二種：動態初始化

	int[] array = new int[]{1,2,3,4,5};

第三種

	int[] array = new int[5];

注意：
1.靜態初始化的時候, 陣列元素個數和初始化資料的格式是一致的，
2.第一種和第二種定義，等號右邊的 [ ] 的里面不可以出現數字，
3.第一種和第二種陣列的大小就是里面資料的個數，

4.陣列的使用

4.1 獲取陣列的長度

通過陣列名.length 就可以獲取陣列的長度
注意：陣列的下標是從0開始的，使用 [ ] 就可以訪問陣列的元素，技能讀取資料也能修改資料，
在這里插入圖片描述

public class Test{
    public static void main(String[] args){

        int[] array = {1,2,3,4,5};
        array[0] = 10;
        System.out.println(array[0]);

    }
}

運行結果
在這里插入圖片描述

4.2 遍歷陣列的兩種方式

1.for回圈遍歷

public class Test{
    public static void main(String[] args){
        int[] array = {1,2,3,4,5};
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
    }
}

2.foreach遍歷

for (int x:array) {
	System.out.print(x+" ");
}

4.3 for回圈和foreach(增強for回圈)的區別

for回圈是可以拿到下標的
foreach是拿不到下標的
所以以后要看情況使用for回圈和foreach

foreach的遍歷原理：遍歷array陣列里面的每一個元素，把每一個元素取出來，然后賦值給x，最后列印x，直到array陣列全部遍歷完，

兩種遍歷的運行結果

public class Test{
    public static void main(String[] args){
        int[] array = {1,2,3,4,5};
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
        System.out.println();
        for (int x:array) {
            System.out.print(x+" ");
        }
    }
}

在這里插入圖片描述

4.4 以字串列印陣列

陣列的工具類：import java.util.Arrays
Arrays.toString(陣列名)
把你需要列印的陣列放到toString函式里面，那么就會把當前的陣列轉變為字串進行輸出！所以呼叫這個函式后，它的回傳值就是一個字串，

來看一個例子
在這里插入圖片描述
運行結果：可以看到陣列被連同方括號都被轉換成字串了

4.5 陣列下標越界訪問例外

當你創建的陣列長度只有5，你非要訪問5下標(數值的下標是從0開始) ，那就會出現下標越界訪問例外，
在這里插入圖片描述

就比如這里陣列只有5個元素最大下標是4，而而要去訪問下標5就是出現陣列越界訪問例外，

5.陣列在記憶體中的存盤

在JVM(JAVA虛擬機)中共有5塊記憶體，而我們平常所說的堆疊就是JAVA虛擬堆疊，區域變數和陣列名都是在堆疊上開辟記憶體的，
在這里插入圖片描述
陣列變數是一個參考
參考一般指向一個物件（當前你可以理解為，等號右邊的就是陣列物件）

來看一段代碼

public class Test{
    public static void main(String[] args){

        int[] array = {1,2,3,4,5};
        int[] array2 = new int[5];
        System.out.println(array);
        System.out.println(array2);
    }
}

運行結果
在這里插入圖片描述
運行后列印出兩個地址
注意：這兩個地址不是真正的地址，他是通過正式的地址hash得到的
但是你可以把它當做一個真實的地址，這兩個地址是唯一的（安全性）

二、陣列作為方法的引數

1.基本用法

代碼如下（示例）：

public class Test{
    public static void prints(int[] arr){
        for (int x:arr) {
            System.out.print(x+" ");
        }
    }
    public static void main(String[] args){
        int[] array = {1,2,3,4,5};
        prints(array);
    }
}

運行結果
在這里插入圖片描述
我這里用的是foreach遍歷整個陣列

int[ ] arr 是函式的形參, int[ ] array 是函式實參.
如果需要獲取到陣列長度, 同樣可以使用 a.length

2.理解參考型別

2.1 傳內置型別

代碼示例如下（傳內置型別）：

public class Test{
    public static void exchange(int n){
        n = 200;
        System.out.println("n= "+n);
    }
    public static void main(String[] args){
        int a = 100;
        exchange(a);
        System.out.println("a= "+a);
    }
}

運行結果：
在這里插入圖片描述

我們發現修改形參n的值，不影響實參a的值
在這里插入圖片描述

2.2 傳參考型別

代碼示例(傳陣列)：

public class Test{
    public static void exchange(int[] arr){
        int tmp = arr[0];
        arr[0] = arr[1];
        arr[1] = tmp;
    }
    public static void main(String[] args){
        int[] array = {10,20,30,40};
        System.out.println("交換前");
        System.out.println("array[0] = "+array[0]+" array[1] = "+array[1]);
        exchange(array);
        System.out.println("交換后");
        System.out.println("array[0] = "+array[0]+" array[1] = "+array[1]);
    }
}

運行結果：

在這里插入圖片描述
我們發現陣列組為引數傳參的話就能修改變數的值，我們前面說過array存盤的是地址，也就是說我們傳的是參考，
什么是參考?

參考相當于一個 “別名”, 也可以理解成一個指標.
創建一個參考只是相當于創建了一個很小的變數, 這個變數保存了一個整數,
這個整數表示記憶體中的一個地址

我們再通過圖來了解一下為社么傳參考就能修改實參呢？
在這里插入圖片描述
傳參考實際上就是傳的地址，通過地址找到同一塊空間，修改同一塊地址上的資料，自然就修改了，

總結：

所謂的 “參考” 本質上只是存了一個地址. Java 將陣列設定成參考型別, 這樣的話后續進行陣列引數傳參,
其實只是將陣列的地址傳入到函式形參中. 這樣可以避免對整個陣列的拷貝(陣列可能比較長, 那么拷貝開銷就會很大).

2.3 認識 null

null在java中表示 ”空參考“ ，表示不指向任何物件，也就是一個無效的參考，
參考型別的0值就是null
來看一個代碼：

public class Test{
    public static void exchange(int[] arr){
        int tmp = arr[0];
        arr[0] = arr[1];
        arr[1] = tmp;
    }
    public static void main(String[] args){
        int[] array = {10,20,30,40};
        exchange(null);
    }
}

運行結果：
在這里插入圖片描述

如果在傳參考時傳的時null就會報出例外， NullPointerException，null 的作用類似于 C 語言中的 NULL
(空指標), 都是表示一個無效的記憶體位置. 因此不能對這個記憶體進行任何讀寫操作，

那如果我們把陣列賦一個 null

public class Test{
    public static void main(String[] args){
        int[] array = null;
        System.out.println(array);
    }
}

運行結果
在這里插入圖片描述
我們發現并沒有列印0,而是列印null

那null的陣列能不能求長度呢？

public class Test{
    public static void main(String[] args){
        int[] array = null;
        System.out.println(array.length);
    }
}

運行結果
在這里插入圖片描述
我們發現這里也是一個空參考例外，從這我們可以知道，把null 賦給了 array，表示array沒有指向任何物件，所以它沒在堆上開辟空間，報出空參考例外，所以null.任何東西都會報出例外
總結：
當我們以后遇到 NullPointerException 都是空參考例外

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 開始, 運行時常量池在堆上)

總結：

1.JVM是多執行緒的，多執行緒就意味著高效率，
2.區域變數和參考保存在堆疊上, new 出的物件保存在堆上.
3.堆的空間非常大, 堆疊的空間比較小.
4.堆是整個 JVM 共享一個, 而堆疊每個執行緒具有一份(一個 Java 程式中可能存在多個堆疊)

三、陣列作為方法的回傳值

假設我們要實作一個方法，把陣列里的每個元素都加上1

import java.util.Arrays;

public class Test{
    public static void addOne(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] + 1;
        }
    }
    public static void main(String[] args){
        int[] array = {1,2,3,4,5};
        addOne(array);
        System.out.println(Arrays.toString(array));
    }
}

這種方法當然可以，但這會破壞原有的陣列，有時候我們不希望破壞原陣列, 就需要在方法內部創建一個新的陣列, 并由方法回傳出來.
來看一下代碼：

import java.util.Arrays;

public class Test{
    public static int[] addOne(int[] arr){
        int[] array2 = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            array2[i] = arr[i] + 1;
        }

        return array2;
    }
    public static void main(String[] args){
        int[] array = {1,2,3,4,5};
        int[] ret = addOne(array);
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(ret));
    }
}

運行結果：
在這里插入圖片描述
這樣的話就不會破壞原有陣列了.
另外由于陣列是參考型別, 回傳的時候只是將這個陣列的首地址回傳給函式呼叫者, 沒有拷貝陣列內容, 從而比較高效，

四、陣列的拷貝

1.什么是包

Java 中提供了 java.util.Arrays 包, 其中包含了一些操作陣列的常用方法.
那什么是包呢？簡單簡單點說，假設你煮面吃是不是要自己調配料，而方便面直接就有調料包，拿起來就用，不用像自己煮面一樣還要想怎么放才好吃，
像我們很多程式寫的程序中不必把所有的細節都自己實作, 已經有大量的標準庫(JDK提供好的代碼)和海量的第三方庫(其他機構組織提供的代碼)供我們直接使用. 這些代碼就放在一個一個的 “包” 之中.

有了這個包，我們只需要 Arrays. 就能使用JAVA提供的很多和陣列相關的方法，

1. for回圈拷貝

新創建一個陣列，再利用for回圈把以前的陣列拷貝到新陣列里，
注意：新開辟的陣列大小一定要大于或者等于原陣列的大小，

import java.util.Arrays;
public class Test{
    public static void main(String[] args){
        int[] array = {1,2,3,4,5};
        int[] arr = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            arr[i] = array[i];
        }
        System.out.println(Arrays.toString(arr));
    }
}

2. copyof拷貝

這是JAVA提供給我們的一種拷貝陣列的方法，先來看一下這個方法的源代碼
在這里插入圖片描述
這個方法需要兩個引數，一個要拷貝的陣列和新陣列的長度，
代碼示例：

import java.util.Arrays;

public class Test{
    public static void main(String[] args){
        int[] array = {1,2,3,4,5};
        int[] arr = Arrays.copyOf(array,10);
        System.out.println(Arrays.toString(arr));//以字串方式列印陣列
    }
}

運行結果：
在這里插入圖片描述
我們發現如果新陣列的長度大于要拷貝陣列的長度，多余的位置默認為0.

3. copyOfRange拷貝

同樣這也是Arrays提供的一種拷貝數的方法，源代碼如圖
在這里插入圖片描述

再來看一個例子

import java.util.Arrays;

public class Test{
    public static void main(String[] args){
        int[] array = {1,2,3,4,5};
        int[] arr = Arrays.copyOfRange(array,1,4);
        System.out.println(Arrays.toString(arr));
    }
}

運行結果
在這里插入圖片描述
因為拷貝范圍是左閉右開的，所以并沒有拷貝到5.
注意：如果超出拷貝陣列的范圍則超出的元素默認為0，且范圍是不能為負數的，

4. arraycopy拷貝

來看一下源代碼
在這里插入圖片描述
使用例子

import java.util.Arrays;

public class Test{
    public static void main(String[] args){
        int[] array = {1,2,3,4,5,6};
        int[] arr = new int[array.length];
        System.arraycopy(array,0,arr,0,6);
        System.out.println(Arrays.toString(arr));
    }
}

運行結果
在這里插入圖片描述
注意：這里的拷貝和上面的兩種方式是不一樣的，這種拷貝方式是不能越界的！如果你的陣列要拷貝的長度從你的起始下標起大于了陣列的長度（無論是起始陣列還是目的地陣列都是不能越界的），就會出現陣列下標越界例外，

4.1 native：本地方法

還有一個重點不知道大家注意沒，arraycopy這個方法的源代碼是沒有具體實作程序的，而且這個方法中有 native 這么一個關鍵字，這屬于本地方法
那么 native 這樣的方法有什么特點呢？

1.運行在本地方法堆疊上
2.底層是由C/C++寫的
3.這樣的方法速度是非常快的

所以我們以后拷貝陣列優先使用的是這種方法，因為它速度快，

5. clone拷貝

陣列名.clone直接產生一個陣列的副本

import java.util.Arrays;

public class Test{
    public static void main(String[] args){
        int[] array = {1,2,3,4,5};
        int[] arr = array.clone();
        System.out.println(Arrays.toString(arr));
    }
}

在這里插入圖片描述

6.深拷貝和淺拷貝

深拷貝：修改拷貝之后的陣列不會影響原陣列
淺拷貝：修改拷貝之后的陣列會影響原陣列

如何達到深拷貝：對物件本身進行拷貝
我們剛剛的例子都屬于深拷貝
因為JAVA以后是面向物件，陣列里一般放的都是物件很少放整形，如果要細說，那么就分基本型別和參考型別，
如果陣列里放的是基本資料型別那就是深拷貝，如果陣列里放的是參考型別那就是淺拷貝，

五、陣列的練習（經典題型）

1.二分查找(折半查找)

二分查找只能用于一組有序陣列(升序或者降序)
以升序陣列為例, 二分查找的思路是先取中間位置的元素, 看要找的值比中間元素大還是小. 如果小, 就去左邊找; 否則就去右邊找.

import java.util.Scanner;
public class Test{
    public static int binarySearch(int[] array,int n){
        if(array == null) return -1;

        int left = 0;
        int right = array.length-1;
        while(left<=right){
            int mid = left+(right-left)/2;
            if(array[mid]>n){//當要找的數比中間那個數小
                right = mid-1;
            }else if(array[mid]<n){//當要找的數比中間那個數大
                left = mid+1;
            }else{
                return mid;//找到了回傳下標
            }
        }

        return -1;//沒找到時
    }
    public static void main(String[] args){
        int[] array = {1,2,3,4,5,6,7,8,9};
        System.out.println("請輸入年喲查找的數字");
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int ret = binarySearch(array,n);
        if(ret == -1){
            System.out.println("沒找到");
        }else{
            System.out.println("找到了下標為"+ret);
        }
    }
}

JAVA還提供了一個二分查找的方法binarySearch
源代碼就不看了，和上面的實作方法類似
同樣是兩個引數，一個是要查找的陣列，一個則是要查找的數字，
如果找到了就放回該數字的下標，沒找到就放回一個負數，
來看一下代碼

import java.util.Arrays;
import java.util.Scanner;
public class Test{
    public static void main(String[] args){
        int[] array = {1,2,3,4,5,6,7,8,9};
        System.out.println("請輸入年喲查找的數字");
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int ret = Arrays.binarySearch(array,n);//呼叫方法
        if(ret < 0){
            System.out.println("沒找到");
        }else{
            System.out.println("找到了下標為"+ret);
        }
    }
}

2.陣列排序(冒泡排序）

給定一個陣列把它排列成升序或者降序
思路：兩兩相比較交換位置，把最大或者最小的數字放到最后，

import java.util.Arrays;
import java.util.Scanner;
public class Test{
    public static void bubbleSort(int[] array){
        if(array == null) return;
        boolean flag = false;//定義個flag判斷陣列是否有序
        for (int i = 0; i < array.length-1; i++) {
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j] > array[j+1]){
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    flag = true;
                }
            }
            if(flag != true){//當陣列已經是有序時直接跳出回圈
                break;
            }
        }
    }
    public static void main(String[] args){
        int[] array = {2,3,1,5,6,4,3,2,1};
        System.out.println(Arrays.toString(array));
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }
}

3.判斷兩個陣列是否相等

JAVA中提供了一個方法 equals 用來判斷兩個陣列是否相等
在這里插入圖片描述
可以看到equals的回傳型別是布爾型別，相等回傳true不相等回傳false
代碼示例：

import java.util.Arrays;
public class Test{
    public static void main(String[] args){
        int[] array = {1,2,3,4,5};
        int[] arr = {1,2,3,4,5};
        boolean bool = Arrays.equals(array,arr);
        System.out.println(bool);

    }
}

4.陣列填充

JAVA中還提供整體填充的方法 fillc ，把陣列里的元素替換成指定元素，可適用各種型別，

import java.util.Arrays;
public class Test{
    public static void main(String[] args){
        int[] arr = {1,2,3,4,5};
        Arrays.fill(arr,6);
        System.out.println(Arrays.toString(arr));
    }
}

運行結果：
在這里插入圖片描述
該函式還能指定下標替換，記住下標是不能越界的，

運行結果：

在這里插入圖片描述

六、二維陣列

1.定義二維陣列

在JAVA中常見的定義陣列方式，JAVA中二維陣列可以省略列，不能省略行，

		int[][] array = {{1,2},{3,4},{5,6}};
        int[][] array2 = new int[3][2];
        int[][] array3 = new int[][]{{1,2},{3,4},{5,6}};

2.二維陣列在記憶體中的存盤

我們知道二維陣列其實就是一個特殊的一維陣列，那么它在記憶體中到底是怎么存盤的呢？
在這里插入圖片描述
每一行構成了一個一維陣列，陣列里的每一個元素存的都是指向每一列一維陣列的地址，
每一列的一維陣列存的則是指向資料的地址，

3.二維陣列的列印方式

3.1 for回圈列印

我們知道陣列名.length求的是陣列的長度，而二維陣列名.length求的則是拿到得是每一列的地址，那么求每一列的長度則是陣列名[i].length，

public class Test{
    public static void main(String[] args){
        int[][] array = {{1,2,3},{3,4,5},{5,6,7}};
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]+" ");
            }
            System.out.println();
        }
    }
}

3.2foreach列印

第一層foreach是遍歷整個array陣列，因為二維陣列的陣列名都是得地址，拿到每一列得地址也就是相當于拿到了一個一維陣列，通過第二次foreach回圈就可以拿到每一個元素

public class Test{
    public static void main(String[] args){
        int[][] array = {{1,2,3},{3,4,5},{5,6,7}};
        for (int[] arr:array) {
            for (int x:arr) {
                System.out.print(x+" ");
            }
            System.out.println();
        }
    }
}

3.3 deepToString(深度列印)

改方法是用來把二維陣列轉換為字串的，它的回傳型別為String

import java.util.Arrays;
public class Test{
    public static void main(String[] args){
        int[][] array = {{1,2,3},{3,4,5},{5,6,7}};
        System.out.println(Arrays.deepToString(array));
    }
}

運行結果：

在這里插入圖片描述

4.不規則的二維陣列

我們前面說過二維陣列的列是可以省略的，但如果省略那這個二維陣列能列印嗎？

public class Test{
    public static void main(String[] args){
        int[][] array = new int[3][];
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);
            }
            System.out.println();
        }
    }
}

運行結果
在這里插入圖片描述
看到了我們熟悉的空參考例外，那這是什么原因呢？
我們知道二維陣列名.length拿到的是地址，而現在陣列沒有指定列，所以里面存的是null，當我們array[ i ].length 的時候就出現了例外，前面也說過 null.任何東西都會出現例外，

在這里插入圖片描述

1.不規則二維陣列的創建

因為二維陣列一般都是行和列都已經寫好了，而不規則的二維陣列在定義時把列給省略掉了，所以沒一行的列數可以有自己定，

public class Test{
    public static void main(String[] args){
        int[][] array = new int[3][];
        array[0] = new int[1];
        array[1] = new int[2];
        array[2] = new int[4];
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]+" ");
            }
            System.out.println();
        }
    }
}

運行結果

在這里插入圖片描述

public class Test{
    public static void main(String[] args){
        int[][] array = new int[3][];
        array[0] = new int[1];
        array[1] = new int[]{2,2,2};
        array[2] = new int[]{1,2,3,4};
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]+" ");
            }
            System.out.println();
        }
    }
}

運行結果：
在這里插入圖片描述

2.不規則的二維陣列在陣列中的存盤

不規則的二維陣列和普通的二維陣列沒什么區別
在這里插入圖片描述

陣列詳解就到這里，記得點個贊再走！

完結！

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/280345.html

標籤：java

上一篇：JAVA 中的 IO流、位元組流、字符流、緩沖流、轉換流、序列流、列印流

下一篇：從零開始的java面試題（【2021】 java基礎篇）

java陣列創建使用拷貝超全詳解

文章目錄

一、陣列基本用法

1.什么是陣列

2.陣列的創建

3.定義陣列的方式

4.陣列的使用

4.1 獲取陣列的長度

4.2 遍歷陣列的兩種方式

4.3 for回圈和foreach(增強for回圈)的區別

4.4 以字串列印陣列

4.5 陣列下標越界訪問例外

5.陣列在記憶體中的存盤

二、陣列作為方法的引數

1.基本用法

2.理解參考型別

2.1 傳內置型別

2.2 傳參考型別

2.3 認識 null

2.4 初識 JVM 記憶體區域劃分

三、 陣列作為方法的回傳值

四、陣列的拷貝

1.什么是包

1. for回圈拷貝

2. copyof拷貝

3. copyOfRange拷貝

4. arraycopy拷貝

4.1 native：本地方法

5. clone拷貝

6.深拷貝和淺拷貝

五、陣列的練習（經典題型）

1.二分查找(折半查找)

2.陣列排序(冒泡排序）

3.判斷兩個陣列是否相等

4.陣列填充

六、二維陣列

1.定義二維陣列

2.二維陣列在記憶體中的存盤

3.二維陣列的列印方式

3.1 for回圈列印

3.2foreach列印

3.3 deepToString(深度列印)

4.不規則的二維陣列

1.不規則二維陣列的創建

2.不規則的二維陣列在陣列中的存盤

完結！

三、陣列作為方法的回傳值