请教个 Java list 处理数据的问题？

[godleon]

问题

环境：java ,springboot , jdk8

我现在有个 List<bean> beans ； bean 里有 2 个字段，aTime ，bTime ， 都是 java.utile 包下 Date 类型；

我现在的需求是， 我需要对比两个字段，有一个是最新的就在 list 的最前面;

如：bean1 {aTime：2023-12-18 05:00:00 , bTime: 2023-12-18 10:40:00}

      bean2 {aTime：2023-12-18 04:00:00 , bTime: 2023-12-18 11:40:00}

      bean3 {aTime：2023-12-18 11:00:00 , bTime: 2023-12-18 03:40:00}

那么 list 返回 顺序是 [bean2, bean3, bean1] 这种该怎么判断一下

[liprais]

Comparators
提问之前先搜索

[godleon]

@liprais 这是啥东西

[chendy]

建议去写点 leetcode 入门题，这不就一排序么…

ArrayList<X> xx = new ArrayList<>();
xx.sort(Comparator.comparing(X::getA).thenComparing(X::getB));

[AlvaMu]

实现 Comparator 接口,重写 compare 方法,用参数中的两个对象,先各自取出较大的 Date,然后两个对象之间的 Date 比较

[visper]

直接问 chatgpt：java 中对 list 里面的 bean 按 bean 的 aTime 字段排序

[godleon]

@chendy 你可复现一下 是不对的

[xianyv]

@godleon #2 建议直接百度

[JackCh3ng]

优先队列？

[JackCh3ng]

@JackCh3ng
或者 Bean 实现 Comparator 自己比较也行啊，
或者用 hutool 的 DateUtil 先把 Bean 里的 aTime 和 bTime 比较一下找到最新的，拿这个最新的和其他的 Bean 比较，sort 排序就行。
脑子还是自己多动动比较好。

[chendy]

帮人帮到底了，说实话这帖子放十年前百度 java 吧我都直接删的，真就硬伸手啊
xx.sort(Comparator.comparing(x -> {
if (x.getA().compareTo(x.getB()) > 0) {
return x.getA();
} else {
return x.getB();
}
}));

[XiFanL1]

import java.util.*;
import java.util.stream.Collectors;

public class Bean {
Date aTime;
Date bTime;

// getters and setters

public Date getLatestTime() {
return aTime.after(bTime) ? aTime : bTime;
}
}

public class Main {
public static void main(String[] args) {
List<Bean> beans = new ArrayList<>();

// add beans to the list

List<Bean> sortedBeans = beans.stream()
.sorted(Comparator.comparing(Bean::getLatestTime).reversed())
.collect(Collectors.toList());

// now sortedBeans is sorted by the latest time in each bean
}
}

[eddiechow]

@chendy 你这个是先按 atime 排，再按 btime 排； OP 的需求其实是按 atime 和 btime 两个时间比较的更新（更大）的时间降序排；
不如这样吧，增加 xtime ，先对 list forEach 比较 atime 和 btime ，把更新的时间赋值到 xtime ，然后再对 xtime 降序排序即可，OP 可行？@godleon

[zydxn]

楼上都直接帮你写出来了...

推荐你看本书吧

https://book.douban.com/subject/26346017/

[godleon]

@chendy 大哥 你能回显一下 在回帖吗？

[Kyle18Tang]

@chendy #10 其实看你 3 楼写的思路，就算复现不了，作为一个开发人员也该知道怎么改了，而不是继续抱怨说复现不了。

[yazinnnn0]

list.sortBy {it -> minOf(it.a, it.b) }

[godleon]

@chendy 还是你真的理解不了 问题呢

[eddiechow]

@chendy #10 第二次的实际运行结果还是和需求不一致😂

[Ericcccccccc]

搜 java 自定义结构体排序

[eddiechow]

其实，题目很简单，绝对的绝大多数 v 友都人为很简单，但往往在回答这种简单问题的准确答案时却会放一些简单的错（手滑、笔误、需求理解不清等等😂）；（纯提供思路的除外）

[saveload]

我会三种写法，每月 8K 笑哈哈

[nauhc]

11 楼把正确答案都写出来了

[darkengine]

还是你真的理解不了 问题呢
--------

看到这句真绷不住了 😂

[zmal]

能上 V2EX ，去 gpt 问问也有答案了啊。

[silentsky]

这个问题太简单 跳过

[NickX]

