Java 实例 – 数组排序及元素查找（完整教程）

Java 实例 – 数组排序及元素查找

在学习 Java 的过程中，数组是一个绕不开的基础数据结构。它就像一个整齐排列的货架，每一个格子都存放着一个数据，方便我们快速查找和处理。而当数据量变大时，如何高效地对这些数据进行排序和查找，就成了开发者必须掌握的核心技能。今天我们就通过几个典型的 Java 实例，深入讲解数组排序与元素查找的常见方法，帮助你从初学者进阶到能够熟练运用这些技术的中级开发者。

数组排序：从无序到有序的魔法

想象一下，你有一堆杂乱无章的书，想快速找到某一本。如果书是按书名排序的，找起来是不是快多了？数组排序就是这个道理。Java 提供了多种排序方式，其中最常用的是 Arrays.sort() 方法，它基于快速排序算法，效率高且稳定。

下面是一个基本的整型数组排序示例：

import java.util.Arrays;

public class ArraySortExample {
    public static void main(String[] args) {
        // 定义一个未排序的整型数组
        int[] numbers = {64, 34, 25, 12, 22, 11, 90};

        // 使用 Arrays.sort() 对数组进行升序排序
        Arrays.sort(numbers);

        // 输出排序后的结果
        System.out.println("排序后的数组：");
        for (int num : numbers) {
            System.out.print(num + " ");
        }
        // 输出：11 12 22 25 34 64 90
    }
}

代码注释：

import java.util.Arrays;：引入 Java 标准库中的 Arrays 工具类，它提供了排序、查找等实用方法。
int[] numbers = {64, 34, 25, 12, 22, 11, 90};：声明并初始化一个整型数组，包含 7 个无序元素。
Arrays.sort(numbers);：调用排序方法，将原数组按升序重新排列。
for (int num : numbers)：增强 for 循环，遍历数组中的每个元素并打印。

💡 小贴士：Arrays.sort() 默认按升序排序。如果需要降序，可以使用 Collections.reverseOrder() 与包装类结合，稍后我们会讲到。

字符串数组的排序与自定义规则

除了数字，字符串数组的排序也很常见。比如你有一组用户姓名，想按字母顺序排列。Java 也支持字符串排序，但要注意大小写问题。

import java.util.Arrays;

public class StringSortExample {
    public static void main(String[] args) {
        String[] names = {"Alice", "bob", "Charlie", "diana", "Eve"};

        // 按字典序排序（默认大小写敏感）
        Arrays.sort(names);

        System.out.println("按字典序排序后的名字：");
        for (String name : names) {
            System.out.println(name);
        }
        // 输出：Alice, Charlie, Eve, bob, diana
    }
}

代码注释：

Arrays.sort(names);：对字符串数组进行字典序排序，大写字母排在小写字母之前。
输出结果中，Alice 在 Charlie 前，但 bob 和 diana 因为以小写开头，排在后面。

如果你想忽略大小写，可以传入自定义比较器：

Arrays.sort(names, String.CASE_INSENSITIVE_ORDER);

这样，排序时会将大小写视为相同，结果变为：Alice, bob, Charlie, diana, Eve。

二分查找：快速定位元素的利器

当你有一个已经排序好的数组，想查找某个元素是否存在，二分查找（Binary Search）是效率最高的方式。它的核心思想是“分而治之”——每次将搜索范围缩小一半。

Java 提供了 Arrays.binarySearch() 方法，专为已排序数组设计。

import java.util.Arrays;

public class BinarySearchExample {
    public static void main(String[] args) {
        int[] sortedNumbers = {11, 12, 22, 25, 34, 64, 90};

        // 查找元素 25 是否存在
        int index = Arrays.binarySearch(sortedNumbers, 25);

        if (index >= 0) {
            System.out.println("元素 25 在索引 " + index + " 处找到。");
        } else {
            System.out.println("元素 25 未找到。");
        }
        // 输出：元素 25 在索引 3 处找到。
    }
}

代码注释：

Arrays.binarySearch(sortedNumbers, 25);：在已排序数组中查找值为 25 的元素。
返回值为非负数表示找到了，返回值为负数表示未找到。
若未找到，返回值为 -(插入位置 - 1)，可用于判断应插入的位置。

⚠️ 重要提醒：二分查找必须作用于已排序的数组，否则结果不可靠。

手动实现二分查找（加深理解）

