在Java列表中高效查找指定值之后（或最近）的元素：利用二分查找优化性能

class Row {
   int a;
   int b;
}

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

static class Row {
    int a, b;

    public int getA() { return a; }
    public int getB() { return b; }

    Row(int a, int b) {
        this.a = a;
        this.b = b;
    }

    @Override
    public String toString() {
        return "Row(" + a + ", " + b + ")";
    }
}

static final Comparator<Row> ORDER_BY_B = Comparator.comparing(Row::getB);

static Row find(int x, List<Row> rows) {
    int size = rows.size();
    // 1. 执行二分查找
    // Collections.binarySearch(list, key, comparator)
    // list: 必须是已按comparator排序的列表
    // key: 用于查找的虚拟对象，其b值设置为x
    // comparator: 用于比较list元素和key
    int i = Collections.binarySearch(rows, new Row(0, x), ORDER_BY_B);

    // 2. 解析binarySearch的返回值，计算实际目标索引
    int index;
    if (i >= 0) {
        // 情况1: 精确匹配
        // 如果找到了b值等于x的元素，i就是其索引。
        index = i;
    } else {
        // 情况2: 未找到精确匹配
        // 当未找到时，binarySearch返回 (-(插入点) - 1)。
        // 因此，实际的插入点（即第一个大于x的元素的索引）是 -(i + 1)。
        int insertionPoint = -(i + 1);

        if (insertionPoint >= size) {
            // 子情况2.1: x大于列表中所有元素的b值
            // 插入点在列表末尾或之后，意味着x比所有元素的b值都大。
            // 根据需求，此时我们返回列表中b值最大的元素（即最后一个元素）。
            index = size - 1;
        } else {
            // 子情况2.2: x小于或介于列表中某些元素的b值之间
            // insertionPoint就是第一个b值大于或等于x的元素的索引。
            index = insertionPoint;
        }
    }

    // 确保索引在有效范围内，防止空列表或极端情况下的越界
    // (虽然上述逻辑已大部分覆盖，但作为通用健壮性考虑)
    if (size == 0) return null; // 列表为空
    if (index < 0) index = 0; // x小于所有元素，取第一个
    if (index >= size) index = size - 1; // x大于所有元素，取最后一个 (此行通常被 insertionPoint >= size 逻辑处理)

    return rows.get(index);
}

public static void main(String[] args) {
    List<Row> rows = Arrays.asList(
        new Row(20, 2),
        new Row(40, 4),
        new Row(50, 5),
        new Row(70, 7));

    // 关键步骤：确保列表按b值排序，这是二分查找的前提
    // 如果原始列表rows已经根据a值排序且a的排序隐含了b的排序，
    // 则可能不需要再次排序。但为确保通用性和正确性，显式排序是最佳实践。
    List<Row> orderByB = rows.stream().sorted(ORDER_BY_B).collect(Collectors.toList());

    System.out.println("Sorted List: " + orderByB); // 打印排序后的列表

    for (int i = 0; i < 9; ++i) {
        System.out.println("查找 " + i + " : " + find(i, orderByB));
    }
}

Sorted List: [Row(2