Java陣列詳解

目錄

一.陣列的概念

二.創建陣列

三.陣列的使用

四.陣列的遍歷

五.陣列作為方法的引數

六.陣列相關方法Arrays

在我們了解陣列這個概念之前，我們先思考下面幾個問題，

如果我們需要兩個資料，那么直接創建兩個變數即可

int a;
int b;

如果需要五個資料，那么可以創建五個變數

int a;
int b;
int c;
int d;
int f;

但如果我們需要100個甚至是1萬個資料，那么我們創一萬個變數？顯然這是不現實的，這個時候就需要我們的陣列來起作用！幫我們“批量”創建變數，

由上可以得出：陣列的本質就是讓我們能“批量”創建相同型別的變數！

陣列

一.陣列的概念

陣列是一種資料結構，用來存盤同一型別的集合，也就是說陣列包含的變數必須是相同型別！

二.創建陣列

基本語法如下：

//動態初始化
資料型別[] 陣列名稱 = new 資料型別 []{初始化資料};
//靜態初始化
資料型別[] 陣列名稱 = {初始化資料};

代碼示例

public class TestDemo {
    public static void main(String[] args) {
        //動態初始化
        //資料型別[] 陣列名稱 = new 資料型別 []{初始化資料};
        int[] arr1 = new int[]{1,2,3};
        //靜態初始化
        //資料型別[] 陣列名稱 = {初始化資料};
        int[] arr2 ={1,2,3};
    }
}

注意：靜態初始化的時候，陣列元素的個數和初始化資料的格式是一樣的！

如果你學過其他語言，例如C語言，c語言的陣列創建是這樣的

資料型別 陣列名[]={初始化資料};

例如： int arr[] = {1,2,3};

其實Java中也可以做到這樣，但是不推薦這么寫，Java是一種強型別語言，變數前面就是型別，一目了然！

三.陣列的使用

我們看一個例子，如何獲取陣列的長度？

如果你學過C語言，那么肯定會說

int sz = sizeof(arr) / sizeof(arr[0]);

其實Java比c語言更方便，直接使用“陣列名.length”就可以求出來陣列的長度，

代碼如下：

public class TestDemo {
    public static void main(String[] args) {
         int[] arr ={1,2,3};
         int len = arr.length;
        System.out.println(len);//3
    }
}

毫無疑問這個代碼運行結果是3；

那么我們如何訪問陣列元素呢？

我們來看下面的代碼：

public class TestDemo {
    public static void main(String[] args) {
         int[] arr ={1,2,3};
         int len = arr.length;
        System.out.println(len);//3
        System.out.println(arr[0]);//1
        System.out.println(arr[1]);//2
        System.out.println(arr[2]);//3
    }
}

顯而易見的是，直接使用陣列名[陣列元素下標]來訪問陣列元素，但出現了一個問題，為什么arr[0]是1而arr[1]是2？為什么不是arr[1]是1 arr[2]是2嗎？

這里我們得出一個結論，陣列的下標是從0開始的，不是從1開始的，

我們來嘗試訪問一下arr[3]看會出現什么情況.

public class TestDemo {
    public static void main(String[] args) {
         int[] arr ={1,2,3};
         int len = arr.length;
        System.out.println(len);//3
        System.out.println(arr[0]);//1
        System.out.println(arr[1]);//2
        System.out.println(arr[2]);//3
        System.out.println(arr[3]);
    }
}

我們發現前面都和我們預想一樣輸出結果都正確，但唯獨出現了一串紅字，這串紅字說明存在陣列越界，

我們由此得出一個結論：在Java下標訪問操作中不能超出有效范圍也就是[0,length-1],如果超出有效范圍，會拋出下標越界例外，

四.陣列的遍歷

所謂遍歷，是指將陣列中的所有元素都訪問一遍，不重不漏，需要搭配回圈陳述句！

我們學了陣列的訪問，那么我們如何遍歷陣列呢？有兩種常用方法 一種是for回圈，一種是foreach回圈，

for回圈示例

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

我們發現列印出來了陣列的元素，
for-each示例

foreach基本使用方法：元素型別 變數：陣列名

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

執行結果一致，

那么我們什么時候使用for回圈，什么時候使用foreach回圈？

foreach回圈適用于不知道回圈次數，或者是回圈次數很難計算，

for回圈適用于知道回圈次數，在復雜的回圈中效率更高，

