大家好！?? 咱們?cè)诰幊虝r(shí)，經(jīng)常需要處理一批相同類型的數(shù)據(jù)，比如班級(jí)里所有同學(xué)的成績 ??、一周每天的最高氣溫 ???、或者購物車?yán)锏纳唐妨斜???。如果為每個(gè)數(shù)據(jù)都聲明一個(gè)單獨(dú)的變量（score1, score2, score3…），那代碼不得寫“瘋”了？??

這時(shí)候，就輪到 Java 中的一個(gè)基礎(chǔ)且重要的數(shù)據(jù)結(jié)構(gòu)登場了——數(shù)組 (Array)！你可以把它 想象成一排帶編號(hào)的儲(chǔ)物柜 或者一個(gè)雞蛋托 ??，專門用來整齊地存放 多個(gè)相同類型 的數(shù)據(jù)。今天，我們就來把數(shù)組這個(gè)“老朋友”徹底搞明白！

一、 數(shù)組到底是個(gè)啥？??

簡單來說，數(shù)組就是一個(gè)固定大小的容器 ??，里面存放的元素必須是相同的數(shù)據(jù)類型。

幾個(gè)關(guān)鍵特性要記?。?/p>

• 類型統(tǒng)一：一個(gè) int 數(shù)組里只能放 int，一個(gè) String 數(shù)組里只能放 String。不能混裝！??
• 長度固定 : 數(shù)組一旦創(chuàng)建，它的長度（能裝多少個(gè)元素）就不能再改變了！這是數(shù)組最核心的限制之一 ??。
• 連續(xù)存儲(chǔ) (通常): 在內(nèi)存中，數(shù)組的元素通常是連續(xù)存放的，這使得通過索引訪問元素非常快 ??。
• 索引訪問 : 每個(gè)元素都有一個(gè)唯一的索引（編號(hào)），從 0 開始！通過索引可以快速定位和訪問元素。

二、 創(chuàng)建和使用數(shù)組 ??

怎么在代碼里用數(shù)組呢？主要分兩步：聲明和初始化。

2.1 聲明數(shù)組引用

告訴編譯器：“我要一個(gè)能指向某種類型數(shù)組的變量”。

// 推薦的聲明方式
int[] scores;
String[] names;
double[] prices;
// C/C++ 風(fēng)格的聲明方式 (也能用，但不推薦)
// int scores[];
// String names[];

注意：這只是聲明了一個(gè)引用變量，它現(xiàn)在還是 null，并沒有指向任何實(shí)際的數(shù)組內(nèi)存空間。

2.2 初始化數(shù)組（分配空間/賦值）

初始化才是真正創(chuàng)建數(shù)組對(duì)象、分配內(nèi)存空間的時(shí)候。有兩種主要方式：

方式一：使用 new 指定長度

這是最常用的方式，你知道需要多大的數(shù)組，但還不確定里面的具體值。

// 創(chuàng)建一個(gè)能存放 5 個(gè) int 的數(shù)組
scores = new int[5]; // 分配了 5 個(gè) int 的空間
// 創(chuàng)建一個(gè)能存放 10 個(gè) String 的數(shù)組
names = new String[10]; // 分配了 10 個(gè) String 引用的空間
// 聲明和初始化可以合并
double[] salaries = new double[50];

重點(diǎn)??: 使用 new 創(chuàng)建數(shù)組后，里面的元素會(huì)被自動(dòng)賦予默認(rèn)值：

• 數(shù)值類型 (int, double etc.): 0 或 0.0
• boolean: false
• char: \u0000 (空字符)
• 引用類型 (String, Object etc.): null

方式二：靜態(tài)初始化 (直接提供元素值)

如果你在創(chuàng)建數(shù)組時(shí)就已經(jīng)知道里面要放哪些元素了，可以用這種更簡潔的方式。編譯器會(huì)根據(jù)你提供的值自動(dòng)確定數(shù)組的長度。

