java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Java ArrayList按对象属性查找

Java ArrayList如何实现按对象属性查找

作者:菩提风

在Java集合框架中,按对象属性查找是日常开发最常用的操作之一,本文将深入解析ArrayList的contains和indexOf的原理,教你如何正确重写equals和hashCode,并使用Stream、HashMap索引等高效查找方式,掌握这些技巧,轻松应对各种按属性查找场景

你在写一个订单导出接口,前端传过来一个 userId,后端内存里正好有一批已经查好的用户对象列表,你要做的就是把这个人从 List<User> 里捞出来。这需求听起来太基础了,基础到很多人直接在 IDE 里敲了一个 list.contains(user) 或者 list.indexOf(user) ,然后装箱发布。但就是这个“简单到不需要思考”的操作,我在 Code Review 里见过无数次翻车现场——有人明明打印出来的两个对象属性一模一样, contains 却返回 false ;有人查回来的对象跟他想要的不是同一个;还有人因为没重写 equals ,在循环里一路查下去全部落空。

这篇文章就围绕一件事展开: Java 的 ArrayList 里,按对象属性查找元素的正确姿势到底是什么 。这里面牵扯到的核心知识点其实就一句话——在 Java 里做对象查找,本质上是在定义“相等”的语义,不管你用 indexOf 、 contains 、 stream 里的 filter ,还是自己造一个 HashMap 索引,背后全都要过 equals 这道关。把这条主线吃透,后面所有的写法都是同一个思想的不同表达。

适合什么人看?刚学到集合框架的同学,建议从头到尾读一遍;准备 Java 面试的,重点看第 6 部分,那些延伸问题几乎每次面试都会被拎出来问;已经在写业务代码、想把手底下的查找逻辑写得更干净的老开发,可以直接跳到第 4 和第 5 部分,那里有我实际项目里踩坑之后整理出来的索引方案和工具类封装思路。

1. 先搞清楚 indexOf 和 contains 为什么经常“查不到”

先说一个我见过很多次的场景。有人从数据库查了一堆用户,放在 ArrayList<User> 里,然后根据前端传过来的 id 查用户信息。他的第一个想法是:我把 targetUser 这个对象 new 出来,直接把里面的 id、name 都塞进去,然后调 userList.contains(targetUser) ,如果返回 true ,就代表查到了。听起来逻辑没毛病,但跑起来往往不是那么回事。

1.1 源码层面:contains 和 indexOf 的判断依据

ArrayList.contains(Object o) 的内部实现是这样的:

public boolean contains(Object o) {
    return indexOf(o) >= 0;
}

