Java中Arrays类常用方法解析-java教程-PHP中文网

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

java中arrays类常用方法解析

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()

登录后复制

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

法语写作助手

法语助手旗下的AI智能写作平台，支持语法、拼写自动纠错，一键改写、润色你的法语作文。

查看详情

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

除了排序和查找，

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<Integer> doubledNumbers = Arrays.stream(numbers)
                                             .map(n -> n * 2) // 每个数字乘以2
                                             .boxed() // 将IntStream的int转换为Stream<Integer>
                                             .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<String> longWordsUpper = Arrays.stream(words)
                                            .filter(s -> s.length() > 4)
                                            .map(String::toUpperCase)
                                            .collect(Collectors.toList());
        System.out.println("长度大于4的大写单词: " + longWordsUpper); // 输出: 长度大于4的大写单词: [HELLO, WORLD, STREAM]
    }
}

登录后复制

通过