javaSE中數(shù)組的概念與使用詳細教程

更新時間：2023年08月15日 09:28:39 作者：paper?jie

這篇文章主要給大家介紹了關(guān)于javaSE中數(shù)組的概念與使用的相關(guān)資料,數(shù)組在內(nèi)存中是一段連續(xù)的空間,空間的編號都是從0開始的,依次遞增,該編號稱為數(shù)組的下標,需要的朋友可以參考下

數(shù)組的概念

什么是Java中的數(shù)組

數(shù)組：可以看成是相同類型元素的一個集合。在內(nèi)存中是一段連續(xù)的空間。在java中，包含6個整形類型元素的數(shù)組，可以看做是酒店中連續(xù)的6個房間.

1. 數(shù)組中存放的元素其類型相同

2. 數(shù)組的空間是連在一起的

3. 每個空間有自己的編號，其實位置的編號為0，即數(shù)組的下標

數(shù)組的創(chuàng)建和初始化

數(shù)組的創(chuàng)建

topy[] 數(shù)組名 = new array[n];

topy：表示數(shù)組中存放元素的類型

topy[]：表示數(shù)組的類型

n：表示數(shù)組的長度

int[] array1 = new int[10]; // 創(chuàng)建一個可以容納10個int類型元素的數(shù)組
double[] array2 = new double[5]; // 創(chuàng)建一個可以容納5個double類型元素的數(shù)組
String[] array3 = new double[3]; // 創(chuàng)建一個可以容納3個字符串元素的數(shù)組

數(shù)組的初始化

數(shù)組的初始化主要分為動態(tài)初始化以及靜態(tài)初始化

動態(tài)初始化：在創(chuàng)建數(shù)組的時侯，直接指定數(shù)組中的元素個數(shù)

int[] array = new int[10];

靜態(tài)初始化：在創(chuàng)建數(shù)組的時候，不直接指定元素個數(shù)，但是直接將具體的數(shù)據(jù)放入數(shù)組中

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

栗子：

int[] array1 = new int[]{0,1,2,3,4,5,6,7,8,9};
double[] array2 = new double[]{1.0, 2.0, 3.0, 4.0, 5.0};
String[] array3 = new String[]{"hell", "Java", "!!!"};

注意：

靜態(tài)初始化雖然沒有指定數(shù)組的長度，編譯器在編譯時會根據(jù){}中元素個數(shù)來確定數(shù)組的長度。

靜態(tài)初始化時, {}中數(shù)據(jù)類型必須與[]前數(shù)據(jù)類型一致。

靜態(tài)初始化可以簡寫，省去后面的new T[]。

這里靜態(tài)和動態(tài)初始化也可以分為兩步，但是省略格式不可以

int[] array1;
array1 = new int[10];
int[] array2;
array2 = new int[]{10, 20, 30};
// 注意省略格式不可以拆分, 否則編譯失敗
// int[] array3;
// array3 = {1, 2, 3};

如果沒有對數(shù)組進行初始化，數(shù)組中元素有其默認值

如果數(shù)組中存儲元素類型為基類類型，默認值為基類類型對應(yīng)的默認值

如果數(shù)組中存儲元素類型為引用類型，默認值為null

數(shù)組的使用

數(shù)組中元素的訪問

數(shù)組在內(nèi)存中是一段連續(xù)的空間，空間的編號都是從0開始的，依次遞增，該編號稱為數(shù)組的下標，數(shù)組可以通過下標訪問其任意位置的元素

int[]array = new int[]{10, 20, 30, 40, 50};
System.out.println(array[0]);
System.out.println(array[1]);
System.out.println(array[2]);
System.out.println(array[3]);
System.out.println(array[4]);
// 也可以通過[]對數(shù)組中的元素進行修改
array[0] = 100;
System.out.println(array[0]);

注意：數(shù)組是一段連續(xù)的內(nèi)存空間，因此支持隨機訪問，即通過下標訪問快速訪問數(shù)組中任意位置的

