【Java基础】数组详解，这一篇就够了！

红目香薰

发布于 2025-12-16 14:57:49

1000

文章被收录于专栏：CSDNToQQCodeCSDNToQQCode

前言

亲爱的同学们，大家好！👋 今天我要和大家分享Java编程中最基础也是最重要的数据结构之一——数组。🌟

作为一名Java初学者，掌握数组的使用是你迈向编程世界的重要一步。数组就像是我们生活中的抽屉，可以有序地存放多个相同类型的物品，让我们能够高效地管理和处理大量数据。

在我多年的教学经验中，我发现很多同学对数组的理解仅停留在表面，不知道如何灵活运用它的特性来解决实际问题。今天，我就带大家深入浅出地了解Java数组的方方面面，让你真正掌握这个强大的工具！准备好了吗？Let’s go! 🚀

知识点说明

数组的基本概念

数组是一种用于存储多个相同类型数据的容器。在Java中，数组是一种引用类型，具有以下特点：

固定长度：一旦创建，数组的长度就不能改变
相同类型：数组中的所有元素必须是相同的数据类型
有序排列：数组中的元素按照索引顺序排列
索引从0开始：第一个元素的索引是0，最后一个元素的索引是数组长度减1

数组的声明与创建

在Java中，声明和创建数组有多种方式：

// 声明数组
int[] numbers;  // 推荐的方式
int numbers[];  // 也可以，但不推荐

// 创建数组
numbers = new int[5];  // 创建一个长度为5的int类型数组

// 声明并创建数组
int[] scores = new int[10];  // 创建一个长度为10的int类型数组

// 声明、创建并初始化数组
int[] points = {95, 85, 76, 90, 88};  // 创建并初始化一个包含5个元素的数组

数组的访问与操作

数组元素的访问是通过索引进行的：

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

// 访问数组元素
int firstNumber = numbers[0];  // 获取第一个元素，值为10
int thirdNumber = numbers[2];  // 获取第三个元素，值为30

// 修改数组元素
numbers[1] = 25;  // 将第二个元素的值修改为25

数组的遍历

遍历数组是一个常见操作，有多种方式：

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

// 使用for循环遍历
for (int i = 0; i < numbers.length; i++) {
    System.out.println("索引 " + i + " 的元素是: " + numbers[i]);
}

// 使用增强型for循环（for-each）遍历
for (int number : numbers) {
    System.out.println("当前元素是: " + number);
}

// 使用Java 8 Stream API遍历
Arrays.stream(numbers).forEach(number -> System.out.println("当前元素是: " + number));

多维数组

Java支持多维数组，最常见的是二维数组：

// 声明并创建二维数组
int[][] matrix = new int[3][4];  // 3行4列的二维数组

// 声明、创建并初始化二维数组
int[][] grid = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

// 访问二维数组元素
int element = grid[1][2];  // 获取第2行第3列的元素，值为6

// 遍历二维数组
for (int i = 0; i < grid.length; i++) {
    for (int j = 0; j < grid[i].length; j++) {
        System.out.print(grid[i][j] + " ");
    }
    System.out.println();
}

数组的常用操作

Java提供了java.util.Arrays类，包含了许多用于操作数组的实用方法：

import java.util.Arrays;

int[] numbers = {5, 2, 9, 1, 7};

// 排序
Arrays.sort(numbers);  // 数组变为 {1, 2, 5, 7, 9}

// 二分查找（要求数组已排序）
int index = Arrays.binarySearch(numbers, 5);  // 返回值5在数组中的索引

// 填充
Arrays.fill(numbers, 10);  // 将数组所有元素设置为10

// 复制
int[] copy = Arrays.copyOf(numbers, numbers.length);  // 创建一个完整的数组副本

// 比较
boolean isEqual = Arrays.equals(numbers, copy);  // 比较两个数组是否相等

// 转换为字符串
String str = Arrays.toString(numbers);  // 将数组转换为字符串表示

重难点说明

1. 数组与内存模型 🧠

理解数组在内存中的存储方式对于深入掌握数组至关重要：

