Java数组常见操作实战指南：遍历、排序、查找、扩容（新手必看）

在Java编程中，数组是存储同类型数据的基础容器，而数组常见操作（遍历、排序、查找、扩容等）是新手必须掌握的核心技能。无论是处理批量数据、实现算法逻辑，还是应对日常开发需求，这些操作都高频出现。很多新手初期容易在数组遍历的边界处理、排序算法的选择、查找逻辑的优化上出错。本文将从数组核心操作分类出发，结合实战案例详细讲解每种操作的实现方法、适用场景及注意事项，帮助新手快速掌握并灵活运用数组操作技巧。

本文核心要点：Java数组遍历方法（for/增强for/Arrays工具类）、数组排序实战（冒泡排序/Arrays.sort）、数组查找技巧（线性查找/二分查找）、数组扩容实现、数组操作常见错误及解决方案

一、数组操作基础认知

在学习具体操作前，需明确数组的核心特性，这是正确执行各类操作的前提：

• 数组长度固定：一旦创建，长度无法直接修改，需通过“扩容”（创建新数组+拷贝元素）间接实现；
• 元素类型统一：数组只能存储同一种数据类型的元素（如int数组仅存int值，String数组仅存String值）；
• 索引从0开始：数组元素的访问通过“索引”实现，索引范围是0~数组长度-1，超出范围会抛出IndexOutOfBoundsException（索引越界异常）；
• 支持工具类操作：Java提供util.Arrays工具类，封装了排序、查找、填充等常用操作，简化开发。

本文所有实战案例基于以下两种常见数组类型展开：

Plain Text // 基本数据类型数组（int） int[] intArr = {12, 45, 7, 23, 56, 31}; // 引用数据类型数组（String） String[] strArr = {“Apple”, “Banana”, “Orange”, “Grape”};

二、数组遍历：获取数组中所有元素

数组遍历是最基础的操作，核心目的是“逐个访问数组中的元素”，常用于数据打印、统计分析（如求和、求平均值）等场景。Java中常用的遍历方式有三种，各有适用场景，新手需灵活选择。

2.1 普通for循环遍历（推荐：需操作索引时）

通过索引控制循环，可直接访问元素索引，适合需要修改元素值、统计索引相关信息的场景（如给指定索引元素赋值、筛选奇数索引元素）。