下標從0開始，介于[0, N）之間不包含N，N為元素個數(shù)，不能越界，否則會報出下標越界常。

遍歷數(shù)組

遍歷就是說將數(shù)組中的所有元素都訪問一遍，訪問可以將數(shù)組的所有元素進行打印。

栗子：這里我們通過循環(huán)遍歷來賦值和打印，也可以使用foreach來遍歷打印。

for-each 是 for 循環(huán)的另外一種使用方式. 能夠更方便的完成對數(shù)組的遍歷. 可以避免循環(huán)條件和更新語句寫錯

   public static void main(String[] args) {
        int[] array = new int[10];
        //通過遍歷賦值
        for (int i = 0; i < array.length; i++) {
            array[i] = i+1;
        }
        //循環(huán)遍歷打印
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        //用foreach遍歷
        for (int x: array) {
            System.out.print(x);
        }

注意：在數(shù)組中可以通過數(shù)組對象.length 來獲取數(shù)組的長度

引用類型 - 數(shù)組

JVM的內(nèi)存分布

內(nèi)存是一段連續(xù)的存儲空間，主要用來存儲程序運行時數(shù)據(jù)的，

1. 程序運行時代碼需要加載到內(nèi)存

2. 程序運行產(chǎn)生的中間數(shù)據(jù)要存放在內(nèi)存

3. 程序中的常量也要保存

4. 有些數(shù)據(jù)可能需要長時間存儲，而有些數(shù)據(jù)當方法運行結(jié)束后就要被銷毀

所以呢，JVM也對所使用的內(nèi)存按照功能的不同進行了劃分：

這里介紹一下上面的幾個區(qū)分：

程序計數(shù)器: 只是一個很小的空間, 保存下一條執(zhí)行的指令的地址

虛擬機棧: 與方法調(diào)用相關(guān)的一些信息，每個方法在執(zhí)行時，都會先創(chuàng)建一個棧幀，棧幀中包含有：局部變量表、操作數(shù)棧、動態(tài)鏈接、返回地址以及其他的一些信息，保存的都是與方法執(zhí)行時相關(guān)的一些信息。比如：局部變量。當方法運行結(jié)束后，棧幀就被銷毀了，即棧幀中保存的數(shù)據(jù)也被銷毀了。

本地方法棧: 本地方法棧與虛擬機棧的作用類似. 只不過保存的內(nèi)容是Native方法的局部變量. 在有些版本的 JVM 實現(xiàn)中(例如HotSpot), 本地方法棧和虛擬機棧是一起的

堆: JVM所管理的最大內(nèi)存區(qū)域. 使用 new 創(chuàng)建的對象都是在堆上保存 (例如前面的 new int[]{1, 2,3} )，堆是隨著程序開始運行時而創(chuàng)建，隨著程序的退出而銷毀，堆中的數(shù)據(jù)只要還有在使用，就不會被銷毀。

方法區(qū): 用于存儲已被虛擬機加載的類信息、常量、靜態(tài)變量、即時編譯器編譯后的代碼等數(shù)據(jù). 方法編譯出的的字節(jié)碼就是保存在這個區(qū)域

基本類型變量與引用類型變量的區(qū)別

基本數(shù)據(jù)類型創(chuàng)建的變量，稱為基本變量，該變量空間中直接存放的是其所對應(yīng)的值；

而引用數(shù)據(jù)類型創(chuàng)建的變量，一般稱為對象的引用，其空間中存儲的是對象所在空間的地址。

下面的代碼，a、b、arr，都是函數(shù)內(nèi)部的變量，因此其空間都在main方法對應(yīng)的棧幀中分配。a、b是內(nèi)置類型的變量，因此其空間中保存的就是給該變量初始化的值。array是數(shù)組類型的引用變量，其內(nèi)部保存的內(nèi)容可以簡單理解成是數(shù)組在堆空間中的首地址。

public static void func() {
int a = 10;
int b = 20;
int[] arr = new int[]{1,2,3};
}

從上圖可以看到，引用變量并不直接存儲對象本身，可以簡單理解成存儲的是對象在堆中空間的起始地址。通過該地址，引用變量便可以去操作對象。有點類似C語言中的指針，但是Java中引用要比指針的操作更簡單

具體分析引用變量

public static void func() {
int[] array1 = new int[3];
array1[0] = 10;
array1[1] = 20;
array1[2] = 30;
int[] array2 = new int[]{1,2,3,4,5};
array2[0] = 100;
array2[1] = 200;
array1 = array2;
array1[2] = 300;
array1[3] = 400;
array2[4] = 500;
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i]);
}
}

java中的null

null 在 Java 中表示 "空引用" , 也就是一個不指向?qū)ο蟮囊?nbsp;

int[] arr = null;
System.out.println(arr[0]);
// 執(zhí)行結(jié)果
Exception in thread "main" java.lang.NullPointerException
at Test.main(Test.java:6)

null 的作用類似于 C 語言中的 NULL (空指針), 都是表示一個無效的內(nèi)存位置. 因此不能對這個內(nèi)存進行任何讀寫操作. 一旦嘗試讀寫, 就會拋出 NullPointerException.（可以理解為空指針異常）

Java 中并沒有約定 null 和 0 號地址的內(nèi)存有任何關(guān)聯(lián)

數(shù)組的應(yīng)用