// 直接提供初始值，長度由編譯器確定 (這里是 4)
int[] initialScores = {90, 85, 92, 78};
// 聲明和靜態(tài)初始化合并
String[] weekdays = {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday"};
// 不能分開寫！下面這樣是錯(cuò)誤的 ?
// int[] numbers;
// numbers = {1, 2, 3}; // 編譯錯(cuò)誤
// 必須這樣寫：
int[] numbers;
numbers = new int[]{1, 2, 3}; // 或者聲明時(shí)就初始化

2.3 訪問數(shù)組元素：靠索引 [] ??

數(shù)組的核心操作就是通過索引來存取元素。記?。?strong>索引從 0 開始！ 非常非常重要！ ??

public class ArrayAccess {
    public static void main(String[] args) {
        String[] fruits = {"Apple <??>", "Banana <??>", "Orange <??>"}; // 長度為 3
        // 訪問元素 (索引 0, 1, 2)
        System.out.println("First fruit: " + fruits[0]); // Apple <??> (索引 0)
        System.out.println("Second fruit: " + fruits[1]); // Banana <??> (索引 1)
        System.out.println("Third fruit: " + fruits[2]); // Orange <??> (索引 2)
        // 修改元素
        fruits[1] = "Grape <??>"; // 把第 2 個(gè)元素 (索引 1) 改成 Grape
        System.out.println("Second fruit now: " + fruits[1]); // Grape <??>
        // 嘗試訪問不存在的索引？后果很嚴(yán)重！
        // System.out.println(fruits[3]); // 運(yùn)行時(shí)錯(cuò)誤??: ArrayIndexOutOfBoundsException
    }
}

2.4 獲取數(shù)組長度：.length 屬性 ??

想知道數(shù)組能裝多少東西？用 .length 屬性（注意：是屬性，不是方法，后面沒有括號(hào) ()，這點(diǎn)和 String 的 length() 方法不同，容易混淆?。?。

int[] data = new int[10];
System.out.println("Length of data array: " + data.length); // Output: 10
String[] colors = {"Red", "Green", "Blue"};
System.out.println("Number of colors: " + colors.length); // Output: 3

.length 在循環(huán)遍歷數(shù)組時(shí)特別有用。

三、 遍歷數(shù)組：挨個(gè)“點(diǎn)名” ??‍♀???‍♂?

遍歷數(shù)組就是按順序訪問數(shù)組中的每一個(gè)元素，通常用循環(huán)來實(shí)現(xiàn)。

3.1 使用傳統(tǒng) for 循環(huán)

最靈活的方式，因?yàn)槟憧梢阅玫疆?dāng)前的索引 i。

public class ForLoopArray {
    public static void main(String[] args) {
        double[] readings = {12.5, 13.1, 11.8, 12.9};
        System.out.println("Sensor Readings:");
        // 循環(huán)條件通常是 i < array.length
        for (int i = 0; i < readings.length; i++) {
            System.out.println("Reading at index " + i + ": " + readings[i]);
        }
    }
}

3.2 使用增強(qiáng)型 for 循環(huán) (for-each)

如果不需要關(guān)心索引，只是想依次處理每個(gè)元素，這種方式更簡潔、易讀。

import java.util.ArrayList; // 只是為了演示集合遍歷
import java.util.List;
public class ForEachArray {
    public static void main(String[] args) {
        char[] vowels = {'a', 'e', 'i', 'o', 'u'};
        System.out.print("Vowels: ");
        // 依次取出 vowels 數(shù)組中的每個(gè) char 賦給變量 vowel
        for (char vowel : vowels) {
            System.out.print(vowel + " ");
        }
        System.out.println(); // 輸出: a e i o u
        // 同樣適用于集合 (比如 ArrayList)
        // List<String> names = new ArrayList<>(); ...
        // for (String name : names) { ... }
    }
}

如何選擇？ 如果需要索引（比如要根據(jù)索引修改元素，或者需要知道當(dāng)前是第幾個(gè)元素），用傳統(tǒng) for。如果只是讀取每個(gè)元素的值，增強(qiáng)型 for 通常更好。