如果是在回圈中使用增刪查改操作，for回圈可以實作，因為foreach回圈不能實作這些操作，

五.陣列作為方法的引數

基本用法：

1.列印陣列內容

代碼示例：

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

2.求陣列元素的和

public class TestDemo {
    public static int sum(int []arr) {
        int sum = 0;//一定要初始化為0，不然是隨機值
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }

    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        int ret = sum(arr);
        System.out.println(ret);
    }
}

3.陣列每個元素乘2輸出

public class TestDemo {
    public static void multiplication(int[] arr){
        for(int i = 0 ;i < arr.length;i++){
            arr[i]=arr[i]*2;
        }
    }
    public static void printArray(int[] arr){
        for(int x:arr){
            System.out.print(x+" ");
        }
    }
    public static void main(String[] args) {
        int [] arr = {1,2,3,4};
        System.out.println("乘2前:");
        printArray(arr);
        System.out.println();
        System.out.println("乘2后:");
        multiplication(arr);
        printArray(arr);
    }
}

六.陣列相關方法Arrays

Arrays是操作Java陣列的工具類，

如果要對陣列做什么事情，可以通過它來做，當然，有些事情是它做不了的，但是只要它能做到，我們呼叫它就OK，

1.陣列轉字串：使用Arrays.toString();

import java.util.Arrays;

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

這個方法列印出來是以字串形式列印，把我們要列印的陣列，放到toString里面，那么就會幫我們把當前陣列，轉變為字串進行輸出

2.陣列拷貝

如何將陣列拷貝？最直觀的方法是創建一個與當前陣列大小相同，型別相同的陣列，使用回圈一個一個賦值，但Java中存在一些方法可以直接拷貝，

使用Arrays.copyOf(陣列名，陣列的長度）；

import java.util.Arrays;

public class TestDemo {
    public static void main(String[] args) {
        int[] arr1 ={1,2,3,4,5,6};
        int[] arr2 = Arrays.copyOf(arr1,arr1.length);
        System.out.println("拷貝的陣列元素為:"+Arrays.toString(arr2));
    }
}

范圍拷貝使用Arrays.copyOfRange(陣列名，從開始下標，到結束下標）

import java.util.Arrays;

public class TestDemo {
    public static void main(String[] args) {
        int[] arr1 = {1,2,3,4,5,6};
        int[] arr2 = Arrays.copyOfRange(arr1,1,3);
        System.out.println("范圍拷貝的陣列內容為:"+Arrays.toString(arr2));
    }
}

注意：copyOfRange函式中，陣列元素依然是從下標為0開始，且最后一個引數是取不到的，也就是說是取[1,3)左閉右開的元素，

3.陣列排序

如果你學過C++，那么一定會對sort函式很熟悉，C++中sort函式使用代碼示例如下

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100;

int main()
{
	int arr[N];
	int n = 0;
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		cin >> arr[i];
	}
	sort(arr,arr+n);
	for (int i = 0; i < n; i++)
	{
		cout << arr[i] << ' ';
	}
	return 0;
}

而Java中也存在這樣的函式：Arrays.sort

import java.util.Arrays;

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

我們可以看到，sort函式均是以升序排列，

4.陣列查找

①.順序查找：

public class TestDemo {
    public static int find(int[] arr,int x){
        for(int i = 0;i<arr.length;i++){
            if(arr[i]==x) return i;
        }
        return -1;//表示沒有找到
    }
    public static void main(String[] args) {
        int [] arr = {1,2,3,4,5};
        System.out.println(find(arr,10));
    }
}

②.二分查找

手動實作：

public class TestDemo {
    public static int binarySearch(int [] arr,int x){
        int left = 0;
        int right = arr.length-1;
        while(left<=right){
            int mid = left+right>>1;
            if(x<arr[mid]){
                //表示在左邊
                right=mid-1;
            }
            else if(x>arr[mid]){
                //表示在右邊
                left = mid + 1;
            }
            else {
                //相等說明找到
                return mid;
            }
        }
        return -1;//回圈結束，說明沒找到;
    }
    public static void main(String[] args) {
        int [] arr = {1,2,3,4,5};
        System.out.println(binarySearch(arr,4));
    }
}

但Java中 這個方法以及被封裝好了 我們可以使用Arrays.binarySearch(陣列名，要找的元素);來實作

import java.util.Arrays;

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

以上就是Java的陣列講解，感謝觀看，