Java中Arrays.binarySearch使用技巧-java教程-PHP中文网

Java中Arrays.binarySearch使用技巧

P粉602998670

发布： 2025-09-20 22:17:01

原创

378人浏览过

Arrays.binarySearch要求数组必须有序，否则结果不可预测；元素存在时返回索引，不存在时返回(-(插入点)-1)，可通过该值获取插入位置；支持基本类型和对象数组，对自定义对象需实现Comparable或传入Comparator以保证排序与查找逻辑一致。

java中arrays.binarysearch使用技巧

Arrays.binarySearch

登录后复制

在Java里是个寻找元素位置的利器，它的核心优势在于速度——对已排序数组，查找效率极高。但要用好它，得先明白它对数组状态的要求以及返回值的含义，这往往是新手容易踩坑的地方，理解这些是高效使用的前提。

要充分利用

Arrays.binarySearch

登录后复制

，关键在于理解其工作原理和各种使用场景。它依赖于二分查找算法，所以前提是数组必须是有序的。如果数组无序，结果是不可预测的，通常会得到一个错误的值，这比没找到还麻烦，因为你可能会误以为找到了。

来看个例子：

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.ArrayList;

public class BinarySearchTips {

    public static void main(String[] args) {
        int[] sortedArray = {10, 20, 30, 40, 50};
        int index = Arrays.binarySearch(sortedArray, 30); // 找到，返回2
        System.out.println("Found 30 at index: " + index); // 输出: Found 30 at index: 2

        int indexNotFound = Arrays.binarySearch(sortedArray, 35); // 没找到
        System.out.println("35 not found, potential insertion point: " + indexNotFound); // 输出: 35 not found, potential insertion point: -4

        // 如果数组是无序的，结果会很诡异，千万别这么用！
        int[] unsortedArray = {50, 10, 30, 20, 40};
        int weirdIndex = Arrays.binarySearch(unsortedArray, 30); // 结果可能是任何值，不可信
        System.out.println("Searching 30 in unsorted array (DO NOT DO THIS!): " + weirdIndex); // 输出结果不确定，可能为-1, -3等，但都不是30的实际位置

        System.out.println("\n--- Object Array Example ---");
        String[] names = {"Alice", "Bob", "Charlie", "David"};
        Arrays.sort(names); // 确保有序
        int nameIndex = Arrays.binarySearch(names, "Charlie");
        System.out.println("Found Charlie at index: " + nameIndex); // 输出: Found Charlie at index: 2

        // 使用Comparator进行查找
        List<Person> people = new ArrayList<>();
        people.add(new Person("Alice", 30));
        people.add(new Person("Bob", 25));
        people.add(new Person("Charlie", 35));

        // 需要先排序，这里按年龄排序
        Collections.sort(people, Comparator.comparing(Person::getAge)); 
        // 排序后: [Bob(25), Alice(30), Charlie(35)]
        System.out.println("Sorted people by age: " + people);

        // binarySearch也需要同样的Comparator
        // 注意：传入的key对象，其用于比较的属性需要与Comparator一致
        int personIndex = Arrays.binarySearch(people.toArray(new Person[0]), new Person("Unknown", 35), Comparator.comparing(Person::getAge));
        System.out.println("Found person with age 35 at index: " + personIndex); // 输出: Found person with age 35 at index: 2
    }

    // Person class (simplified for demonstration)
    static class Person {
        String name;
        int age;
        public Person(String name, int age) { this.name = name; this.age = age; }
        public String getName() { return name; }
        public int getAge() { return age; }
        @Override public String toString() { return name + "(" + age + ")"; }
    }
}

登录后复制

当元素找到时，它返回的是该元素的索引。如果没找到，它返回的是

(-(插入点) - 1)

登录后复制

。这个“插入点”指的是如果该元素存在，它应该被插入的位置，以保持数组的有序性。这个负值设计很巧妙，它能区分“找到”和“没找到”，并且还提供额外信息。比如，如果返回-3，那么实际的插入点就是

(-(-3) - 1) = 2

登录后复制

。这意味着如果你要把这个元素加进去，它应该放在索引2的位置。

立即学习“Java免费学习笔记（深入）”；

除了基本类型数组，

Arrays.binarySearch

登录后复制

也有重载方法支持对象数组，但这通常要求对象实现

Comparable

登录后复制

接口，或者在查找时提供一个

Comparator

登录后复制

。这里需要注意的是，当对对象数组使用

binarySearch

登录后复制

时，传入的

key

登录后复制

对象也需要能够与数组中的元素进行比较，并且比较逻辑要和排序时一致。

Java

binarySearch

登录后复制

性能优势与适用场景分析：为什么它比线性查找快？

Arrays.binarySearch

登录后复制

之所以快，在于它采用了二分查找算法。想象一下，你在电话簿里找一个名字，你会从头翻到尾吗？不会。你会直接翻到中间，看看名字是偏前还是偏后，然后把查找范围缩小一半。二分查找就是这个原理。每次比较，它都将搜索空间减半。对于一个包含N个元素的数组，线性查找最坏情况需要N次比较，而二分查找只需要