四、 數(shù)組的“常見煩惱” ????

使用數(shù)組時(shí)，有幾個(gè)經(jīng)典錯(cuò)誤你很可能會(huì)遇到：

• ArrayIndexOutOfBoundsException <??>: 這是最常見的數(shù)組錯(cuò)誤！當(dāng)你試圖訪問一個(gè)不存在的索引時(shí)（比如索引 < 0，或者索引 >= array.length），就會(huì)拋出這個(gè)運(yùn)行時(shí)異常。寫循環(huán)時(shí)要特別小心邊界條件！
• NullPointerException : 如果你的數(shù)組引用變量本身是 null（即它沒有指向任何數(shù)組對(duì)象），而你試圖訪問它的 .length 屬性或者通過索引訪問元素（如 nullArray[0]），就會(huì)得到這個(gè)運(yùn)行時(shí)異常。
• 使用數(shù)組前，確保它已經(jīng)被正確初始化了！長度固定不變 <??>: 前面強(qiáng)調(diào)過，數(shù)組長度一旦確定就不能改。如果你的程序需要一個(gè)可以動(dòng)態(tài)增刪元素的容器，那么 Java 集合框架中的 ArrayList 等類通常是更好的選擇。

五、 超出基礎(chǔ)：多維數(shù)組與 Arrays工具類 ????

5.1 多維數(shù)組

你可以創(chuàng)建“數(shù)組的數(shù)組”，最常見的是二維數(shù)組，可以把它想象成一個(gè)表格或矩陣 ?。

// 創(chuàng)建一個(gè) 3行 4列 的 int 二維數(shù)組
int[][] matrix = new int[3][4];
// 靜態(tài)初始化
String[][] board = {
    {"X", "O", "X"},
    {"O", "X", "O"},
    {"X", "O", "X"}
};
// 訪問元素需要兩個(gè)索引
matrix[0][1] = 5; // 設(shè)置第 1 行第 2 列 (索引都是從 0 開始)
System.out.println("Board[1][1]: " + board[1][1]); // Output: X

遍歷二維數(shù)組通常需要嵌套循環(huán)。

5.2 java.util.Arrays 工具類 <???>

Java 提供了一個(gè)非常有用的 Arrays 類（在 java.util 包下），里面包含了很多操作數(shù)組的static方法，能省不少事：

• Arrays.toString(array): 把數(shù)組轉(zhuǎn)換成易于閱讀的字符串形式，方便打印調(diào)試，強(qiáng)烈推薦！??
• Arrays.sort(array): 對(duì)數(shù)組進(jìn)行排序（原地排序）。
• Arrays.fill(array, value): 用指定值填充整個(gè)數(shù)組。
• Arrays.copyOf(originalArray, newLength): 復(fù)制原數(shù)組的一部分或全部到一個(gè)新的數(shù)組（可以用來變相“擴(kuò)展”數(shù)組）。
• Arrays.equals(array1, array2): 比較兩個(gè)數(shù)組的內(nèi)容是否相等（注意，不是用 == 比地址）。

import java.util.Arrays; // <--- 別忘了導(dǎo)入！
public class ArraysUtilDemo {
    public static void main(String[] args) {
        int[] nums = {5, 2, 8, 1, 9};
        // 好看的打印方式
        System.out.println("Original array: " + Arrays.toString(nums));
        // 排序
        Arrays.sort(nums);
        System.out.println("Sorted array: " + Arrays.toString(nums));
        // 填充
        int[] filled = new int[5];
        Arrays.fill(filled, -1);
        System.out.println("Filled array: " + Arrays.toString(filled));
        // 復(fù)制 (取前 3 個(gè)元素)
        int[] copied = Arrays.copyOf(nums, 3); // nums 已經(jīng)是排序后的 {1, 2, 5, 8, 9}
        System.out.println("Copied first 3: " + Arrays.toString(copied));
    }
}