保存數(shù)據(jù)

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

作為函數(shù)的參數(shù)

函數(shù)傳基本類型：

public static void main(String[] args) {
int num = 0;
func(num);
System.out.println("num = " + num);
}
public static void func(int x) {
x = 10;
System.out.println("x = " + x);
} /
/ 執(zhí)行結(jié)果
x = 10
num = 0

這里在func方法中修改形參 x 的值, 不影響實參的 num 值

參數(shù)傳數(shù)組類型，也就是引用類型：

public static void main(String[] args) {
int[] arr = {1, 2, 3};
func(arr);
System.out.println("arr[0] = " + arr[0]);
}
public static void func(int[] a) {
a[0] = 10;
System.out.println("a[0] = " + a[0]);
}
 // 執(zhí)行結(jié)果
a[0] = 10
arr[0] = 10

發(fā)現(xiàn)在func方法內(nèi)部修改數(shù)組的內(nèi)容, 方法外部的數(shù)組內(nèi)容也發(fā)生改變.因為數(shù)組是引用類型，按照引用類型來進行傳遞(可以理解為傳的是地址)，是可以修改其中存放的內(nèi)容的

總結(jié): 所謂的 "引用" 本質(zhì)上只是存了一個地址. Java 將數(shù)組設(shè)定成引用類型, 這樣的話后續(xù)進行數(shù)組參數(shù)傳參, 其實只是將數(shù)組的地址傳入到函數(shù)形參中. 這樣可以避免對整個數(shù)組的拷貝(數(shù)組可能比較長, 那么拷貝開銷就會很大)

作為函數(shù)的返回值

直接上代碼：

求斐波那契數(shù)的前n項：

public class TestArray {
public static int[] fib(int n){
if(n <= 0){
return null;
} in
t[] array = new int[n];
array[0] = array[1] = 1;
for(int i = 2; i < n; ++i){
array[i] = array[i-1] + array[i-2];
} r
eturn array;
}
public static void main(String[] args) {
int[] array = fib(10);
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}

數(shù)組練習(xí)

數(shù)組變字符串

使用Java 中提供了 java.util.Arrays 包：

    public static void main5(String[] args) {
        int[] array ={1,2,3,4,5,5,7,8};
       String Arr =  Arrays.toString(array);
       //String Arr = My_Arrays(array);
        System.out.println(Arr);
    }

自己定義一個方法：

    public static void main5(String[] args) {
        int[] array ={1,2,3,4,5,5,7,8};
       //String Arr =  Arrays.toString(array);
       String Arr = My_Arrays(array);
        System.out.println(Arr);
    }
    public static String My_Arrays(int[] array) {
        if(array.length == 0) {
            return "[]";
        }
        String ret = "[";
        for (int i = 0; i < array.length; i++) {
            ret += array[i];
            if(i < array.length - 1) {
                ret += ",";
            }
        }
        ret += "]";
        return ret;
    }

數(shù)組拷貝

使用了Arrays包中的拷貝方法去：

    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6,7,8,9,10};
        int[] newArr = new  int[10];
        newArr = Arrays.copyOf(array, array.length);
        for (int i = 0; i < array.length; i++) {
            System.out.print(newArr[i] + " ");
        }
    }

區(qū)域拷貝：

    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6,7,8,9,10};
        int[] newArr = new int[10];
        newArr = Arrays.copyOf(array, array.length);
        int[] newArr2 = new int[10];
        newArr2 = Arrays.copyOfRange(array, 2, 5);
        for (int i = 0; i < array.length; i++) {
            System.out.print(newArr[i] + " ");
        }
        System.out.println();
        for (int i = 0; i < 3; i++) {
            System.out.print(newArr2[i] + " ");
        }
    }

二維數(shù)組

Java中的二維數(shù)組本質(zhì)上也是一維數(shù)組，每個元素又是一個一維數(shù)組。

基本語法：

數(shù)據(jù)類型[][] 數(shù)組名稱 = new 數(shù)據(jù)類型 [行數(shù)][列數(shù)] { 初始化數(shù)據(jù) };

栗子：

int[][] arr = {{1, 2, 3, 4},{5, 6, 7, 8},{9, 10, 11, 12}};
for (int row = 0; row < arr.length; row++) {
for (int col = 0; col < arr[row].length; col++) {
System.out.printf("%d\t", arr[row][col]);
} System.out.println("");
}

這里大家要記住一個點：二維數(shù)組中的行標存的就是對應(yīng)每一列的地址，通過地址來找到它們，可以將int[i] arr看做地址。其他的，二維數(shù)組的用法和一維數(shù)組就沒有明顯差別了。