list对象排序及分组

本文详细介绍了Java中如何使用Collections.sort()对自定义类进行排序,包括通过实现Comparable接口和使用Comparator接口。同时,展示了如何利用Java Stream API进行数据分组,包括基于对象属性和基本属性的分组方法。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

一、list对象排序
https://blog.youkuaiyun.com/qq_39366175/article/details/79449178
1.对象:
根据age正序排序实现Comparable 重写compareTo
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Comparable{
private Integer age;

private String name;

private Date createTime;

@Override
public String toString() {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    return "User{" + age + ", " + name  + ", " + sdf.format(createTime) + '}';
}

@Override
public int compareTo(User o) {
    return this.age.compareTo(o.getAge());
}

}
测试:
1.直接测试
@Test
public void sort(){
List list = new ArrayList<>();
Random r = new Random();
for (int i = 0; i < 10 ; i++) {
int x = r.nextInt(11);
User user = new User(10+x, “agc”+i, addDateMinut(new Date(),x));
list.add(user);
}
Collections.sort(list);
for (User user : list) {
System.out.println(user.toString());
}
}
2.重写优先
@Test
public void sort(){
List list = new ArrayList<>();
Random r = new Random();
for (int i = 0; i < 10 ; i++) {
int x = r.nextInt(11);
User user = new User(10+x, “agc”+i, addDateMinut(new Date(),x));
list.add(user);
}
Collections.sort(list, new Comparator() {
@Override
public int compare(User o1, User o2) {
long x = o1.getCreateTime().getTime();
long y = o2.getCreateTime().getTime();
int yy = (x < y) ? -1 : ((x == y) ? 0 : 1);
return yy;
}
});
for (User user : list) {
System.out.println(user.toString());
}
}
二、分组
(1)根据对象分组
1.定义分组对象
@Data
@AllArgsConstructor
@EqualsAndHashCode
public class UserGroup {
private Integer age;

private String name;

}
2.测试
@Test
public void test000(){
List list = new ArrayList<>();
Random r = new Random();
for (int i = 0; i < 10 ; i++) {
int x = r.nextInt(11);
User user = new User(10, “AAA”, addDateMinut(new Date(),x));
list.add(user);
}
for (int i = 0; i < 10 ; i++) {
int x = r.nextInt(11);
User user = new User(11, “BBB”, addDateMinut(new Date(),x));
list.add(user);
}
//分组
Map<UserGroup, List> collect = list.stream().
collect(Collectors.groupingBy(new Function<User, UserGroup>() {
@Override
public UserGroup apply(User user) {
return new UserGroup(user.getAge(),user.getName());
}
}));

    System.out.println(collect);
}

(2)根据基本属性分组
@Test
public void test000(){
List list = new ArrayList<>();
Random r = new Random();
for (int i = 0; i < 10 ; i++) {
int x = r.nextInt(11);
User user = new User(10, “AAA”, addDateMinut(new Date(),x));
list.add(user);
}
for (int i = 0; i < 10 ; i++) {
int x = r.nextInt(11);
User user = new User(11, “BBB”, addDateMinut(new Date(),x));
list.add(user);
}
//分组
Map<Integer, List> collect = list.stream().
collect(Collectors.groupingBy(new Function<User, Integer>() {
@Override
public Integer apply(User user) {
return user.getAge();
}
}));

    System.out.println(collect);
}
### Java List 排序分组示例 为了实现先排序分组的需求,可以利用 `Stream` API 提供的功能来处理集合。下面是一个完整的例子展示如何对列表进行多条件排序以及保持原有顺序的情况下执行分组。 #### 多条件排序 通过链式调用多个比较器来进行复杂排序逻辑: ```java import java.util.*; import java.util.stream.Collectors; class Something { private String parentKey; private int noThings; public Something(String parentKey, int noThings) { this.parentKey = parentKey; this.noThings = noThings; } public String getParentKey() { return parentKey; } public int getNoThings() { return noThings; } @Override public String toString() { return "Something{" + "parentKey='" + parentKey + '\'' + ", noThings=" + noThings + '}'; } } public class Main { static Map<String, Integer> totalNoThings = new HashMap<>(); public static void main(String[] args) { // 初始化测试数据... List<Something> somethings = Arrays.asList( new Something("A", 1), new Something("B", 2), new Something("C", 3), new Something("D", 4) ); // 设置用于比较的外部映射关系 totalNoThings.put("A", 5); totalNoThings.put("B", 6); totalNoThings.put("C", 7); totalNoThings.put("D", 8); // 对somethings对象列表按照两个属性先后排序 List<Something> sorted = somethings.stream() .sorted(Comparator.comparing((Something x) -> totalNoThings.get(x.getParentKey())) .thenComparing(Something::getNoThings)) .collect(Collectors.toList()); System.out.println(sorted); } } ``` 这段代码实现了基于自定义规则的两次排序:首先是依据父键关联的数量降序排列,其次是根据自身的数量升序排列[^1]。 #### 维持原有序列下的分组 当希望在分组时不改变之前设定好的序列时,可以通过设置流的操作模式为稳定(stable),即保证相同元素间的相对位置不变。然而,在标准库中直接指定稳定性并不总是可行,因此通常的做法是在收集阶段保留原始索引信息作为辅助字段参与后续计算或显示。 ```java // 假设已经完成了上述排序过程... Map<String, List<Something>> groupedAndSorted = IntStream.range(0, sorted.size()) .boxed() .collect(Collectors.groupingBy(i -> sorted.get(i).getParentKey(), LinkedHashMap::new, Collectors.mapping(sorted::get, Collectors.toList()))); System.out.println(groupedAndSorted.values()); ``` 这里创建了一个新的哈希映射表存储经过分组后的子集,并且指定了使用 `LinkedHashMap` 来保存插入顺序,从而确保即使进行了分组操作也能够维持原有的条目次序[^2]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值