六、總結(jié) ??

數(shù)組是 Java 中存儲(chǔ)固定數(shù)量、相同類型元素的基礎(chǔ)數(shù)據(jù)結(jié)構(gòu)。

• 核心特性：類型統(tǒng)一、長度固定、索引訪問 (從 0 開始)。
• 創(chuàng)建方式：new Type[size] 或靜態(tài)初始化 {...}。
• 訪問與長度：使用 array[index] 訪問，.length 獲取長度。
• 遍歷：常用 for 或增強(qiáng) for 循環(huán)。
• 常見陷阱 ??：ArrayIndexOutOfBoundsException, NullPointerException, 長度固定限制。
• 好幫手 <???>：java.util.Arrays 類提供了很多實(shí)用方法。

雖然 ArrayList 等集合類在靈活性上更勝一籌，但數(shù)組在性能（尤其是訪問速度）和表示固定大小數(shù)據(jù)集時(shí)仍然有其優(yōu)勢，并且是理解集合類的基礎(chǔ)。所以，扎實(shí)掌握數(shù)組非常重要！

七、練練手，檢驗(yàn)成果！????

來，動(dòng)手寫寫代碼，鞏固一下！

? 基礎(chǔ)操作 ?

• 聲明一個(gè)可以存放 10 個(gè) double 類型數(shù)據(jù)的數(shù)組 prices，并將其所有元素初始化為 9.99 (使用循環(huán)或 Arrays.fill)。
• 創(chuàng)建一個(gè) String 數(shù)組 colors，包含 “Red”, “Green”, “Blue”, “Yellow”。然后，修改第三個(gè)元素 (“Blue”) 為 “Purple”，并打印修改后的數(shù)組內(nèi)容 (使用 Arrays.toString)。

? 循環(huán)與計(jì)算 ?

• 給定一個(gè) int 數(shù)組 scores = {88, 92, 75, 98, 85}，計(jì)算并打印數(shù)組中所有分?jǐn)?shù)的平均值 (注意結(jié)果可能是小數(shù))。
• 查找數(shù)組 int[] data = {5, -2, 9, 15, -8, 1} 中的最大值，并打印出來。

? 概念辨析 ?

• 嘗試解釋為什么數(shù)組的索引是從 0 開始而不是從 1 開始？(提示：可以從內(nèi)存地址和偏移量角度思考，或說明其歷史淵源和編程習(xí)慣)
• 比較數(shù)組 (int[]) 和 ArrayList<Integer> 的主要區(qū)別，尤其是在大小和類型方面。

八、參考答案 ???

? 基礎(chǔ)操作答案 ?

1.初始化 prices 數(shù)組:

import java.util.Arrays;
public class InitPrices {
    public static void main(String[] args) {
        double[] prices = new double[10];
        // 方法一：使用循環(huán)
        // for (int i = 0; i < prices.length; i++) {
        //     prices[i] = 9.99;
        // }
        // 方法二：使用 Arrays.fill (更推薦)
        Arrays.fill(prices, 9.99);
        System.out.println("Initialized prices: " + Arrays.toString(prices));
    }
}

2.修改 colors 數(shù)組:

import java.util.Arrays;
public class ModifyColors {
    public static void main(String[] args) {
        String[] colors = {"Red", "Green", "Blue", "Yellow"};
        System.out.println("Original colors: " + Arrays.toString(colors));
        // 第三個(gè)元素索引是 2
        if (colors.length > 2) { // 做個(gè)簡單檢查防止越界
            colors[2] = "Purple <??>";
        }
        System.out.println("Modified colors: " + Arrays.toString(colors));
        // 輸出: Modified colors: [Red, Green, Purple <??>, Yellow]
    }
}

? 循環(huán)與計(jì)算答案 ?

3.計(jì)算平均分:

