Java中Arrays类常用方法解析

Arrays类提供静态方法高效处理数组，涵盖排序（sort）、查找（binarySearch）、填充（fill）、复制（copyOf）、比较（equals/deepEquals）及转字符串（toString/deepToString），并支持通过stream()集成Stream API，实现函数式编程，提升代码简洁性与性能。

Java中的

Arrays

类，在我看来，简直是处理数组的瑞士军刀。它不是用来创建数组的，而是提供了一系列静态工具方法，帮你对数组进行各种操作，比如排序、搜索、比较、填充，甚至转换成字符串方便打印。可以说，只要你还在Java里跟数组打交道，

Arrays

类就是你绕不开的得力助手。

解决方案

Arrays

类提供了一整套静态方法来简化数组的常见操作。这些方法覆盖了从数据组织到内容检查的方方面面。核心功能包括但不限于：高效地对数组进行排序；在已排序数组中快速查找元素；填充数组的全部或部分内容；比较两个数组是否相等；将数组内容转换成易于阅读的字符串表示；以及创建数组的副本。掌握这些方法，能让你在日常开发中处理数组时事半功倍，写出更简洁、更高效的代码。

数组排序：如何高效地组织你的数据？

谈到数组操作，排序无疑是最频繁、也最基础的需求之一。

Arrays.sort()

方法就是为此而生，它提供了多种重载，能满足你对各种类型数组的排序需求。坦白说，每次需要排序，我第一个想到的就是它，因为它足够简单，而且在性能上，Java的实现也相当成熟。

立即学习“Java免费学习笔记（深入）”；

对于基本数据类型（如

int[]

,

double[]

,

char[]

等），

Arrays.sort()

通常采用的是经过优化的双轴快速排序（Dual-Pivot Quicksort）算法。这个算法在大多数情况下表现出色，平均时间复杂度是O(n log n)。这意味着，即使你的数组有几十万甚至上百万个元素，它也能在可接受的时间内完成排序。