对于基本类型数组，数组变量存储在栈中，而数组元素存储在堆中
对于引用类型数组，数组变量和引用存储在栈中，实际对象存储在堆中

int[] numbers = new int[5];       // numbers存储在栈中，5个整数存储在堆中
String[] names = new String[3];   // names存储在栈中，3个引用存储在堆中，字符串对象存储在堆中

2. 数组的边界检查 ⚠️

Java会自动进行数组边界检查，如果访问超出数组范围的索引，会抛出ArrayIndexOutOfBoundsException异常：

int[] numbers = {10, 20, 30};
int value = numbers[3];  // 抛出ArrayIndexOutOfBoundsException，因为最大索引是2

为了避免这种异常，我们应该始终确保索引在有效范围内：

int[] numbers = {10, 20, 30};
int index = 2;

if (index >= 0 && index < numbers.length) {
    int value = numbers[index];  // 安全访问
    System.out.println("值是: " + value);
} else {
    System.out.println("索引超出范围!");
}

3. 数组的不可变长度 📏

Java数组一旦创建，其长度就不能改变。如果需要动态调整大小，我们有两种选择：

创建一个新的更大的数组，并复制原数组的元素
使用ArrayList等集合类，它们提供了动态调整大小的能力

// 手动扩展数组
int[] oldArray = {1, 2, 3};
int[] newArray = new int[oldArray.length * 2];  // 创建一个更大的数组
System.arraycopy(oldArray, 0, newArray, 0, oldArray.length);  // 复制元素

// 使用ArrayList代替数组
import java.util.ArrayList;
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
// 可以继续添加元素，无需担心大小问题

4. 数组与对象的关系 🔄

在Java中，数组本身就是对象，具有以下特点：

数组有一个名为length的公共final实例变量，表示数组的长度
数组继承自Object类，因此具有Object类的所有方法
每种类型的数组都有自己的类，如int[]、String[]等

int[] numbers = {1, 2, 3};
System.out.println(numbers.length);  // 输出3
System.out.println(numbers.getClass().getName());  // 输出"[I"，表示int数组类型

核心代码说明

让我们通过一些实际的代码示例来深入理解数组的使用：

1. 基本数组操作

public class ArrayBasics {
    public static void main(String[] args) {
        // 创建并初始化数组
        int[] scores = {85, 92, 78, 95, 88};
        
        // 计算总分和平均分
        int sum = 0;
        for (int score : scores) {
            sum += score;
        }
        double average = (double) sum / scores.length;
        
        // 找出最高分和最低分
        int max = scores[0];
        int min = scores[0];
        for (int i = 1; i < scores.length; i++) {
            if (scores[i] > max) {
                max = scores[i];
            }
            if (scores[i] < min) {
                min = scores[i];
            }
        }
        
        // 输出结果
        System.out.println("总分: " + sum);
        System.out.println("平均分: " + average);
        System.out.println("最高分: " + max);
        System.out.println("最低分: " + min);
    }
}

这个例子展示了如何使用数组存储学生成绩，并计算总分、平均分、最高分和最低分。

2. 数组排序和搜索

import java.util.Arrays;

public class ArraySortSearch {
    public static void main(String[] args) {
        // 创建一个乱序数组
        int[] numbers = {42, 17, 93, 25, 8, 64, 31, 50};
        
        System.out.println("原始数组: " + Arrays.toString(numbers));
        
        // 排序数组
        Arrays.sort(numbers);
        System.out.println("排序后: " + Arrays.toString(numbers));
        
        // 二分查找
        int target = 31;
        int index = Arrays.binarySearch(numbers, target);
        if (index >= 0) {
            System.out.println("找到 " + target + " 在索引 " + index);
        } else {
            System.out.println(target + " 不在数组中");
        }
        
        // 自定义搜索
        int searchTarget = 42;
        int foundIndex = linearSearch(numbers, searchTarget);
        if (foundIndex >= 0) {
            System.out.println("通过线性搜索找到 " + searchTarget + " 在索引 " + foundIndex);
        } else {
            System.out.println("通过线性搜索未找到 " + searchTarget);
        }
    }
    
