Java数组常用方法全解析

哈喽！今天心血来潮给大家带来了《Java Arrays常用方法详解》，想必大家应该对文章都不陌生吧，那么阅读本文就都不会很困难，以下内容主要涉及到，若是你正在学习文章，千万别错过这篇文章~希望能帮助到你！

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

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

解决方案

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

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

谈到数组操作，排序无疑是最频繁、也最基础的需求之一。Arrays.sort()方法就是为此而生，它提供了多种重载，能满足你对各种类型数组的排序需求。坦白说，每次需要排序，我第一个想到的就是它，因为它足够简单，而且在性能上，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()之前，务必确保你的数组是排好序的，否则，你得到的就不是“快速定位”，而是“快速迷失”了。

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

除了排序和查找，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]
    }
}

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

以上就是《Java数组常用方法全解析》的详细内容，更多关于的资料请关注golang学习网公众号！