import java.util.Arrays;public class ArraySortingExample {    public static void main(String[] args) {        int[] numbers = {5, 2, 8, 1, 9, 3};        System.out.println("原始数组: " + Arrays.toString(numbers)); // 输出: 原始数组: [5, 2, 8, 1, 9, 3]        Arrays.sort(numbers);        System.out.println("排序后数组: " + Arrays.toString(numbers)); // 输出: 排序后数组: [1, 2, 3, 5, 8, 9]        String[] names = {"Charlie", "Alice", "Bob", "David"};        System.out.println("原始字符串数组: " + Arrays.toString(names));        Arrays.sort(names); // 字符串默认按字典序排序        System.out.println("排序后字符串数组: " + Arrays.toString(names)); // 输出: 排序后字符串数组: [Alice, Bob, Charlie, David]    }}

而对于对象数组（如

String[]

，或者你自定义的类数组），

Arrays.sort()

则会使用一个稳定的归并排序（MergeSort）算法，或者在某些Java版本中，可能会使用Timsort（一种混合排序算法，结合了归并排序和插入排序的优点）。稳定性在这里很重要，它意味着如果两个元素相等，它们在排序后的相对位置不会改变。如果你需要按照自定义的规则排序对象数组，还可以传入一个

Comparator

：

import java.util.Arrays;import java.util.Comparator;class Person {    String name;    int age;    public Person(String name, int age) {        this.name = name;        this.age = age;    }    @Override    public String toString() {        return name + "(" + age + ")";    }}public class CustomObjectSorting {    public static void main(String[] args) {        Person[] people = {            new Person("Alice", 30),            new Person("Bob", 25),            new Person("Charlie", 30),            new Person("David", 20)        };        System.out.println("原始人员数组: " + Arrays.toString(people));        // 按年龄升序排序        Arrays.sort(people, Comparator.comparingInt(p -> p.age));        System.out.println("按年龄排序: " + Arrays.toString(people)); // 输出: [David(20), Bob(25), Alice(30), Charlie(30)]        // 如果年龄相同，则按名字字母序排序        Arrays.sort(people, Comparator.comparingInt((Person p) -> p.age)                                      .thenComparing(p -> p.name));        System.out.println("按年龄再按名字排序: " + Arrays.toString(people)); // 输出: [David(20), Bob(25), Alice(30), Charlie(30)]    }}

你看，通过

Comparator

，我们能非常灵活地定义排序规则。这东西用起来真是方便，避免了手动实现复杂排序逻辑的麻烦。

数组查找：快速定位你想要的信息？

当你的数组已经排好序，并且你需要快速找到某个特定的元素时，

Arrays.binarySearch()

方法就是你的首选。它的效率非常高，时间复杂度是O(log n)，这意味着即使数组非常大，查找速度也极快。

但这里有个大前提，也是我经常看到一些初学者容易犯错的地方：数组必须是已经排好序的！ 如果你在一个未排序的数组上调用

binarySearch()

，结果将是不可预测的，很可能找不到你想要的值，或者返回一个毫无意义的负数。

binarySearch()

方法的返回值也很有意思：

如果找到了目标元素，它会返回该元素在数组中的索引。如果没找到，它会返回一个负数。这个负数的计算方式是

(-(插入点) - 1)

。这里的“插入点”是指如果目标元素存在，它应该被插入的位置（保持数组有序）。这个设计很巧妙，因为它不仅告诉你没找到，还指明了它“应该”在哪里。

import java.util.Arrays;public class ArraySearchingExample {    public static void main(String[] args) {        int[] sortedNumbers = {1, 3, 5, 7, 9, 11, 13};        System.out.println("已排序数组: " + Arrays.toString(sortedNumbers));        // 查找存在的元素        int indexFound = Arrays.binarySearch(sortedNumbers, 7);        System.out.println("元素 7 的索引: " + indexFound); // 输出: 元素 7 的索引: 3        // 查找不存在的元素        int indexNotFound = Arrays.binarySearch(sortedNumbers, 6);        System.out.println("元素 6 的索引: " + indexNotFound); // 输出: 元素 6 的索引: -4 (表示应该插入到索引3的位置，即- (3 + 1))        int indexNotFound2 = Arrays.binarySearch(sortedNumbers, 15);        System.out.println("元素 15 的索引: " + indexNotFound2); // 输出: 元素 15 的索引: -8 (表示应该插入到索引7的位置，即- (7 + 1))        // 尝试在未排序数组上查找（错误示范）        int[] unsortedNumbers = {5, 2, 8, 1, 9};        int resultUnsorted = Arrays.binarySearch(unsortedNumbers, 8);        System.out.println("在未排序数组中查找 8: " + resultUnsorted); // 输出可能是任意值，不靠谱        // 正确做法是先排序        Arrays.sort(unsortedNumbers);        System.out.println("排序后数组: " + Arrays.toString(unsortedNumbers));        resultUnsorted = Arrays.binarySearch(unsortedNumbers, 8);        System.out.println("在排序后数组中查找 8: " + resultUnsorted); // 输出: 4    }}

记住，在使用

binarySearch()

之前，务必确保你的数组是排好序的，否则，你得到的就不是“快速定位”，而是“快速迷失”了。

eMart 网店系统

功能列表：底层程序与前台页面分离的效果，对页面的修改无需改动任何程序代码。完善的标签系统，支持自定义标签，公用标签，快捷标签，动态标签，静态标签等等，支持标签内的vbs语法，原则上运用这些标签可以制作出任何想要的页面效果。兼容原来的栏目系统，可以很方便的插入一个栏目或者一个栏目组到页面的任何位置。底层模版解析程序具有非常高的效率，稳定性和容错性，即使模版中有错误的标签也不会影响页面的显示。所有的标

0 查看详情

数组内容操作：填充、复制与比较的艺术

除了排序和查找，

Arrays

类还提供了一系列方法来操作数组的内容，比如初始化、复制和比较。这些方法虽然看起来简单，但在实际开发中，它们的使用频率非常高，能大大简化你的代码。

填充数组：

Arrays.fill()

当你需要用同一个值初始化数组的所有元素，或者将数组的某个范围内的元素重置为特定值时，

Arrays.fill()

就派上用场了。它比你手动写循环赋值要简洁得多，也更不容易出错。

import java.util.Arrays;public class ArrayFillExample {    public static void main(String[] args) {        int[] data = new int[5];        Arrays.fill(data, 100); // 将所有元素填充为 100        System.out.println("填充后数组: " + Arrays.toString(data)); // 输出: [100, 100, 100, 100, 100]        int[] partialData = new int[7];        Arrays.fill(partialData, 2, 5, 99); // 从索引 2 (包含) 到 5 (不包含) 填充为 99        System.out.println("部分填充数组: " + Arrays.toString(partialData)); // 输出: [0, 0, 99, 99, 99, 0, 0]    }}

复制数组：

Arrays.copyOf()

与

Arrays.copyOfRange()

在Java中，直接赋值数组变量只会复制引用，而不是创建数组内容的副本。如果你想得到一个独立的新数组，就需要使用

Arrays.copyOf()

或

Arrays.copyOfRange()

。这在很多场景下都非常有用，比如当你需要修改一个数组，但又不想影响原始数组时。

Arrays.copyOf(originalArray, newLength)

：创建一个新数组，包含原始数组的前

newLength

个元素。如果

newLength

小于原始数组长度，则截断；如果大于，则用默认值（如

0

或

null

）填充新增部分。

Arrays.copyOfRange(originalArray, from, to)

：创建一个新数组，包含原始数组从

from

（包含）到

to

（不包含）的元素。

import java.util.Arrays;public class ArrayCopyExample {    public static void main(String[] args) {        int[] original = {1, 2, 3, 4, 5};        System.out.println("原始数组: " + Arrays.toString(original));        // 复制整个数组，并改变长度        int[] copy1 = Arrays.copyOf(original, original.length);        System.out.println("完整复制: " + Arrays.toString(copy1)); // 输出: [1, 2, 3, 4, 5]        int[] copy2 = Arrays.copyOf(original, 3); // 截断        System.out.println("截断复制: " + Arrays.toString(copy2)); // 输出: [1, 2, 3]        int[] copy3 = Arrays.copyOf(original, 7); // 扩展        System.out.println("扩展复制: " + Arrays.toString(copy3)); // 输出: [1, 2, 3, 4, 5, 0, 0]        // 复制数组的一部分        int[] subArray = Arrays.copyOfRange(original, 1, 4); // 从索引 1 到 4 (不包含)        System.out.println("部分复制: " + Arrays.toString(subArray)); // 输出: [2, 3, 4]    }}

比较数组：

Arrays.equals()

与

Arrays.deepEquals()

比较两个数组是否相等，听起来简单，但实际上根据数组的类型和维度，有不同的处理方式。

Arrays.equals(array1, array2)

：这个方法用于比较两个一维数组是否相等。它会检查两个数组的长度是否相同，并且对应位置的元素是否都相等。对于对象数组，它会使用元素的

equals()

方法进行比较。

Arrays.deepEquals(array1, array2)

：当你处理多维数组时，

equals()

就力不从心了，因为它只会比较数组的引用。这时，你需要

deepEquals()

。它会递归地比较多维数组的每个子数组和元素，直到最底层。

import java.util.Arrays;public class ArrayComparisonExample {    public static void main(String[] args) {        int[] arr1 = {1, 2, 3};        int[] arr2 = {1, 2, 3};        int[] arr3 = {1, 2, 4};        System.out.println("arr1 和 arr2 相等吗? " + Arrays.equals(arr1, arr2)); // 输出: true        System.out.println("arr1 和 arr3 相等吗? " + Arrays.equals(arr1, arr3)); // 输出: false        String[] sArr1 = {"A", "B"};        String[] sArr2 = {"A", "B"};        System.out.println("sArr1 和 sArr2 相等吗? " + Arrays.equals(sArr1, sArr2)); // 输出: true        // 多维数组比较        int[][] multiArr1 = {{1, 2}, {3, 4}};        int[][] multiArr2 = {{1, 2}, {3, 4}};        int[][] multiArr3 = {{1, 2}, {3, 5}};        System.out.println("multiArr1 和 multiArr2 (equals): " + Arrays.equals(multiArr1, multiArr2)); // 输出: false (因为比较的是子数组的引用)        System.out.println("multiArr1 和 multiArr2 (deepEquals): " + Arrays.deepEquals(multiArr1, multiArr2)); // 输出: true        System.out.println("multiArr1 和 multiArr3 (deepEquals): " + Arrays.deepEquals(multiArr1, multiArr3)); // 输出: false    }}

在使用

equals()

和

deepEquals()

时，一定要清楚你是在比较一维数组还是多维数组，否则很容易掉进陷阱。

数组到字符串的转换：便捷的调试与展示

在开发和调试过程中，我们经常需要把数组的内容打印出来，以便检查其状态。直接打印数组对象会得到类似

[I@15db9742

这样的内存地址，这显然不是我们想要的。

Arrays

类提供了

toString()

和

deepToString()

方法来解决这个问题。

Arrays.toString(array)

：这个方法会将一维数组的所有元素转换成一个字符串，格式通常是

[element1, element2, ..., elementN]

。这是我平时调试时最常用的方法，没有之一。

Arrays.deepToString(array)

：如果你有一个多维数组，

toString()

就无能为力了，它只会打印子数组的引用。这时候，

deepToString()

就显得非常重要了，它会递归地将多维数组的所有层级都转换成字符串。

import java.util.Arrays;public class ArrayToStringExample {    public static void main(String[] args) {        int[] singleDimArray = {10, 20, 30, 40};        System.out.println("一维数组: " + Arrays.toString(singleDimArray)); // 输出: [10, 20, 30, 40]        String[] stringArray = {"Apple", "Banana", "Cherry"};        System.out.println("字符串数组: " + Arrays.toString(stringArray)); // 输出: [Apple, Banana, Cherry]        // 多维数组        int[][] multiDimArray = {{1, 2}, {3, 4, 5}, {6}};        System.out.println("多维数组 (toString): " + Arrays.toString(multiDimArray)); // 输出: [[I@hashcode, [I@hashcode, [I@hashcode] - 不理想        System.out.println("多维数组 (deepToString): " + Arrays.deepToString(multiDimArray)); // 输出: [[1, 2], [3, 4, 5], [6]] - 这才是我们想要的    }}

deepToString()

在打印复杂数据结构，尤其是多维数组时，简直是神器。它能让你一眼看清数组的完整结构和内容，省去了很多手动遍历打印的麻烦。

结合Stream API：现代Java的数组处理方式

Java 8引入的Stream API，彻底改变了我们处理集合和数组的方式。

Arrays

类也紧跟潮流，提供了

Arrays.stream()

方法，让数组也能无缝接入Stream API的强大功能。这在我看来，是现代Java开发中处理数组的一个重要趋势。

Arrays.stream()

方法可以把一个数组转换成一个

Stream

（或

IntStream

,

LongStream

,

DoubleStream

），这样你就可以利用Stream API提供的

filter()

,

map()

,

reduce()

,

collect()

等一系列高级操作来处理数组数据了。这让数组操作变得更加函数式、声明式，代码也更简洁、易读。

import java.util.Arrays;import java.util.List;import java.util.stream.Collectors;public class ArrayStreamExample {    public static void main(String[] args) {        int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};        // 筛选出偶数，然后求和        int sumOfEvens = Arrays.stream(numbers)                               .filter(n -> n % 2 == 0) // 筛选偶数                               .sum(); // 求和        System.out.println("偶数之和: " + sumOfEvens); // 输出: 偶数之和: 30        // 将数组中的每个数字乘以2，然后收集到一个新的List中        List doubledNumbers = Arrays.stream(numbers)                                             .map(n -> n * 2) // 每个数字乘以2                                             .boxed() // 将IntStream的int转换为Stream                                             .collect(Collectors.toList()); // 收集到List        System.out.println("翻倍后的数字列表: " + doubledNumbers); // 输出: 翻倍后的数字列表: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]        String[] words = {"hello", "world", "java", "stream"};        // 找出所有长度大于4的单词，并转换成大写        List longWordsUpper = Arrays.stream(words)                                            .filter(s -> s.length() > 4)                                            .map(String::toUpperCase)                                            .collect(Collectors.toList());        System.out.println("长度大于4的大写单词: " + longWordsUpper); // 输出: 长度大于4的大写单词: [HELLO, WORLD, STREAM]    }}

通过

Arrays.stream()

，你可以将传统的数组操作提升到一个新的层次，利用Stream API的并行处理能力，在处理大量数据时还能获得性能上的优势。这确实是Java在处理数据集合方面的一个

以上就是Java中Arrays类常用方法解析的详细内容，更多请关注创想鸟其它相关文章！