    // 实现线性搜索
    public static int linearSearch(int[] array, int target) {
        for (int i = 0; i < array.length; i++) {
            if (array[i] == target) {
                return i;
            }
        }
        return -1;  // 未找到
    }
}

这个例子展示了如何使用Arrays.sort()对数组进行排序，以及如何使用二分查找和线性搜索在数组中查找元素。

3. 二维数组应用

public class TwoDimensionalArray {
    public static void main(String[] args) {
        // 创建一个5x5的二维数组表示棋盘
        char[][] board = new char[5][5];
        
        // 初始化棋盘（填充空格）
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[i].length; j++) {
                board[i][j] = '-';
            }
        }
        
        // 放置一些棋子
        board[1][1] = 'X';
        board[1][2] = 'O';
        board[2][2] = 'X';
        board[3][3] = 'O';
        
        // 打印棋盘
        System.out.println("棋盘状态:");
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[i].length; j++) {
                System.out.print(board[i][j] + " ");
            }
            System.out.println();
        }
        
        // 检查是否有连续的三个相同棋子（简化版）
        boolean hasThreeInRow = checkThreeInRow(board, 'X');
        System.out.println("是否有三个连续的X: " + hasThreeInRow);
    }
    
    // 检查是否有三个连续的相同棋子（仅检查行）
    public static boolean checkThreeInRow(char[][] board, char player) {
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j <= board[i].length - 3; j++) {
                if (board[i][j] == player && 
                    board[i][j+1] == player && 
                    board[i][j+2] == player) {
                    return true;
                }
            }
        }
        return false;
    }
}

这个例子展示了如何使用二维数组表示棋盘，并实现一个简单的检查连续三个相同棋子的功能。

4. 数组作为方法参数和返回值

public class ArrayMethods {
    public static void main(String[] args) {
        int[] original = {1, 2, 3, 4, 5};
        
        // 数组作为方法参数
        System.out.println("原始数组: " + Arrays.toString(original));
        doubleValues(original);
        System.out.println("加倍后: " + Arrays.toString(original));
        
        // 数组作为返回值
        int[] reversed = reverseArray(original);
        System.out.println("反转后: " + Arrays.toString(reversed));
        
        // 可变参数（本质上是数组）
        int sum = addNumbers(1, 2, 3, 4, 5);
        System.out.println("总和: " + sum);
    }
    
    // 修改数组内容的方法
    public static void doubleValues(int[] array) {
        for (int i = 0; i < array.length; i++) {
            array[i] *= 2;
        }
    }
    
    // 返回新数组的方法
    public static int[] reverseArray(int[] array) {
        int[] result = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            result[i] = array[array.length - 1 - i];
        }
        return result;
    }
    
    // 使用可变参数的方法
    public static int addNumbers(int... numbers) {
        int sum = 0;
        for (int num : numbers) {
            sum += num;
        }
        return sum;
    }
}

这个例子展示了如何将数组作为方法参数和返回值，以及如何使用可变参数（本质上是数组）。

5. 常见数组算法

public class ArrayAlgorithms {
    public static void main(String[] args) {
        int[] numbers = {5, 8, 2, 9, 3, 7, 1, 6, 4};
        
        // 1. 冒泡排序
        int[] bubbleSorted = bubbleSort(numbers.clone());
        System.out.println("冒泡排序: " + Arrays.toString(bubbleSorted));
        
        // 2. 选择排序
        int[] selectionSorted = selectionSort(numbers.clone());
        System.out.println("选择排序: " + Arrays.toString(selectionSorted));
        
        // 3. 数组合并
        int[] array1 = {1, 3, 5, 7};
        int[] array2 = {2, 4, 6, 8};
        int[] merged = mergeArrays(array1, array2);
        System.out.println("合并数组: " + Arrays.toString(merged));
        
        // 4. 移除重复元素
        int[] withDuplicates = {1, 2, 2, 3, 4, 4, 5};
        int[] noDuplicates = removeDuplicates(withDuplicates);
        System.out.println("移除重复后: " + Arrays.toString(noDuplicates));
    }
    
