Java如何通过数组查询数据？

基础查询方法

线性查询（遍历）

适用于无序数组或简单查找：

public static int linearSearch(int[] arr, int target) {
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == target) {
            return i; // 返回目标索引
        }
    }
    return -1; // 未找到
}
// 示例调用
int[] numbers = {3, 7, 2, 9, 5};
int index = linearSearch(numbers, 9); // 返回 3

二分查找（有序数组）

要求数组必须有序，时间复杂度 O(log n)：

import java.util.Arrays;
public static int binarySearch(int[] arr, int target) {
    Arrays.sort(arr); // 确保有序（若未排序）
    int left = 0, 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;
}
// 示例调用
int[] sortedArr = {2, 5, 8, 12, 16};
int pos = binarySearch(sortedArr, 12); // 返回 3

多维数组查询

二维数组遍历查询

public static int[] search2DArray(int[][] matrix, int target) {
    for (int i = 0; i < matrix.length; i++) {
        for (int j = 0; j < matrix[i].length; j++) {
            if (matrix[i][j] == target) {
                return new int[]{i, j}; // 返回行列索引
            }
        }
    }
    return new int[]{-1, -1}; // 未找到
}
// 示例调用
int[][] grid = {{1, 4}, {9, 7}, {5, 2}};
int[] position = search2DArray(grid, 7); // 返回 [1, 1]

高效行列搜索（有序矩阵）

若每行有序且每列有序：

public static boolean searchSortedMatrix(int[][] matrix, int target) {
    int row = 0, col = matrix[0].length - 1; // 从右上角开始
    while (row < matrix.length && col >= 0) {
        if (matrix[row][col] == target) return true;
        else if (matrix[row][col] > target) col--; // 左移
        else row++; // 下移
    }
    return false;
}

对象数组查询

使用 equals() 方法比较自定义对象：

class Person {
    String name;
    int age;
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public boolean equals(Object obj) { // 重写equals
        if (obj instanceof Person) {
            Person p = (Person) obj;
            return this.name.equals(p.name) && this.age == p.age;
        }
        return false;
    }
}
// 查询对象数组
public static int findPerson(Person[] people, Person target) {
    for (int i = 0; i < people.length; i++) {
        if (people[i].equals(target)) {
            return i;
        }
    }
    return -1;
}

工具类辅助查询

Arrays.binarySearch()（官方库）

适用于已排序数组：

import java.util.Arrays;
int[] arr = {10, 20, 30, 40};
int index = Arrays.binarySearch(arr, 30); // 返回 2
// 注：若未排序，结果不可预测！

Stream API（Java 8+）

复杂条件查询：

import java.util.Arrays;
import java.util.OptionalInt;
int[] arr = {5, 3, 9, 1};
OptionalInt result = Arrays.stream(arr)
                          .filter(x -> x > 4) // 过滤条件
                          .findFirst();       // 获取首个匹配
if (result.isPresent()) {
    System.out.println(result.getAsInt()); // 输出 5
}

关键注意事项

1. 数组越界
   始终检查索引范围：index >= 0 && index < arr.length。
2. 空数组处理
   提前验证：if (arr == null || arr.length == 0) return -1;。
3. 对象比较
   自定义类需重写 equals() 和 hashCode()。
4. 性能选择
   • 小规模/无序数组 → 线性查找。
   • 大规模有序数组 → 二分查找。
5. 多维数组维度
   使用 arr.length 获取行数，arr[i].length 获取列数。

• 基础查询：线性遍历满足多数场景。
• 高效查询：有序数组优先用二分查找。
• 对象查询：依赖正确的 equals() 实现。
• 工具优化：善用 Arrays 和 Stream 简化代码。

引用说明：本文代码示例基于Oracle官方Java文档规范，并遵循《Effective Java》中对象比较的最佳实践，二分查找算法参考《算法导论》分治策略实现。