list 的排序，一楼已经说了，Comparators ，你想根据什么规则排都没问题。简单来说就是 a 和 b 时间取最大值再排序嘛。

[forgottencoast]

@eddiechow
真的，说明眼高手低的人很多。

[forgottencoast]

@zydxn
OP 不是看书的问题，OP 是缺乏基本的编程基础知识。
这个就是最简单的按照行内元素的属性来排序，现代编程语言都会支持的排序。

[Alex5467]

@chendy lamada 表达式

[nerkeler]

这也不是眼高手低的问题，这题的实现思路就没什么难度，总而言之 你要先 给每个 bean 排好序取最新的日期，在用每个 bean 里的最新日期排序

[spike0100]

按照 a 和 b 分别排序，然后对比两个集合的第一个对象就完了。

[wxw752]

@eddiechow #20 10 楼无非就是从小到大排了，想从大到小加个 reversed()不就完事了。

[msaionyc]

personList.stream().
sorted((a, b) -> (int) (Math.max(b.getaTime().getTime(), b.getbTime().getTime()) - Math.max(a.getaTime().getTime(), a.getbTime().getTime()))).
collect(Collectors.toList());

直接取 aTime 和 bTime 里的较大值去写 comparator 就可以了，验证过了，排序结果符合你的描述

[vagusss]

有一个是最新的就在 list 的最前面,坦白说我没有看懂这句话,

[vagusss]

@vagusss 有点懂了, 是取两个值中的最大值进行比较排序?

[twofox]

。。。看到这句真绷不住了 😂

没学过 Comparators 吗

[Morii]

取 A 和 B 中最新的时间 X ，再按照 X 排下

[ZZ74]

@twofox
绷不住了，看了 OP 回复 1 楼给的提示才是真的绷不住

[Goooooos]

一看就是期末考试题

[Navee]

有两个方法达到你想要的效果
1. 你的 bean 实现接口：java.util.Comparator
2. 使用 List.sort 方法，传入 Comparator 函数

[cpstar]

恰巧在 compare 上，曾经遇到一个 BUG ，https://page.cpstar.cn/post/chu-li-yi-ge-yi-xiang-bu-dao-de-bug/，自己写 comparator ，要注意三性

[twofox]

@ZZ74 如果是我被一楼回复了，我肯定先滚去搜一下是啥玩意

然后回来谢谢他，而不是这是啥玩意🤣

[c2const]

虽然工作中 Java 接触不多，虽然技术水平和薪资也无关，
---------------
但突然感觉有的人确实不适合编程 :(
或者说只是为了混个工作？ :(

[broken123]

为何会问如此基础的问题？不先了解下排序的本质么

[supertailcat]

这种问题建议直接 LLM 。如果答案不对就说明你的描述能力太差了。而且不得不说，你题面这个描述确实太差了…

[lmq2582609]

List<Bean> beans;
beans.sort(
Comparator.comparingLong((Bean bean) -> {
//取 aTime 时间戳
Date aTime = bean.getATime();
//取 bTime 时间戳
Date bTime = bean.getBTime();
//取 aTime 和 bTime 中最新的时间（时间戳较大的就是最新的时间）
return Math.max(aTime.getTime(), bTime.getTime());
}).reversed() //加 reversed()是排倒序(从大到小)
);
希望可以帮到你！

[orionnnnn]

@lmq2582609 好开！

[yeyang5211]

请教问题的时候记得先把火气憋住,搞到答案了再怼. 轻重缓急晓得伐

[mazhiyuan]

@lmq2582609 学习了，指不定日后会用到，感谢。

[godleon]

@lmq2582609 首先谢谢回复，当 atime 和 btime 都不为 null 的时候 确实可以满足需求，但是我的需求里 现在 atime 和 btime 可能有一个会为 null, 当一个为 null 时，另一个日期继续参与排序，该怎么优化一下~

[lmq2582609]

@godleon
如果有 null 的情况，可以给一个默认值，如-1
List<Bean> beans;
beans.sort(
Comparator.comparingLong((Bean bean) -> {
//取 aTime 时间戳
Date aTime = bean.getATime();
//取 bTime 时间戳
Date bTime = bean.getBTime();
//取 aTime 和 bTime 中最新的时间（时间戳较大的就是最新的时间）
return Math.max(getTime(aTime), getTime(bTime));
}).reversed() //加 reversed()是排倒序(从大到小)
);

private long getTime(Date date) {
return date == null ? -1 : date.getTime();
}