判断 Java 数组是否有序

1. 概述

在实际开发中，我们有时需要判断一个数组是否已经按升序排列。本文将介绍几种在 Java 中实现此功能的方法，包括使用循环和递归两种常见方式，并涵盖基本类型数组、实现 Comparable 接口的对象数组，以及未实现 Comparable 接口的对象数组的处理方式。

2. 使用循环判断

最简单直接的方式是使用 for 循环逐个比较相邻元素。如果发现前一个元素大于后一个元素，则说明数组不是有序的。

2.1. 基本类型数组

对于 int[] 这样的基本类型数组，我们可以这样实现：

boolean isSorted(int[] array) {
    for (int i = 0; i < array.length - 1; i++) {
        if (array[i] > array[i + 1])
            return false;
    }
    return true;
}

✅ 优点：逻辑清晰，性能高效
⚠️ 注意：只适用于升序判断，降序需修改比较方向

2.2. 实现 `Comparable` 接口的对象数组

对于实现 Comparable 接口的对象数组（如 String[] 或 Integer[]），我们可以使用 compareTo 方法进行比较：

boolean isSorted(Comparable[] array) {
    for (int i = 0; i < array.length - 1; ++i) {
        if (array[i].compareTo(array[i + 1]) > 0)
            return false;
    }
    return true;
}

✅ 适用对象：如 String, Integer, LocalDate 等内置类

2.3. 未实现 `Comparable` 接口的对象数组

如果对象未实现 Comparable 接口，比如自定义类 Employee：

public class Employee implements Serializable {
    private int id;
    private String name;
    private int age;

    // getters and setters
}

我们可以使用 Comparator 来定义比较规则，例如按 age 字段排序：

Comparator<Employee> byAge = Comparator.comparingInt(Employee::getAge);

然后将 Comparator 作为参数传入判断方法中：

boolean isSorted(Object[] array, Comparator comparator) {
    for (int i = 0; i < array.length - 1; ++i) {
        if (comparator.compare(array[i], array[i + 1]) > 0)
            return false;
    }
    return true;
}

✅ 灵活性高：可自由定义排序字段或规则
⚠️ 注意：需确保传入的 Comparator 与数组元素类型匹配

3. 使用递归判断

虽然递归写法更偏向教学意义，但在实际开发中并不推荐，因为容易导致栈溢出。不过我们还是可以了解一下其基本实现方式。

3.1. 基本类型数组

递归方式从数组末尾开始，每次比较最后两个元素：

boolean isSorted(int[] array, int length) {
    if (array == null || length < 2) 
        return true; 
    if (array[length - 2] > array[length - 1])
        return false;
    return isSorted(array, length - 1);
}

⚠️ 注意：递归深度受限，不适用于大数组

3.2. 实现 `Comparable` 接口的对象数组

同样使用 compareTo 方法进行比较：

boolean isSorted(Comparable[] array, int length) {
    if (array == null || length < 2) 
        return true; 
    if (array[length - 2].compareTo(array[length - 1]) > 0)
        return false;
    return isSorted(array, length - 1);
}

3.3. 未实现 `Comparable` 接口的对象数组

使用 Comparator 的递归版本如下：

boolean isSorted(Object[] array, Comparator comparator, int length) {
    if (array == null || length < 2)
        return true;
    if (comparator.compare(array[length - 2], array[length - 1]) > 0)
        return false;
    return isSorted(array, comparator, length - 1);
}

❌ 不推荐：递归调用在生产环境中存在栈溢出风险，建议使用循环替代

4. 总结

我们介绍了多种判断数组是否有序的方式：

方法	适用类型	是否推荐	说明
循环判断	基本类型、对象类型	✅ 推荐	逻辑清晰，性能稳定
递归判断	基本类型、对象类型	❌ 不推荐	存在栈溢出风险，不适用于大数组

✅ 建议：在实际开发中，优先使用循环方式判断数组是否有序，逻辑清晰且性能稳定。

如需查看完整代码示例，可访问 GitHub 仓库。

Persistence

REST

Security