import java.util.Arrays;
public class AverageScore {
    public static void main(String[] args) {
        int[] scores = {88, 92, 75, 98, 85};
        if (scores.length == 0) {
            System.out.println("Array is empty, cannot calculate average.");
            return;
        }
        int sum = 0;
        for (int score : scores) {
            sum += score;
        }
        // 注意：為了得到精確的小數(shù)結(jié)果，需要將 sum 或 length 轉(zhuǎn)為 double
        double average = (double) sum / scores.length;
        // 或者 double average = sum * 1.0 / scores.length;
        System.out.println("Scores: " + Arrays.toString(scores));
        System.out.println("Average score: " + average); // 輸出: Average score: 87.6
    }
}

4.查找最大值:

import java.util.Arrays;
public class FindMaxValue {
    public static void main(String[] args) {
        int[] data = {5, -2, 9, 15, -8, 1};
        if (data.length == 0) {
            System.out.println("Array is empty.");
            return;
        }
        int max = data[0]; // 假設(shè)第一個(gè)元素是最大值
        for (int i = 1; i < data.length; i++) {
            if (data[i] > max) {
                max = data[i]; // 如果找到更大的，更新 max
            }
        }
        System.out.println("Data: " + Arrays.toString(data));
        System.out.println("Maximum value: " + max); // 輸出: Maximum value: 15
    }
}

? 概念辨析答案 ?

5.為什么索引從 0 開始？

這主要是歷史原因和底層實(shí)現(xiàn)效率的考慮。在 C 語言（Java 的重要祖先）及更早的語言中，數(shù)組名通常代表數(shù)組第一個(gè)元素在內(nèi)存中的起始地址。訪問數(shù)組元素 array[i]，實(shí)際上是計(jì)算 起始地址 + i * 每個(gè)元素的大小 來找到第 i+1 個(gè)元素的地址。如果索引從 0 開始，那么訪問第一個(gè)元素 array[0] 就是 起始地址 + 0 * size，即起始地址本身，計(jì)算最簡單、最高效。如果從 1 開始，訪問第一個(gè)元素 array[1] 就需要計(jì)算 起始地址 + (1-1) * size，多了一步減法。這種從 0 開始的索引（稱為 zero-based indexing）已經(jīng)成為 C 家族語言（包括 C++, Java, C#, JavaScript 等）的編程慣例。

6.int[] vs ArrayList<Integer> 區(qū)別:

• 大小:
  • int[]: 大小固定。一旦創(chuàng)建，長度不能改變。
  • ArrayList<Integer>: 大小可變。可以動(dòng)態(tài)添加或刪除元素，其內(nèi)部容量會(huì)自動(dòng)調(diào)整（雖然可能涉及性能開銷）。
• 類型:
  • int[]: 存儲(chǔ)的是基本數(shù)據(jù)類型 int 的值。
  • ArrayList<Integer>: 存儲(chǔ)的是包裝類 <font color="purple">Integer</font> 的對(duì)象引用。它不能直接存儲(chǔ)基本類型 int（但 Java 的自動(dòng)裝箱/拆箱機(jī)制使得使用起來很像在存取 int）。
• 功能: ArrayList 提供了更多現(xiàn)成的方法（如 add, remove, contains, size 等），而數(shù)組功能相對(duì)基礎(chǔ)（主要靠索引和 Arrays 工具類）。
• 性能: 對(duì)于固定大小且頻繁訪問的場景，數(shù)組通常比 ArrayList 性能稍好（特別是對(duì)于基本類型數(shù)組，避免了裝箱/拆箱開銷和對(duì)象引用的開銷）。

希望這篇關(guān)于數(shù)組的筆記能幫你打下堅(jiān)實(shí)的基礎(chǔ)！用熟了它，再去看集合框架就會(huì)感覺輕松很多！如果覺得有幫助，別忘了 點(diǎn)贊??、收藏?、關(guān)注 哦！感謝！??

到此這篇關(guān)于Java 基礎(chǔ)--數(shù)組(Array)：存儲(chǔ)數(shù)據(jù)的“排排坐”的文章就介紹到這了,更多相關(guān)java數(shù)組Array內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！