虽然 Java 提供了现成方法，但理解其实现逻辑对掌握算法思维非常重要。下面是一个手动实现的二分查找版本：

public class ManualBinarySearch {
    // 手动实现二分查找，返回元素索引或 -1（未找到）
    public static int binarySearch(int[] arr, int target) {
        int left = 0;           // 左边界
        int right = arr.length - 1; // 右边界

        while (left <= right) {
            int mid = left + (right - left) / 2; // 防止整数溢出

            if (arr[mid] == target) {
                return mid; // 找到目标，返回索引
            } else if (arr[mid] < target) {
                left = mid + 1; // 目标在右半部分
            } else {
                right = mid - 1; // 目标在左半部分
            }
        }

        return -1; // 未找到
    }

    public static void main(String[] args) {
        int[] data = {10, 20, 30, 40, 50};
        int result = binarySearch(data, 30);

        if (result != -1) {
            System.out.println("找到元素 30，索引为 " + result);
        } else {
            System.out.println("未找到元素 30");
        }
    }
}

代码注释：

left + (right - left) / 2：这是计算中间位置的安全方式，避免 left + right 太大导致溢出。
while (left <= right)：只要搜索范围有效，就继续。
每次比较后，更新 left 或 right，缩小搜索区间。
最终未找到时返回 -1。

多种数据类型的排序与查找实践

在实际项目中，我们可能需要处理对象数组。比如一个学生列表，按成绩排序或按姓名查找。这时可以使用 Comparator 接口。

import java.util.Arrays;
import java.util.Comparator;

class Student {
    String name;
    int score;

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return name + " - " + score;
    }
}

public class StudentSortAndSearch {
    public static void main(String[] args) {
        Student[] students = {
            new Student("张三", 88),
            new Student("李四", 92),
            new Student("王五", 76),
            new Student("赵六", 95)
        };

        // 按成绩从高到低排序
        Arrays.sort(students, Comparator.comparingInt(s -> -s.score));

        System.out.println("按成绩降序排列：");
        for (Student s : students) {
            System.out.println(s);
        }
        // 输出：赵六 - 95, 李四 - 92, 张三 - 88, 王五 - 76

        // 查找名字为 "李四" 的学生
        Student target = new Student("李四", 0);
        int index = Arrays.binarySearch(students, target, Comparator.comparing(s -> s.name));

        if (index >= 0) {
            System.out.println("找到学生：" + students[index]);
        } else {
            System.out.println("未找到学生李四");
        }
    }
}

代码注释：

Comparator.comparingInt(s -> -s.score)：按成绩降序排列，负号实现反向。
Arrays.binarySearch(students, target, ...)：传入比较器，确保查找时按名字比较。
这种方式可灵活应对复杂对象的排序与查找需求。

总结与建议

通过本篇 Java 实例 – 数组排序及元素查找的讲解，我们系统地学习了：

如何使用 Arrays.sort() 对基本类型与对象数组进行排序；
如何通过 Arrays.binarySearch() 高效查找已排序数组中的元素；
如何手动实现二分查找，加深对算法的理解；
如何使用 Comparator 实现自定义排序与查找逻辑。

这些技能不仅在面试中高频出现，更在日常开发中广泛应用。例如，处理用户列表、订单数据、成绩排名等场景，都离不开排序与查找。

✅ 建议初学者先从基础排序开始，熟练掌握 Arrays.sort() 和 binarySearch()，再逐步学习自定义比较器与算法实现。

记住：排序是查找的前提，在使用二分查找前，务必确保数组已排序。否则，结果将不准确。

实用技巧速查表

操作	方法	说明
数组升序排序	`Arrays.sort(arr)`	适用于基本类型与实现 `Comparable` 的对象
降序排序	`Arrays.sort(arr, Collections.reverseOrder())`	需导入 `java.util.Collections`
二分查找	`Arrays.binarySearch(arr, key)`	仅适用于已排序数组
自定义排序	`Arrays.sort(arr, comparator)`	用于复杂对象排序
手动实现二分查找	循环 + 中点判断	理解算法逻辑的必经之路

掌握这些技巧后，你就能在面对大量数据时，快速完成排序与查找任务。无论是写项目、做算法题，还是应对面试，都能游刃有余。希望这篇 Java 实例 – 数组排序及元素查找能成为你学习路上的一盏明灯。继续加油，未来的 Java 工程师！