    // 冒泡排序
    public static int[] bubbleSort(int[] array) {
        int n = array.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    // 交换元素
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
        return array;
    }
    
    // 选择排序
    public static int[] selectionSort(int[] array) {
        int n = array.length;
        for (int i = 0; i < n - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < n; j++) {
                if (array[j] < array[minIndex]) {
                    minIndex = j;
                }
            }
            // 交换元素
            int temp = array[i];
            array[i] = array[minIndex];
            array[minIndex] = temp;
        }
        return array;
    }
    
    // 合并两个有序数组
    public static int[] mergeArrays(int[] array1, int[] array2) {
        int[] result = new int[array1.length + array2.length];
        int i = 0, j = 0, k = 0;
        
        while (i < array1.length && j < array2.length) {
            if (array1[i] < array2[j]) {
                result[k++] = array1[i++];
            } else {
                result[k++] = array2[j++];
            }
        }
        
        while (i < array1.length) {
            result[k++] = array1[i++];
        }
        
        while (j < array2.length) {
            result[k++] = array2[j++];
        }
        
        return result;
    }
    
    // 移除重复元素
    public static int[] removeDuplicates(int[] array) {
        // 假设数组已排序
        if (array.length == 0 || array.length == 1) {
            return array;
        }
        
        int uniqueCount = 1;
        for (int i = 1; i < array.length; i++) {
            if (array[i] != array[i - 1]) {
                uniqueCount++;
            }
        }
        
        int[] result = new int[uniqueCount];
        result[0] = array[0];
        int index = 1;
        
        for (int i = 1; i < array.length; i++) {
            if (array[i] != array[i - 1]) {
                result[index++] = array[i];
            }
        }
        
        return result;
    }
}

这个例子展示了几种常见的数组算法，包括冒泡排序、选择排序、合并有序数组和移除重复元素。

对Java初期学习的重要意义

掌握数组对Java初学者有以下几点重要意义：

1. 打好编程基础 🏗️

数组是最基础的数据结构之一，理解数组的工作原理和使用方法是学习更复杂数据结构（如列表、集合等）的基础。

2. 培养算法思维 🧠

通过数组操作和算法实现（如排序、搜索等），可以培养逻辑思维和算法思想，这对解决各种编程问题至关重要。

3. 提高代码效率 ⚡

数组提供了直接的内存访问，在需要高性能的场景下，合理使用数组可以显著提高程序的执行效率。

4. 理解内存管理 💾

学习数组有助于理解Java的内存模型和对象引用机制，为后续学习垃圾回收、内存优化等高级主题打下基础。

5. 应对实际问题 🔍

在实际开发中，数组被广泛应用于各种场景，如数据处理、图像处理、游戏开发等。掌握数组操作可以帮助你解决这些实际问题。

总结

亲爱的同学们，今天我们深入探讨了Java中的数组，从基本概念到高级应用，全方位地了解了这个强大的数据结构。💯

让我们回顾一下关键点：

数组是一种固定长度的数据结构，用于存储相同类型的多个元素。
数组元素通过索引访问，索引从0开始，最大索引是数组长度减1。
数组可以是一维的，也可以是多维的，多维数组适合表示矩阵、表格等复杂数据结构。
Java提供了丰富的数组操作API，如排序、搜索、复制等，可以简化我们的编程工作。
理解数组的内存模型和边界检查对于编写安全、高效的代码至关重要。

数组是Java编程的基石，掌握它将为你的编程之路奠定坚实的基础。无论是处理简单的数据集合，还是实现复杂的算法，数组都是你不可或缺的工具。🌟

记住，编程能力的提升需要不断的实践和思考。尝试使用今天学到的知识解决实际问题，挑战自己，你会发现数组的魅力远不止于此！✨

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2025-08-01，如有侵权请联系 cloudcommunity@tencent.com 删除

索引

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度