public int indexOf(Object o) {
    if (o == null) {
        for (int i = 0; i < size; i++)
            if (elementData[i] == null)
                return i;
    } else {
        for (int i = 0; i < size; i++)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

注意看: contains 本质上就是把传入的对象跟数组里的每一个元素做 equals 比较。

问题就出在这个 equals 上。如果你没有在 User 类里重写 equals ,那么调用的就是 Object.equals 的默认实现—— 比较两个对象的引用地址是否相同 。换句话说,即使 new User("1001", "张三") 和 userList 里那个 User("1001", "张三") 的每一个字段都一模一样,只要它们是两个不同的对象,内存地址不一样, contains 就返回 false 。

这就是很多人“明明数据一样却查不到”的根本原因: 你拿去找的不是列表里原有的那个对象,而是一个内容相同但身份不同的新对象。 问题不在 ArrayList,在于你没有定义“什么算相等”。

1.2 重写 equals 时最容易忽略的 hashCode 约束

要让 contains 和 indexOf 按预期工作,就得重写 User 类的 equals 。但这里有个铁律: 重写了 equals ,就必须重写 hashCode 。

为什么?因为 ArrayList 的 contains 只用 equals ,但 HashMap 、 HashSet 、 HashTable 这些散列集合不一样。它们先用 hashCode 定位到某个桶,然后再用 equals 比较桶里的元素。如果你重写了 equals 但不重写 hashCode ,就会出现一种非常诡异的现象:两个对象 equals 比较返回 true ,但它们的 hashCode 不一样,放进 HashSet 后会被当成两个不同的元素,用 HashMap 按属性查 key 也会查不到。

举个实际例子:

public class User {
    private String id;
    private String name;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return Objects.equals(id, user.id);
    }

    // 忘记重写 hashCode
}

equals 用 id 判断相等,但 hashCode 还是 Object 默认的实现。这时候如果你把一个 User 放进 HashSet ,再 new User("1001") 去查,基本查不到——因为两个对象的哈希值不一样,连桶都进不去。

正确的做法是同步重写 hashCode :

@Override
public int hashCode() {
    return Objects.hash(id);
}

Objects.hash 内部会处理 null 的情况,比自己手写一个 id.hashCode() 要稳。为什么强调这一点?因为 按属性查找的场景往往紧接着就是去重、分组、放进 Map 索引这些操作,equals 和 hashCode 不一致会连环炸 。

1.3 别一刀切:equals 的判定范围要按业务定义

还有一个容易踩的坑:equals 里比较哪些字段,直接决定你的查找逻辑是不是符合业务预期。

假设 User 有 id 、 name 、 age 、 mobile 四个字段。如果你在 equals 里把四个字段全部比较一遍,那业务上的语义就是“四个字段都一样才算同一个用户”。但很多业务场景里, id 才是唯一标识——两个 id 相同的用户对象,哪怕 name 因为中间改了数据库而不同,也应该是同一个人。这时候如果你用全字段相等, contains(new User("1001", "李四", 20, null)) 可能返回 false ,因为它跟列表里 User("1001", "张三", 20, "138...") 的 name 和 mobile 对不上。

我的建议是: 对于有业务主键的实体类,equals 里优先比较主键 。比如用户、订单、商品这类有唯一 id 的对象,equals 只看 id 就够了;只有像坐标点、金额明细这种没有天然主键、纯粹靠值语义区分的对象,才适合把全部字段都纳入比较。

equals 的重写过程可以用一行顺口溜记: 先比地址,再比类型,最后比关键字段 。类型比较的地方,用 getClass() != o.getClass() 还是 o instanceof User ,取决于业务上允不允许子类跟父类相等。大多数实体类不涉及继承,用 getClass() 更严谨一点。

2. 查单个对象:遍历、Stream、迭代器到底怎么选

搞清楚了 equals 的原理,后面怎么写都是顺理成章的事。查单个对象,核心诉求是拿到那个匹配的元素,找不到的时候再给一个兜底处理。这个场景下,常见的有三条路线。

2.1 传统 for 循环:最笨但永远不过时的写法

User findUserById(List<User> userList, String targetId) {
    User result = null;
    for (User user : userList) {
        if (Objects.equals(user.getId(), targetId)) {
            result = user;
            break;
        }
    }
    return result;
}

很多人觉得这种写法“太土”,但它的优点恰恰是土得踏实:逻辑直白、没有任何额外对象生成、调试的时候断点随便打、中间状态一目了然。性能上也不差——遍历列表本来就是 O(n),for 循环和 Stream 的时间复杂度没有区别,for 循环甚至因为少了 Stream 框架的开销,在极端大的列表上反而稍微快一点。

需要注意两个细节:

  1. 比较用 Objects.equals(u.getId(), targetId) ,不要用 u.getId().equals(targetId) 。因为前者对 null 安全,后者在 u.getId() 为 null 时会抛空指针。
  2. 找到后记得 break 。虽然对性能影响不大(反正后面没有了),但这是一个习惯问题: 查询语义本身就是要拿到第一个匹配项,没必要把整个列表扫完 。不写 break 的人多半是没想清楚“我已经找到了”这个状态。

2.2 Stream 流式查找:findFirst、findAny、orElse 的真实用法

Java 8 以后,Stream 是很多人写查找的首选:

User result = userList.stream()
        .filter(user -> Objects.equals(user.getId(), targetId))
        .findFirst()
        .orElse(null);

这段代码的可读性确实比 for 循环好,尤其是当你连续写了好几个查找逻辑时,链式调用会显得非常干净。这里面的几个方法,每个都有各自的门道:

还有一个容易被忽略的点: orElse 和 orElseGet 的差异。 orElse(T other) 里的参数不管有没有匹配结果,都会先被求值; orElseGet(Supplier<? extends T> supplier) 是懒加载的,只有真的没匹配到时才会执行 supplier。如果兜底对象创建成本很低,两者没区别;如果创建一个默认对象要做一堆初始化,务必用 orElseGet 。我在项目里见过有人写 orElse(new User()) ,结果每次查询都 new 了一个没用上的对象。数据量小无所谓,数据量大或者对象构造复杂时就是白花花的开销。

Stream 写法也有一个限制: lambda 表达式里访问的外部变量必须是 effectively final 。如果你想在循环里不断修改变量,用 Stream 会很难受,这种场景更适合 for 循环。

2.3 迭代器场景:边查边删时才需要它

查找本身不需要迭代器,for 循环和 Stream 足够。但有一种近亲场景: 不仅要把匹配的元素找出来,还要把它从原列表里删掉 。这时候直接在 for 里删除是危险的:

for (User user : userList) {
    if (Objects.equals(user.getId(), targetId)) {
        userList.remove(user); // 会抛 ConcurrentModificationException
    }
}

增强 for 循环底层用的是 Iterator , Iterator 会维护一个 expectedModCount 跟 ArrayList 的 modCount 做比对,你在遍历过程中调 list.remove() ,会修改 modCount ,下一次 iterator.next() 时就发现两个数字对不上,直接抛异常。

正确做法是使用 Iterator.remove() :

Iterator<User> iterator = userList.iterator();
while (iterator.hasNext()) {
    User user = iterator.next();
    if (Objects.equals(user.getId(), targetId)) {
        iterator.remove();
        break;
    }
}

如果只是基于某个属性条件批量删除,更简单的方式是 removeIf :

userList.removeIf(user -> Objects.equals(user.getId(), targetId));

removeIf 底层已经帮你处理好了迭代过程中的删除问题,这也是 JDK 8 给集合框架加的好东西。很多人只知道 foreach 删除会报错,但不知道 Iterator.remove() 和 removeIf 才是推荐解,面试里这也算是个高频追问点。

把三种方式放到一起看:

方式可读性性能适配场景
传统 for + equals高,逻辑直白O(n),无额外开销通用场景,适合调试
Stream + findFirst最高,链式干净O(n),略有框架开销日常查找,配合 Optional 处理空值
Iterator / removeIf中O(n)查找的同时需要删除元素

3. 查出一批匹配对象:filter + collect 的组合套路

单个查找解决的是“这个人在不在”的问题,但业务里还有一种更常见的需求: 把符合某个条件的一堆对象都找出来 。比如按部门编码查部门下所有用户、按状态查所有待处理的订单。这种场景用 findFirst 就不合适了,正确姿势是 filter 配合 collect 。

3.1 一个批量匹配的完整示例

假设用户对象里有 deptCode 字段,现在要找出所有 A001 部门的用户:

List<User> aDeptUsers = userList.stream()
        .filter(user -> "A001".equals(user.getDeptCode()))
        .collect(Collectors.toList());

这里有一个很关键的写法习惯: 把常量放在前面 , "A001".equals(user.getDeptCode()) 。为什么?因为 String.equals 方法对 null 是安全的,如果 user.getDeptCode() 是 null,这行代码返回 false ,不会抛异常;反过来写 user.getDeptCode().equals("A001") ,在 getDeptCode() 为 null 时直接空指针。

这种“常量在前”的反转写法看起来有点违反直觉,但它在处理可能为 null 的字段时是最省事、最安全的。当然,更推荐的还是 Objects.equals(user.getDeptCode(), "A001") ,语义更清晰,也同样是 null 安全。

如果你不想收集成 List ,还可以换成别的收集器: Collectors.toSet() 去重, Collectors.toMap() 转成 Map, Collectors.groupingBy() 分组。这些都是同一个思想的延伸—— 先把符合条件的元素筛出来,再按你需要的数据结构收集 。

3.2 匹配结果为空:别上来就抛异常

批量查找结果为空是一个正常状态,不等于错误。很多新手一看到 collect(Collectors.toList()) 返回了空列表,下意识就抛异常,这其实是把“空集合”和“异常”混为一谈了。

我的处理原则是:

这里顺便提一个常见的坑:有人喜欢在 filter 后面直接加 .get() ,比如 stream.filter(...).findFirst().get() 。这在能找到时没问题,找不到就直接 NoSuchElementException ,而且异常信息特别不友好,调试的时候完全不知道是哪个条件没匹配上。规范做法是给 orElseThrow 传一个带业务信息的异常:

User user = userList.stream()
        .filter(u -> Objects.equals(u.getOrderId(), orderId))
        .findFirst()
        .orElseThrow(() -> new BizException("订单不存在: " + orderId));

这样报错的时候日志里直接能看到是哪个订单号查不到,排查效率完全不一样。

3.3 在循环里删除匹配项为什么会抛 ConcurrentModificationException

批量查找常常伴随批量删除,这在做“清理无效数据”类功能时非常常见。前面第 2 小节提过增强 for 循环里删除会抛异常,这里我要再多说两句关于 ConcurrentModificationException 的原理,因为很多人只知道结论,不知道根因。

ArrayList 内部维护了一个 modCount 字段,记录结构性修改的次数。 Iterator 在创建时会把这个值保存为 expectedModCount ,每次调用 next() 都会检查两者是否相等。你调用了 list.remove() , modCount 增加了,但 iterator 手里的 expectedModCount 没变,下一次 next() 一对比,不一致,就抛了 ConcurrentModificationException 。

注意这个异常的名字很具误导性,它 不是 只有多线程并发修改才会抛,单线程里一边遍历一边删,照样抛。

所以当你要在遍历中删除匹配元素时,记住三选一:

  1. 用 Iterator.remove() ;
  2. 用 removeIf ;
  3. 先收集要删除的元素,遍历结束后统一 removeAll 。

第三种在实际业务中也很常用,尤其是删除条件比较复杂、需要多步判断的时候:

List<User> toRemove = userList.stream()
        .filter(user -> user.getStatus() == Status.INVALID)
        .collect(Collectors.toList());
userList.removeAll(toRemove);

4. 数据量上来了,别傻傻地反复遍历

contains 、 filter 、for 循环,它们的共同点是时间复杂度都是 O(n)—— 每查一次,就要把整个列表从头到尾扫一遍 。业务量小的时候无所谓,几千条数据随便扫,但一旦数据量到几万、几十万,而且同一个列表频繁按属性查询,问题就来了。

我接手过一个导出功能,用户的筛选条件有好几个,每个筛选条件都要在内存列表里查一遍对象,接口调用一次,列表被完整遍历了七八次,高峰期直接把这个接口的响应时间拖到了两三秒。后来优化方案不是去调 SQL,而是在内存里建索引。

4.1 什么时候才值得为查找建索引

不是所有场景都需要建索引,建索引也有成本:占内存、需要维护、数据变更时要同步更新。我一般按下面几个条件判断:

条件满足时
列表数据量较大(上万起步)值得考虑索引
同一个属性被反复查询一定要建索引
数据在查询期间相对稳定索引生命周期好管理
内存足以容纳额外的一份 Map可以建索引

如果一条都不满足,老老实实用 Stream 遍历就行,不要为了炫技给自己找维护负担。如果满足两条以上,优先考虑 HashMap 索引。

4.2 用 HashMap 建单值索引

我们要找的是“按 userId 查 User”,那就把 List<User> 转换成一个 Map<String, User> :

Map<String, User> userIndex = userList.stream()
        .collect(Collectors.toMap(
                User::getId,
                Function.identity(),
                (oldValue, newValue) -> newValue
        ));

// 查找直接 O(1)
User user = userIndex.get(targetId);

注意三个细节:

  1. 函数式接口 Function.identity() :等价于 user -> user ,就是“把 User 自己作为 value”。这样写更简洁,不过有人觉得 user -> user 可读性更好,看团队习惯。
  2. mergeFunction 一定不能省 。 Collectors.toMap 如果遇到重复 key 且没有传 mergeFunction,会直接抛 IllegalStateException: Duplicate key 。这在真实数据里太常见了,你以为 id 唯一,结果数据库里有脏数据或者查询条件不够精确,两个对象同一个 id,不写 mergeFunction,程序当场炸给你看。传了 (oldValue, newValue) -> newValue 之后,遇到重复 key 会保留后一个,逻辑上等于“后面的覆盖前面的”。
  3. key 为 null 时要小心 。 HashMap 允许 null key, Collectors.toMap 也允许,但如果后续你用 userIndex.get(targetId) 去查,而 targetId 是 null,可能给你返回一个不是预期中的对象。如果业务上 id 不允许为 null,最好在构建索引前做一层过滤。

建索引的收益很明显:查一次从 O(n) 降到 O(1),如果每次请求要查多个属性,可以分别建多个 Map,内存换时间,非常划算。

4.3 一对多分组索引:groupingBy 的威力

但前面说的是“一个属性唯一确定一个对象”的情况。如果属性不是唯一的,比如你要按 deptCode 查部门下所有用户,一个部门对应多个用户,那就不能用 toMap ,得用 groupingBy :

Map<String, List<User>> usersByDept = userList.stream()
        .collect(Collectors.groupingBy(User::getDeptCode));

// 使用
List<User> aDeptUsers = usersByDept.getOrDefault("A001", Collections.emptyList());

这段代码把整个列表按部门编码分组,之后按部门查用户就是一次 Map 的 get 操作,同样是 O(1) 级别。注意 getOrDefault 的第二个参数,如果某个部门下没有用户, get 会返回 null,用 getOrDefault(key, Collections.emptyList()) 可以避免返回 null 后调用方还要做判空。

这里还有一个容易忽视的点: groupingBy 默认收集到 List,如果你确定分组结果不需要保持顺序,可以加第二个参数 :

Map<String, Set<User>> usersByDept = userList.stream()
        .collect(Collectors.groupingBy(User::getDeptCode, Collectors.toSet()));

对于去重有要求的场景就很实用。但注意 User 放进 HashSet 或作为 HashMap 的 key 时,一定得保证 equals 和 hashCode 是配套的,这就是第 1 部分反复强调的问题。你会发现,前面每讲一个容器特性,后面都在为 equals/hashCode 的一致性做铺垫——它们是整个集合框架的地基,绕不开。

5. 进阶玩法:方法引用、通用工具方法、反射兜底

到这一部分,基础的查找姿势已经讲得差不多了。接下来是让代码更优雅、更通用的几个进阶技巧,也是我在项目里沉淀下来的东西。

5.1 字符串比较的 null 安全:把常量放在前面的意义

先回到一个非常容易出错的细节。用 Stream 按属性过滤时,很多人写成:

userList.stream()
        .filter(user -> user.getName().equals("张三"))
        .collect(Collectors.toList());

这段代码在 user.getName() 不为 null 时没问题,但只要某个用户的 name 字段是 null,直接抛 NullPointerException 。数据库里的字段允许为 null 是常态,你在代码里写的判断逻辑也不能假设它一定不为 null。

两种写法都可以规避:

// 写法一:常量在前
.user -> "张三".equals(user.getName())

// 写法二:Objects.equals
.user -> Objects.equals(user.getName(), "张三")

我个人更推荐 Objects.equals ,因为它的意图更明确:你可能并不关心目标值是位于调用对象还是参数位置,你只关心“这两个值是否相等,且都不为空时才相等”。对于非 String 类型,比如 Integer、Long、枚举,用 Objects.equals 也是通吃,一套写法用到头。

5.2 用 Function 泛型封装一个通用按属性查找工具

实际项目里,同一个列表被按 id、按 code、按 name 分别查的情况太多了。每次写一遍 stream().filter() 倒也不是不行,但代码会显得非常冗余。这时候可以封装一个泛型工具方法,把“属性”作为参数传进去:

public static <T> List<T> findByField(List<T> source,
                                      Function<T, String> fieldGetter,
                                      String expectedValue) {
    return source.stream()
            .filter(item -> Objects.equals(fieldGetter.apply(item), expectedValue))
            .collect(Collectors.toList());
}

使用的时候非常顺手:

List<User> users = CollectionUtils.findByField(userList, User::getId, "1001");
List<User> byName = CollectionUtils.findByField(userList, User::getName, "张三");
List<User> byDept = CollectionUtils.findByField(userList, User::getDeptCode, "A001");

这个工具类用到了 Function<T, String> 这个函数式接口,它的语义是“从一个对象里取某个字段的 getter”。Java 里的方法引用 User::getId 完美契合这个接口——你看,平时写 lambda 和写方法引用的时候觉得是语法糖,用到泛型工具里才发现它是真的能帮你把重复代码压掉大半。

如果还想支持更多类型,可以把 String 换成泛型:

public static <T, R> List<T> findByField(List<T> source,
                                         Function<T, R> fieldGetter,
                                         R expectedValue) {
    return source.stream()
            .filter(item -> Objects.equals(fieldGetter.apply(item), expectedValue))
            .collect(Collectors.toList());
}

这样 Integer 的 age、枚举类型的 status 都可以用同一个方法处理,一个工具方法覆盖整个项目里的按属性查找需求。

5.3 反射真能按属性名查找,但我不推荐在业务里用

面试的时候有人会问:能不能不传 getter,传一个属性名字符串进去,用反射拿到 Field,再取值做比较?可以,写出来大概是这样的思路:

public static <T> List<T> findByFieldName(List<T> source,
                                          String fieldName,
                                          Object expectedValue) throws Exception {
    Field field = source.get(0).getClass().getDeclaredField(fieldName);
    field.setAccessible(true);
    return source.stream()
            .filter(item -> {
                try {
                    return Objects.equals(field.get(item), expectedValue);
                } catch (IllegalAccessException e) {
                    throw new RuntimeException(e);
                }
            })
            .collect(Collectors.toList());
}

这个方案在写通用框架、查询组件这类场景下是有价值的,因为框架不知道调用方的实体类长什么样,只能用反射兜底。但在普通业务代码里,我明确不推荐:

  1. 性能损耗 。反射调用比直接调用 getter 慢,数据量大时差距会被放大。
  2. 类型安全缺失 。属性名拼错、类型写错,编译期完全发现不了,要跑到运行期才炸,排查成本高。
  3. 模块化限制 。从 Java 9 开始模块系统对反射访问有严格控制,你依赖的那个类如果没开放 exports , setAccessible(true) 会直接报 InaccessibleObjectException 。
  4. 可读性差 。用方法引用的通用工具,IDE 可以跳转、编译期能检查;用反射版本,整个查找逻辑就像黑盒,别人接手时完全看不出来它到底在比较什么字段。

结论是: 通用性优先选方法引用 + Function 的方案,反射留给框架层 。这也是我判断一个技术该不该用的标准——用它是因为它能解决你没别的办法解决的问题,而不是因为它看起来很强大。

6. 面试常问的延伸问题与工程化自查清单

这一部分既是给准备面试的同学划重点,也是给日常写代码的人补一个收尾的检查清单。因为按属性查找这个操作,在面试里通常不是单独问的,而是作为一系列集合框架问题的引子,一环扣一环往下挖。

6.1 ArrayList 相关的高频面试题怎么答

面试官如果问你“ArrayList 怎么判断 contains 一个元素”,你应该答出这三层:

  1. 结论 :底层是通过 indexOf 遍历数组,用传入元素的 equals 方法跟每个元素比较。
  2. 前提 :所以要用 contains 查业务对象,必须先重写目标类的 equals ,同时配套重写 hashCode 。
  3. 应用 :如果是按某个属性查,更推荐的写法是用 Stream 的 filter 或构建 HashMap 索引,因为按属性查找本来就不是 contains 的设计目标,它查的是“整个对象相等”。

如果面试官再往下问“ArrayList 和 LinkedList 的 contains 谁快”,你可以说:两者都是 O(n),但 ArrayList 是连续数组遍历,CPU 缓存的局部性好很多,实际往往比 LinkedList 快;LinkedList 每次要跳过一个 node 引用,缓存不友好,还更费内存。这也是为什么我开头提到, ArrayList 的“随机访问快”优势主要体现在按索引取元素上,而不是按内容查找上 。

高频考题还包括:

6.2 按属性去重、分组、统计是一族近亲问题

按属性查找的思路延伸到去重、分组,代码模式非常相似。比如有一个列表,想按 userId 去重:

List<User> distinctUsers = userList.stream()
        .collect(Collectors.collectingAndThen(
                Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(User::getId))),
                ArrayList::new
        ));