log₂N

登录后复制

次。

举个例子，一个有100万个元素的数组：

巧文书

巧文书是一款AI写标书、AI写方案的产品。通过自研的先进AI大模型，精准解析招标文件，智能生成投标内容。

查看详情

线性查找：最坏可能需要100万次比较。
二分查找：
```
log₂1000000
```
登录后复制
大约是20次比较。这个差距是巨大的。

所以，它的适用场景非常明确：

数据量大且需要频繁查找：当你的数据集很大，并且你经常需要查询某个元素是否存在或其位置时，二分查找的效率优势就体现出来了。
数据可以预先排序：这是前提。如果数据是动态变化的，每次查找前都需要排序，那么排序的开销可能会抵消二分查找的优势。但如果数据是相对静态的，或者只需要排序一次，那么它就非常划算。
内存效率要求高：二分查找不需要额外的内存空间，它是在原数组上进行操作的。

一个常见的误区是，有人觉得“反正数据量不大，无所谓”。但一个好的习惯是，只要条件允许（数据有序），就应该优先考虑二分查找，这是一种“防患于未然”的编程哲学。

处理

Arrays.binarySearch

登录后复制

返回负值：如何判断元素是否存在及获取插入点？

binarySearch

登录后复制

返回负值确实是新手常遇到的一个“坑”，但理解了它的逻辑，这反而是个非常实用的特性。

当

binarySearch

登录后复制

返回一个负数

登录后复制

时，这意味着目标元素在数组中不存在。这个

登录后复制

的含义是

(-(insertionPoint) - 1)

登录后复制

。那么，

判断元素是否存在：很简单，如果返回值
```
>= 0
```
登录后复制
，则存在；否则不存在。
获取插入点：如果返回值是负数
```
i
```
登录后复制
，那么实际的插入点就是
```
-(i + 1)
```
登录后复制
。

我们再用代码来强化一下理解：

import java.util.Arrays;

public class BinarySearchNegativeReturn {
    public static void main(String[] args) {
        int[] data = {10, 20, 30, 50, 60};

        // 查找存在的元素
        int foundIndex = Arrays.binarySearch(data, 30);
        if (foundIndex >= 0) {
            System.out.println("元素 30 存在，索引为: " + foundIndex); // 输出: 元素 30 存在，索引为: 2
        } else {
            System.out.println("元素 30 不存在。");
        }

        // 查找不存在的元素 40
        int notFoundIndex = Arrays.binarySearch(data, 40);
        if (notFoundIndex >= 0) {
            System.out.println("元素 40 存在，索引为: " + notFoundIndex);
        } else {
            int insertionPoint = -(notFoundIndex + 1);
            System.out.println("元素 40 不存在。如果插入，它应该在索引: " + insertionPoint); // 输出: 元素 40 不存在。如果插入，它应该在索引: 3
            // 验证：10, 20, 30, (40), 50, 60 -> 40应该在索引3
        }

        // 查找比所有元素都小的 5
        int lessThanAll = Arrays.binarySearch(data, 5);
        int insertionPointLess = -(lessThanAll + 1);
        System.out.println("元素 5 不存在。如果插入，它应该在索引: " + insertionPointLess); // 输出: 元素 5 不存在。如果插入，它应该在索引: 0

        // 查找比所有元素都大的 70
        int greaterThanAll = Arrays.binarySearch(data, 70);
        int insertionPointGreater = -(greaterThanAll + 1);
        System.out.println("元素 70 不存在。如果插入，它应该在索引: " + insertionPointGreater); // 输出: 元素 70 不存在。如果插入，它应该在索引: 5 (数组长度)
    }
}

登录后复制

这个插入点的概念在需要维护一个有序集合时非常有用，比如你可能想在不重复添加元素的前提下，将新元素插入到正确的位置，保持数组的有序性。

binarySearch

登录后复制

在对象数组和自定义类型中的应用：

Comparable

登录后复制

与

Comparator

登录后复制

的选择

当处理对象数组时，

Arrays.binarySearch

登录后复制

的灵活性体现在它对

Comparable

登录后复制

接口和

Comparator

登录后复制

函数式接口的支持上。

如果你的对象本身就有一个“自然顺序”，比如

String

登录后复制

按字母顺序，

Integer

登录后复制

按数值大小，那么让你的自定义类实现

Comparable<T>

登录后复制

接口是最好的选择。

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

class Book implements Comparable<Book> {
    String title;
    int year;

    public Book(String title, int year) {
        this.title = title;
        this.year = year;
    }

    @Override
    public int compareTo(Book other) {
        // 自然顺序：按年份升序，年份相同则按标题字母序
        if (this.year != other.year) {
            return Integer.compare(this.year, other.year);
        }
        return this.title.compareTo(other.title);
    }

    @Override
    public String toString() {
        return "Book{" + "title='" + title + '\'' + ", year=" + year + '}';
    }
}

public class BinarySearchObject {
    public static void main(String[] args) {
        Book[] books = {

登录后复制

以上就是Java中Arrays.binarySearch使用技巧的详细内容，更多请关注php中文网其它相关文章！