Plain Text public class ArrayTraversalFor { public static void main(String[] args) { int[] intArr = {12, 45, 7, 23, 56, 31}; System.out.println(“普通for循环遍历数组：”); // 循环条件：i从0开始，小于数组长度（避免索引越界） for (int i = 0; i < intArr.length; i++) { System.out.println(“索引[” + i + “]：” + intArr[i]); // 可直接修改元素值（如将所有元素翻倍） intArr[i] *= 2; } System.out.println(“修改后数组：” + Arrays.toString(intArr)); } }

运行结果：

Plain Text 普通for循环遍历数组： 索引[0]：12 索引[1]：45 索引[2]：7 索引[3]：23 索引[4]：56 索引[5]：31 修改后数组：[24, 90, 14, 46, 112, 62]

注意：循环条件务必写i < 数组长度，若写成i <= 数组长度，会导致索引越界异常。

2.2 增强for循环遍历（推荐：仅读取元素时）

增强for循环（foreach）语法简洁，无需关注索引，直接遍历元素，适合仅需读取元素、无需修改元素或操作索引的场景（如打印元素、统计元素和）。

Plain Text import java.util.Arrays;public class ArrayTraversalForeach { public static void main(String[] args) { String[] strArr = {“Apple”, “Banana”, “Orange”, “Grape”}; System.out.println(“增强for循环遍历数组：”); // 语法：for (元素类型 变量名 : 数组名) for (String fruit : strArr) { System.out.println(fruit); // 注意：此处修改fruit不会改变数组元素（fruit是临时变量） fruit = “Pear”; } System.out.println(“修改后数组：” + Arrays.toString(strArr)); } }

运行结果：

Plain Text 增强for循环遍历数组： Apple Banana Orange Grape 修改后数组：[Apple, Banana, Orange, Grape]

关键提醒：增强for循环中的变量是元素的“副本”，修改该变量不会影响数组原始元素。

2.3 Arrays.toString()遍历（推荐：快速打印数组）

Arrays工具类的toString()方法可直接将数组转换为字符串格式，无需手动循环，适合快速打印数组内容（开发中调试常用）。

Plain Text import java.util.Arrays;public class ArrayTraversalArrays { public static void main(String[] args) { int[] intArr = {12, 45, 7, 23}; String[] strArr = {“Apple”, “Banana”}; // 直接打印数组（默认格式：[元素1, 元素2, …]） System.out.println(“int数组：” + Arrays.toString(intArr)); System.out.println(“String数组：” + Arrays.toString(strArr)); } }

运行结果：

Plain Text int数组：[12, 45, 7, 23] String数组：[Apple, Banana]

三、数组排序：整理数组元素顺序

数组排序是将数组元素按指定规则（升序/降序）重新排列的操作，常用于数据整理、查找优化等场景。Java中排序分为“手动实现排序算法”和“使用Arrays工具类排序”，新手可先掌握工具类排序（高效简洁），再了解基础排序算法（如冒泡排序）。

3.1 Arrays.sort()工具类排序（推荐：开发首选）

Arrays.sort()是Java提供的高效排序方法，默认按“自然顺序”排序（基本类型升序，String按字典序），支持自定义排序（需结合Comparator，新手后期掌握）。

Plain Text import java.util.Arrays;public class ArraySortArrays { public static void main(String[] args) { // 1. 基本类型数组排序（升序） int[] intArr = {12, 45, 7, 23, 56, 31}; Arrays.sort(intArr); System.out.println(“int数组升序排序后：” + Arrays.toString(intArr)); // 2. 引用类型数组排序（String按字典序） String[] strArr = {“Apple”, “Banana”, “Orange”, “Grape”}; Arrays.sort(strArr); System.out.println(“String数组字典序排序后：” + Arrays.toString(strArr)); // 3. 部分排序（从索引1开始，到索引4结束，左闭右开） int[] partArr = {12, 45, 7, 23, 56, 31}; Arrays.sort(partArr, 1, 4); // 排序索引1、2、3的元素 System.out.println(“部分排序后：” + Arrays.toString(partArr)); } }

运行结果：

Plain Text int数组升序排序后：[7, 12, 23, 31, 45, 56] String数组字典序排序后：[Apple, Banana, Grape, Orange] 部分排序后：[12, 7, 23, 45, 56, 31]

3.2 手动实现冒泡排序（理解排序原理）

冒泡排序是最基础的排序算法，核心思想是“相邻元素两两比较，大的元素往后移”，经过多轮遍历后完成排序。适合新手理解排序的核心逻辑。

Plain Text public class ArraySortBubble { public static void main(String[] args) { int[] intArr = {12, 45, 7, 23, 56, 31}; bubbleSort(intArr); System.out.println(“冒泡排序后：” + Arrays.toString(intArr)); }// 冒泡排序实现方法 public static void bubbleSort(int[] arr) { // 外层循环：控制排序轮数（数组长度-1轮，每轮确定一个最大值） for (int i = 0; i < arr.length – 1; i++) { // 内层循环：相邻元素比较，大的后移（每轮后，最大元素已在末尾，无需再比较） for (int j = 0; j < arr.length – 1 – i; j++) { if (arr[j] > arr[j + 1]) { // 交换相邻元素 int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } } }

运行结果：

Plain Text 冒泡排序后：[7, 12, 23, 31, 45, 56]

注意：冒泡排序效率较低，适合小规模数据；大规模数据推荐使用Arrays.sort()（底层是高效的双轴快速排序）。

四、数组查找：定位目标元素位置

数组查找是“在数组中寻找指定目标元素，并返回其索引”的操作，常用于数据检索场景。根据数组是否有序，分为“线性查找”（无序/有序数组均可）和“二分查找”（仅有序数组，效率更高）。

4.1 线性查找（顺序查找）

线性查找是逐个遍历数组元素，与目标值比较，找到则返回索引，未找到则返回-1（约定俗成的“未找到”标识）。适合无序数组或小规模有序数组。

Plain Text public class ArraySearchLinear { public static void main(String[] args) { int[] intArr = {12, 45, 7, 23, 56, 31}; int target = 23; int index = linearSearch(intArr, target);if (index != -1) { System.out.println(“目标元素” + target + “的索引：” + index); } else { System.out.println(“未找到目标元素” + target); } } // 线性查找实现方法 public static int linearSearch(int[] arr, int target) { // 遍历数组，逐个比较 for (int i = 0; i < arr.length; i++) { if (arr[i] == target) { return i; // 找到目标，返回索引 } } return -1; // 遍历结束未找到，返回-1 } }

运行结果：

Plain Text 目标元素23的索引：3

4.2 二分查找（折半查找）

二分查找的核心思想是“每次将查找范围缩小一半”，仅适用于有序数组（升序/降序），效率远高于线性查找（大规模数据首选）。Java中可通过Arrays.binarySearch()直接实现。

Plain Text import java.util.Arrays;public class ArraySearchBinary { public static void main(String[] args) { int[] intArr = {12, 45, 7, 23, 56, 31}; // 二分查找前必须先排序（升序） Arrays.sort(intArr); System.out.println(“排序后的数组：” + Arrays.toString(intArr)); int target = 23; // 1. 使用Arrays.binarySearch()查找 int index = Arrays.binarySearch(intArr, target); if (index >= 0) { System.out.println(“目标元素” + target + “的索引：” + index); } else { // 未找到时，返回“-(插入点)-1”（插入点是目标元素应插入的位置） System.out.println(“未找到目标元素，插入点位置：” + (-index – 1)); } } // 手动实现二分查找（升序数组） public static int binarySearch(int[] arr, int target) { int left = 0; // 左边界索引 int right = arr.length – 1; // 右边界索引 while (left <= right) { int mid = (left + right) / 2; // 中间索引 if (arr[mid] == target) { return mid; // 找到目标，返回索引 } else if (arr[mid] < target) { left = mid + 1; // 目标在右半部分，缩小左边界 } else { right = mid – 1; // 目标在左半部分，缩小右边界 } } return -1; // 未找到 } }

运行结果：

Plain Text 排序后的数组：[7, 12, 23, 31, 45, 56] 目标元素23的索引：2

关键提醒：二分查找前必须确保数组有序，否则会返回错误结果。

五、数组扩容：突破固定长度限制

Java数组长度固定，若需存储更多元素，需通过“扩容”实现：核心逻辑是“创建一个更长的新数组，将原数组元素拷贝到新数组”，最后让原数组引用指向新数组。常用扩容方式有两种：手动拷贝扩容、使用Arrays.copyOf()扩容。

5.1 Arrays.copyOf()扩容（推荐：简洁高效）

Arrays.copyOf()可直接创建指定长度的新数组，并拷贝原数组元素，简化扩容流程，是开发中首选的扩容方式。

Plain Text import java.util.Arrays;public class ArrayExpandCopyOf { public static void main(String[] args) { int[] oldArr = {12, 45, 7, 23}; System.out.println(“原数组：” + Arrays.toString(oldArr) + “，长度：” + oldArr.length); // 扩容：创建长度为8的新数组，拷贝原数组元素（多余位置补默认值0） int[] newArr = Arrays.copyOf(oldArr, 8); // 给新数组添加新元素 newArr[4] = 56; newArr[5] = 31; System.out.println(“扩容后数组：” + Arrays.toString(newArr) + “，长度：” + newArr.length); } }

运行结果：

Plain Text 原数组：[12, 45, 7, 23]，长度：4 扩容后数组：[12, 45, 7, 23, 56, 31, 0, 0]，长度：8

5.2 手动拷贝扩容（理解底层逻辑）

手动扩容通过System.arraycopy()（底层native方法，高效）实现元素拷贝，步骤更清晰，适合新手理解扩容的底层逻辑。

Plain Text import java.util.Arrays;public class ArrayExpandManual { public static void main(String[] args) { int[] oldArr = {12, 45, 7, 23}; int expandLength = 4; // 新增长度 // 1. 创建新数组（原长度+新增长度） int[] newArr = new int[oldArr.length + expandLength]; // 2. 拷贝原数组元素到新数组（System.arraycopy(原数组, 原起始索引, 新数组, 新起始索引, 拷贝长度)） System.arraycopy(oldArr, 0, newArr, 0, oldArr.length); // 3. 添加新元素 newArr[4] = 56; newArr[5] = 31; System.out.println(“原数组：” + Arrays.toString(oldArr) + “，长度：” + oldArr.length); System.out.println(“扩容后数组：” + Arrays.toString(newArr) + “，长度：” + newArr.length); } }

运行结果与Arrays.copyOf()扩容一致。

六、数组操作常见问题与解决方案（新手避坑指南）

整理新手在数组操作中高频出现的错误，结合具体场景给出解决方案，帮助快速排查问题。

问题1：索引越界异常（IndexOutOfBoundsException）

原因：访问数组时使用的索引超出“0~数组长度-1”的范围（如遍历循环条件写i <= arr.length、直接访问索引等于数组长度的元素）。

解决方案：严格确保索引范围，遍历数组时优先使用i < arr.length作为循环条件。

Plain Text int[] arr = {1, 2, 3}; // 错误示例：索引3超出范围（数组长度3，索引最大为2） // System.out.println(arr[3]); // 抛出IndexOutOfBoundsException// 正确示例：索引范围0~2 for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); }

问题2：增强for循环修改元素失败

原因：增强for循环中的变量是数组元素的“副本”，修改副本不会影响原始数组元素。

解决方案：若需修改数组元素，使用普通for循环（通过索引直接访问元素）。

Plain Text int[] arr = {1, 2, 3}; // 错误示例：增强for循环修改元素失败 for (int num : arr) { num *= 2; // 仅修改副本，原始数组不变 } System.out.println(“增强for循环修改后：” + Arrays.toString(arr)); // [1,2,3]// 正确示例：普通for循环修改元素 for (int i = 0; i < arr.length; i++) { arr[i] *= 2; } System.out.println(“普通for循环修改后：” + Arrays.toString(arr)); // [2,4,6]

问题3：二分查找未排序数组，返回错误结果

原因：二分查找的核心前提是“数组有序”，无序数组使用二分查找会导致逻辑错误。

解决方案：二分查找前必须先对数组排序（如使用Arrays.sort()）。

Plain Text int[] arr = {3, 1, 2}; int target = 2; // 错误示例：未排序数组直接二分查找 // int index = Arrays.binarySearch(arr, target); // 返回错误索引// 正确示例：先排序再二分查找 Arrays.sort(arr); int index = Arrays.binarySearch(arr, target); System.out.println(“目标元素索引：” + index); // 1

问题4：数组扩容后原数组引用未更新

原因：扩容的核心是“创建新数组”，若仍使用原数组引用访问，将无法获取新数组的元素。

解决方案：扩容后，让原数组引用指向新数组（如oldArr = newArr;）。

Plain Text int[] oldArr = {1, 2, 3}; // 错误示例：扩容后未更新原引用 int[] newArr = Arrays.copyOf(oldArr, 5); newArr[3] = 4; System.out.println(“原引用访问：” + Arrays.toString(oldArr)); // [1,2,3]（未更新）// 正确示例：更新原引用指向新数组 oldArr = newArr; System.out.println(“更新后引用访问：” + Arrays.toString(oldArr)); // [1,2,3,4,0]

七、总结

本文系统讲解了Java数组的四大核心操作（遍历、排序、查找、扩容），涵盖每种操作的实现方法、适用场景及注意事项，并整理了新手高频错误的解决方案。数组操作是Java编程的基础，掌握这些操作技巧，能为后续学习集合框架、算法实现等内容打下坚实基础。

新手学习数组操作的关键是“多动手实践”——通过编写不同场景的代码（如遍历统计、排序查找、动态扩容），熟悉各类操作的核心逻辑，同时注意规避索引越界、修改元素失败等常见错误。如果在学习过程中有其他问题，欢迎在评论区留言讨论。

关键词：Java数组遍历、Java数组排序、Java数组查找、Java数组扩容、Java数组操作实战、Java新手教程、数组常见错误