先聊个实际场景吧。有一次线上接口报警CPU 被打满十几个 QPS 就把服务拖到超时。查了半天锅竟然出在一个 1 万大小的 List 上——有同事在循环里反复调用list.contains()去判断某个对象是否存在。1 万条数据不算大但循环 500 次就是 5000 万次 equals 比较换谁谁都扛不住。那之后我就特别关注Java 里从 List 中快速查找对象这件事。这篇文章想聊的就是List.contains()、HashSet、HashMap、二分查找、Stream 过滤这些查找手段各自底层到底在干什么适用于什么场景百万级数据下差距能有多大以及面试里围绕着List 查找对象最常被问到的那些坑。无论你是刚学 Java 基础还是工作几年想补一补集合底层的知识这篇都值得花十分钟看完。1. 为什么普通查找会慢contains 背后的线性扫描1.1 源码层面看 contains 和 indexOf很多 Java 开发刚入行时被告知判断集合里有没有某个元素用contains()就行。这句话本身没错但很多人不知道它内部是怎么实现的。我们直接看ArrayList的源码逻辑它最终会调到一个叫indexOfRange的方法int indexOfRange(Object o, int index, int size) { if (o null) { for (int i index; i size; i) if (elementData[i] null) return i; } else { for (int i index; i size; i) if (o.equals(elementData[i])) return i; } return -1; }核心就是一个for循环从头到尾遍历数组用equals()一个一个比。数据量是 n那时间就是 O(n)。这其实和图书馆里一本一本翻书没区别你要找一本《Java 编程思想》管理员不查索引直接从第一本开始挨个看封面看完一排书架才知道有没有。LinkedList更夸张它的contains()也是线性扫描但底层是链表结构每次定位下一个节点都要通过指针跳转缓存局部性差实际速度比ArrayList还要慢一截。所以从查找角度讲链表结构在随机查找这个场景里没有任何优势。1.2 查找能生效的前提equals 必须按业务语义重写contains()用equals()比较这里有个隐藏前提你的对象必须正确重写了equals()。如果没重写用的就是Object的默认实现——直接比较两个对象的引用地址。也就是说两个 User 对象就算 name 和 id 完全一样只要它们是new了两次的不同实例list.contains(target)就永远返回false。这就是一个非常经典的基础面试误区。面试官问List 怎么判断元素是否存在一半人会说用contains追问那对象有没有重写 equals 你知道吗沉默一大片。写代码时也是一样的坑你自己定义了一个User类什么方法都没重写就敢直接调用contains等线上查不出数据的时候多半是这一层出了问题。2. 快速查找的正道HashSet 与 HashMap 的 O(1) 机制2.1 哈希是怎么回事先分区再精确比较前面说的线性扫描慢慢在每一个元素都要比。哈希结构的思路完全不同它在插入元素时就计算一个哈希值根据哈希值把元素分桶存放。查找时同样算出目标对象的哈希值直接定位到对应的桶里然后只需要在这个桶里面做小范围的equals比较。用图书馆类比更清楚图书馆按索书号分了区域你要找一本特定分类的书管理员先看索书号知道它在TP 计算机类那一排然后只在那排找而不是从大门开始一本一本翻。哈希函数就是那个索书号规则。HashSet.contains()的时间复杂度平均是 O(1)数据量越大优势越明显。使用前提非常关键hashCode()和equals()必须成对重写而且要遵守约定——两个对象 equals 相等hashCode 一定相等hashCode 相等的两个对象equals 不一定相等这就是哈希冲突。如果破坏了这条约定比如只重写 equals 不重写 hashCode那么内容相同的对象会分配到不同的桶里查找照样失效。2.2 用 HashSet 给 List 做存在性查询缓存实战中最常见的需求有一个 List要高频判断某个对象在不在里面。如果每次都调用list.contains()复杂度是 O(n) 乘以查询次数分分钟变 O(n²)。正确姿势是把 List 转成 HashSet后续查询走 O(1) 的哈希查找ListUser userList getUsersFromDb(); // 一次性构建 HashSet SetUser userSet new HashSet(userList); // 后续反复查询 boolean exists userSet.contains(targetUser);这里有个很容易忽略的点new HashSet(userList)会顺便把重复元素去掉。如果业务上不允许去重那说明你本来就不该用 Set 做唯一性判断得换个思路。另外如果既要保持 List 的原始顺序、又要快速判断存不存在可以这么做List 照常维护Set 只作为一个存在性缓存更新数据时两边同步操作。2.3 按字段查找HashMap业务键, 对象 才是真解法现实里更多的情况不是判断整个对象在不在而是根据用户 ID 找到这个 User 对象或根据订单号找到订单。这类需求你用contains完全够不到——它只告诉你在不在不会把对象还给你。常规烂写法是这样User found null; for (User u : userList) { if (u.getId().equals(10001)) { found u; break; } }这段代码没大错但如果在一个高频接口里循环查找就是性能隐患。更好的做法是用 Map 把业务键映射到对象本身MapString, User userMap userList.stream() .collect(Collectors.toMap(User::getId, u - u, (a, b) - a)); // 之后查 10001 只需要一次 get User found userMap.get(10001);注意Collectors.toMap遇到重复 key 会直接抛IllegalStateException所以第三个参数必须给一个合并函数我这里写的是(a, b) - a保留第一个。这种用内存换时间的做法在数据量几千到几百万之间基本都是最优解。构建 Map 是一次性 O(n) 的开销之后每次 get 是 O(1)典型的一次建索引终身享受。3. 二分查找有序 List 下的高效方案3.1 排序 Collections.binarySearch 的完整步骤如果 List 本身保持有序而且你不能额外占用太多内存去建 Map二分查找是另一个好选择。它的原理像猜数字在 1 到 100 里猜一个数每次都告诉我大了还是小了最多猜 7 次就能锁死。有序数组里找目标每次比较排除一半所以时间复杂度是 O(log n)。100 万条数据线性查找平均要比较 50 万次二分查找只需要大约 20 次。Java 集合框架专门提供了Collections.binarySearch()Collections.sort(list, Comparator.comparing(User::getId)); // 注意传入的 key 要和排序用的比较器对得上 User key new User(); key.setId(10001); int index Collections.binarySearch(list, key, Comparator.comparing(User::getId));如果返回的 index 大于等于 0说明找到了这个下标就是目标位置。如果返回负数表示找不到但负数的绝对值减 1 能得到如果存在应该插入的位置。这个细节面试也很爱考源码里的注释写得很清楚return -(insertion point) - 1。3.2 二分查找的适用边界和常见误区二分查找最大的先决条件就是必须先排序。很多人直接把一个没排序的 List 扔给binarySearch结果时好时坏还以为是方法有问题。另外排序用的 Comparator 和查找用的 Comparator 必须完全一致否则比较的是两套标准结果自然错乱。它适合的数据特征是一次排序、多次查询、数据基本不变。如果数据频繁增删每次增删都要恢复有序状态维护成本可能比线性查找还高。这个时候 Map 反而更合适——HashMap 的插入和查找都是 O(1)不需要维护全局有序。4. Stream API 查找代码最优雅但不等于最快4.1 filter、findAny 与 findFirst 的取舍Java 8 以后查找对象最常见的写法就是 StreamOptionalUser user userList.stream() .filter(u - 张三.equals(u.getName())) .filter(u - u.getAge() 18) .findAny();Stream 的优势在于表达力。复杂条件查找多字段组合、范围判断、模糊匹配用 Stream 写出来非常清晰读者一眼就能看懂过滤逻辑。findFirst()返回流中第一个匹配元素findAny()返回任意一个匹配元素。在串行流里两者几乎没区别但findAny()在并行流里性能更好因为它不要求满足碰到的顺序。这是我实际使用中比较推荐的没有严格顺序要求的场景一律用findAny()。4.2 别把 Stream 当性能银弹必须说清楚Stream 的filter底层依然是遍历整个 List时间复杂度还是 O(n)只不过写法优雅。它不会因为你用了 lambda 就自动变快。我的判断标准很简单如果查询条件只有按 ID 精确查那肯定用 Map不用 Stream如果查询条件是多个字段组合或者有范围条件、模糊条件那用 Stream 也没太大毛病因为这种复杂查询本来就很难建索引。真正的问题是别在循环里反复用 Stream 查同一个 List——那和循环里contains()是同一个坑复杂度照样爆炸。5. 百万级数据实测不同方案的真实差距5.1 设计一个能说明问题的对比实验光讲理论不够我建议你自己动手跑一个对比实验。思路是这样生成 100 万条 User 数据放进ArrayList分别测contains()、HashSet.contains()、Map.get()、二分查找、Stream 过滤的耗时。用System.nanoTime()前后掐表就行不用引入复杂的基准测试框架但要注意两点一是先跑几轮做 JVM 预热让热点编译生效二是每次查找的目标最好分散避免恰好命中极端情况。ListUser list new ArrayList(); for (int i 0; i 1_000_000; i) { list.add(new User(String.valueOf(i), name i)); } SetUser set new HashSet(list); MapString, User map list.stream() .collect(Collectors.toMap(User::getId, u - u)); Collections.sort(list, Comparator.comparing(User::getId)); // 对同一个目标分别测 4 种方式 String targetId 500000;5.2 实测结果该怎么解读按照我这边的经验100 万条数据单次查找大概是这样查找方式时间复杂度百万级数据单次耗时ArrayList.containsO(n)几十毫秒量级Stream filter findAnyO(n)同样几十毫秒量级Collections.binarySearchO(log n)微秒级HashSet.containsO(1) 平均亚微秒级HashMap.getO(1) 平均亚微秒级别太纠结具体数字不同机器差异很大关键是量级差距contains是几十毫秒哈希结构是零点几毫秒差两个数量级不止。如果查询次数一多这个差距会滚雪球。这也是为什么我一直强调选型比写法更重要。同样的功能用contains写两行能跑通用 HashMap 写五行才能跑通但线上稳定性完全不是一个档次。6. 那些年最容易踩的坑equals、排序和并发6.1 equals 和 hashCode 的正确重写姿势前面提过不重写 equals 会导致contains失效这里给一个标准写法。用 IDEA 的 Generate 功能可以自动生成或者手动写Override public boolean equals(Object o) { if (this o) return true; if (!(o instanceof User)) return false; User user (User) o; return Objects.equals(id, user.id) Objects.equals(name, user.name); } Override public int hashCode() { return Objects.hash(id, name); }注意Objects.hash()内部会因自动装箱产生一些开销但普通业务对象完全可接受。另外一个易错点对象一旦放进 HashSet 或作为 HashMap 的 key就不要再修改参与 hashCode 计算的字段。否则它的哈希值变了但它在集合里的存储位置不会自动更新再次查找时就会找不到。这种 bug 隐蔽性很高我在项目里见过不止一次。6.2 循环里查 List 的 O(n²) 陷阱这是性能问题的重灾区。很多代码长这样for (Order order : orderList) { User user findUserInList(userList, order.getUserId()); // 每次都是线性扫描 // ... }外层 1000 个订单内层 10000 个用户总比较次数是 1000 万。一万乘一千还不算太夸张但如果两边都是万级那就是上亿次比较接口铁定超时。重构方案永远是一样的循环之前先把查的对象放进 Map 或 SetMapString, User userMap userList.stream() .collect(Collectors.toMap(User::getId, u - u)); for (Order order : orderList) { User user userMap.get(order.getUserId()); }这个重构是我在 code review 里提得最多的优化点之一收益立竿见影。6.3 并发环境下的查找注意点ArrayList是线程不安全的。如果多个线程同时读写contains()在遍历过程中数据被修改可能导致脏读甚至ArrayIndexOutOfBoundsException。正确的选择读多写少的场景用CopyOnWriteArrayList它的contains()是弱一致的遍历的是一个不可变的快照不会抛并发异常。需要并发且按 key 查找直接用ConcurrentHashMapConcurrentHashMap.newKeySet()可以拿到一个并发安全的 Set 做存在性判断。另外并发情况下 HashMap 的扩容可能会出现死循环这是 JDK 7 时期的老问题JDK 8 改成了尾插法解决但依然不应该在并发无锁场景下直接用 HashMap——该用ConcurrentHashMap就老老实实用。7. 扩展当数据量大到内存装不下时7.1 从内存索引到外部索引的思路如果单机内存放不下全部数据几千万甚至上亿条记录上面的方案就都不适用了。此时思路要切换到外部的索引结构数据库加索引让 SQL 走 B 树查找或用搜索引擎如 Elasticsearch做倒排索引。这里我只想点出一个共性所有快速查找的本质都是提前建立一种按关键字段组织的索引结构只不过 HashMap 把索引放在内存的哈希桶里数据库把索引放在磁盘的 B 树里。理解了这一层无论前端什么框架、什么中间件对查找快的认知都是通的。7.2 面试时怎么回答这个问题面试官如果问Java 中如何从 List 集合中快速查找对象一个能让对方满意的回答思路是分层的先答基础contains()是线性遍历 O(n)前提是重写 equals。再答优化需要根据业务字段精确查找时构建HashMap或HashSet把复杂度降到 O(1)。追加补充如果 List 是有序的且不允许额外内存可以用Collections.binarySearch()O(log n)。最后展示深度说明 hashCode 与 equals 的约定、哈希冲突、以及 JDK 8 里哈希冲突严重时 HashMap 会从链表转为红黑树长度超过 8 且数组容量超过 64 时树化后最差查找从 O(n) 优化到 O(log n)。这个回答既有广度又有深度比干巴巴背contains 是 O(n)要完整得多。我自己现在的习惯是写任何查找代码前先问三个问题——数据量多大查多少次按什么字段查如果只查一两次直接 for 循环没人说什么如果按 ID 高频查一定建 Map如果既要按 ID 查又要保持插入顺序那就LinkedHashMap或者 Map List 配合。写代码可以快但选型不能懒。望着千万级数据在contains里打转的教训我是真不想再经历第二次了。