这个写法的原理是先把元素都放进一个 TreeSet ,比较器指定为按 id 比较,第二次遇到相同 id 的元素就会被 TreeSet 拒绝,最后再转成 ArrayList 。一次性做完,效率不错。

如果想做“按 id 分组,得到一个 id 对应多个对象的 Map”,就是前面讲的 groupingBy :

Map<String, List<User>> map = userList.stream()
        .collect(Collectors.groupingBy(User::getId));

团队协作时你会发现,查单个和查一批的代码模式其实是同源的: 都是先定义匹配条件,再决定取几个 。匹配条件用 equals ,取一个用 findFirst/findAny ,取多个用 collect ,不去重用 filter ,去重用 TreeSet 或 toMap 合并,分组用 groupingBy 。把这些组合想清楚,集合这一块的大多数场景都能处理得八九不离十。

6.3 工程化自查清单

我在实际项目中踩过很多坑之后,给自己定了一个“按属性查找”的自查清单,每次写类似逻辑都会过一遍:

检查项说明
equals/hashCode 是否配套涉及 HashSet、HashMap 时必查
比较字段是否选对了实体类优先比较业务主键,别全字段一刀切
null 是否安全属性可能为 null 时用 Objects.equals,或常量在前
数据量大不大大到反复全表扫描时,建 HashMap 索引
toMap 是否处理了重复 key不传 mergeFunction 时重复 key 直接抛异常
删除时是否用了 removeIf/Iteratorforeach 里直接 remove 会抛 ConcurrentModificationException
工具方法是否通用同一份代码在三个 Service 里重复出现时,抽成泛型工具

最后再分享一个我实际开发中的习惯。我在重写一个实体类的 equals 之前,一定会先问自己三个问题:这个类会被放进 HashSet 吗?会被当作 Map 的 key 吗?业务上“相等”的定义到底是什么?三个问题里有一个回答不确定,就先把 equals 和 hashCode 一起写好,别等到排查空指针、重复数据、查询不到数据的时候才追悔莫及。按对象属性查找这件事,表面看是 API 和语法问题,往深了看,其实是你在定义这个对象在 Java 世界里“到底是谁”——把这个想清楚,ArrayList 里就没什么查不到的。

以上就是Java ArrayList如何实现按对象属性查找的详细内容,更多关于Java ArrayList按对象属性查找的资料请关注脚本之家其它相关文章!

您可能感兴趣的文章:
阅读全文