Java 实例 – 在数组中查找指定元素（长文解析）

Java 实例 – 在数组中查找指定元素

在 Java 编程中，数组是一种基础且高频使用的数据结构。它就像一个整齐排列的货架，每个位置上放着一个物品，而这些物品的编号（索引）从 0 开始。当我们需要从这个货架中找出某个特定商品时，比如“苹果”或“编号为 8 的书籍”，就涉及到“查找指定元素”的操作。

这不仅是面试常考题，也是日常开发中实实在在的需求。比如在学生名单中找某个名字，在成绩表中查找是否有人考了满分，甚至在游戏地图中定位某个角色的位置。掌握高效查找方法，能让你的代码更优雅、更高效。

今天我们就以“Java 实例 – 在数组中查找指定元素”为主题，从基础到进阶，一步步带你掌握这项核心技能。无论你是初学者还是有一定经验的开发者，都能从中获得实用价值。

什么是数组中的查找操作？

简单来说，数组查找就是“在一组有序数据中，判断某个值是否存在，并返回其位置或状态”。

想象你有一本电话簿，按姓氏排序。你要找“张伟”的电话号码，你会从头开始一页页翻，直到找到为止——这叫顺序查找。如果电话簿是按拼音排的，你可能会直接跳到“张”字开头的部分，再快速定位——这叫二分查找。

在 Java 中，我们主要面对两种查找方式：顺序查找和二分查找。它们各有适用场景，理解它们的原理和使用条件，是写出高效代码的关键。

创建数组与初始化

在动手查找之前，先得有一个数组。Java 中创建数组有多种方式，我们从最基础的开始。

// 声明并初始化一个整型数组
int[] numbers = { 10, 25, 33, 47, 52, 68, 71, 89, 95 };

// 或者使用 new 关键字
int[] scores = new int[5];
scores[0] = 88;
scores[1] = 92;
scores[2] = 76;
scores[3] = 95;
scores[4] = 83;

上面这段代码中，第一种方式是直接初始化，适合数据已知且数量不多的情况；第二种方式是先声明数组长度，再逐个赋值，适合动态赋值或从用户输入获取数据的场景。

注意：数组索引从 0 开始，所以 numbers[0] 是第一个元素 10，numbers[8] 是最后一个元素 95。

顺序查找：逐个比对，简单但有效

顺序查找是最直观的方法。它从数组第一个元素开始，一个一个往下比对，直到找到目标值或遍历完所有元素。

这种方法适合无序数组，或者数据量较小的情况。它的优点是逻辑简单，无需特殊条件；缺点是效率较低，最坏情况下要遍历整个数组。

public static int linearSearch(int[] arr, int target) {
    // 遍历数组中的每一个元素
    for (int i = 0; i < arr.length; i++) {
        // 如果当前元素等于目标值，返回其索引
        if (arr[i] == target) {
            return i; // 找到，返回索引
        }
    }
    // 循环结束仍未找到，返回 -1 表示未找到
    return -1;
}

使用示例

int[] data = { 10, 25, 33, 47, 52, 68, 71, 89, 95 };
int result = linearSearch(data, 68);

if (result != -1) {
    System.out.println("找到了！元素 68 在索引 " + result + " 位置");
} else {
    System.out.println("未找到该元素");
}

输出结果：

找到了！元素 68 在索引 5 位置

✅ 小贴士：返回 -1 是一种约定俗成的“未找到”标识。因为数组索引不可能为负数，所以用它表示查找失败非常合理。

二分查找：高效定位，前提是你得有序

如果你的数组是有序的（升序或降序），那就可以使用更高效的二分查找。它的思想就像猜数字游戏：你心里想一个 1 到 100 的数字，我每次猜中间的数（比如 50），你告诉我“大了”或“小了”，我再根据反馈缩小范围。

二分查找的时间复杂度是 O(log n)，远优于顺序查找的 O(n)。但注意：必须保证数组是有序的，否则结果不可靠。

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; // 目标值在左半部分，更新右边界
        }
    }

    // 未找到，返回 -1
    return -1;
}

使用示例

int[] sortedData = { 10, 25, 33, 47, 52, 68, 71, 89, 95 };
int result = binarySearch(sortedData, 33);

if (result != -1) {
    System.out.println("找到了！元素 33 在索引 " + result + " 位置");
} else {
    System.out.println("未找到该元素");
}

输出结果：

找到了！元素 33 在索引 2 位置

📌 重要提示：mid = left + (right - left) / 2 是一种防溢出写法。如果使用 (left + right) / 2，在极端大数值下可能超出 int 范围。

查找字符串数组中的元素

数组不仅支持数字，也支持字符串。在实际项目中，比如用户列表、商品名称库，经常需要查找字符串。

public static int findStringIndex(String[] arr, String target) {
    for (int i = 0; i < arr.length; i++) {
        // 使用 equals() 方法比较字符串内容，不能用 ==！
        if (arr[i].equals(target)) {
            return i;
        }
    }
    return -1;
}

示例代码

String[] fruits = { "苹果", "香蕉", "橙子", "葡萄", "草莓" };
int index = findStringIndex(fruits, "橙子");

if (index != -1) {
    System.out.println("找到了！'橙子' 在索引 " + index + " 位置");
} else {
    System.out.println("未找到该水果");
}

输出：

找到了！'橙子' 在索引 2 位置

⚠️ 注意：Java 中字符串比较必须使用 .equals()，不能用 ==。因为 == 比较的是引用地址，而 .equals() 比较的是内容。

何时选择哪种查找方式？

我们来做一个对比总结，帮助你快速判断使用哪种方法。

✅ 建议：

• 如果数组很小（比如少于 100 个元素），顺序查找足够快，代码也更简单。
• 如果数组很大且已排序，一定要用二分查找，性能提升非常明显。
• 你可以先用 Arrays.sort() 对数组排序，再使用二分查找，但记得排序本身也有开销。

实际应用案例：学生成绩查询系统

假设你正在开发一个学生成绩管理系统。你需要根据学号快速查找某个学生的信息。

class Student {
    private String name;
    private int id;
    private int score;

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

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public int getScore() {
        return score;
    }
}

// 按学号排序的学生数组
Student[] students = {
    new Student("张三", 101, 88),
    new Student("李四", 105, 92),
    new Student("王五", 108, 76),
    new Student("赵六", 112, 95)
};

// 二分查找学号为 108 的学生
public static Student binarySearchById(Student[] arr, int targetId) {
    int left = 0;
    int right = arr.length - 1;

    while (left <= right) {
        int mid = left + (right - left) / 2;
        int midId = arr[mid].getId();

        if (midId == targetId) {
            return arr[mid];
        } else if (midId < targetId) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return null;
}

调用：

Student found = binarySearchById(students, 108);
if (found != null) {
    System.out.println("找到学生：" + found.getName() + "，成绩：" + found.getScore());
} else {
    System.out.println("未找到该学生");
}

输出：

找到学生：王五，成绩：76

这个例子展示了 Java 实例 – 在数组中查找指定元素 的实际价值：让程序响应更快，用户体验更好。

总结与建议

掌握在数组中查找指定元素，是每个 Java 开发者的基本功。通过本文，你已经学会了：

• 如何创建和初始化数组；
• 使用顺序查找处理无序或小规模数据；
• 使用二分查找处理有序大规模数据；
• 如何在字符串数组中安全查找；
• 如何结合实际场景设计查找逻辑。

记住：没有“最好”的方法，只有“最合适”的方法。理解每种策略的优缺点，才能在开发中做出明智选择。

最后，动手写一写代码，哪怕只是自己模拟一个查找过程，也会让你印象更深刻。编程不是背公式，而是理解背后的逻辑。

下一次当你面对一个“在数组中找某个值”的需求时，不妨先问自己：数组有序吗？数据量多大？然后选择合适的方案。你会发现，Java 实例 – 在数组中查找指定元素 这个看似基础的问题，其实藏着很多进阶的智慧。