java中实现对集合分组后重新排序

public class PersonInfo
{
	private Long personId;
	private String personName;
	private Integer age;
	private Integer seq;
	public Long getPersonId() {
		return personId;
	}
	public void setPersonId(Long personId) {
		this.personId = personId;
	}
	public String getPersonName() {
		return personName;
	}
	public void setPersonName(String personName) {
		this.personName = personName;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public Integer getSeq() {
		return seq;
	}
	public void setSeq(Integer seq) {
		this.seq = seq;
	}
	
public class Test {

	public static void main(String[] args) 
	{
		List<PersonInfo> buildPersonInfoList = new ArrayList<>();
		List<PersonInfo> personInfoList = getPersonInfo();
		System.out.println("排序前="+personInfoList.toString());
		Map<Integer, List<PersonInfo>> matchsListMap = personInfoList.stream()
				.collect(Collectors.groupingBy(PersonInfo::getAge));
		
		Integer i = 1;
		Integer j = 1;
		for(Map.Entry<Integer, List<PersonInfo>> entry : matchsListMap.entrySet())
		{
		    Integer mapKey = entry.getKey();
		    List<PersonInfo> ls = entry.getValue();
		    System.out.println(mapKey+":"+ls);
		    for (PersonInfo personInfo : ls)
		    {
		    	PersonInfo p = new PersonInfo();
		    	BeanUtils.copyProperties(personInfo, p);
		    	p.setSeq(j++);
		    	buildPersonInfoList.add(p);
			}
		    PersonInfo p = new PersonInfo();
		    p.setPersonName("我是分组"+i++);
		    buildPersonInfoList.add(p);
		}
		System.out.println("分组后="+buildPersonInfoList.toString());
		
		
		Collections.sort(personInfoList,new Comparator<PersonInfo>(){//此处创建了一个匿名内部类
			// 这里比较age,降序就O2-O1,升序就O1-O2
			@Override
			public int compare(PersonInfo o1,PersonInfo o2){
				return o1.getAge() - o2.getAge();
			}});
		System.out.println("排序后="+personInfoList.toString());
	}
	
	private static List<PersonInfo> getPersonInfo()
	{
		List<PersonInfo> personInfoList = new ArrayList<>();
		PersonInfo pi1 = new PersonInfo();
		pi1.setPersonId(1L);
		pi1.setAge(18);
		pi1.setPersonName("小明1");
		pi1.setSeq(1);
		personInfoList.add(pi1);
		
		PersonInfo pi2 = new PersonInfo();
		pi2.setPersonId(2L);
		pi2.setAge(18);
		pi2.setPersonName("小明2");
		pi2.setSeq(2);
		personInfoList.add(pi2);
		
		PersonInfo pi3 = new PersonInfo();
		pi3.setPersonId(3L);
		pi3.setAge(17);
		pi3.setPersonName("小明3");
		pi3.setSeq(3);
		personInfoList.add(pi3);
		
		PersonInfo pi4 = new PersonInfo();
		pi4.setPersonId(4L);
		pi4.setAge(19);
		pi4.setPersonName("小明4");
		pi4.setSeq(4);
		personInfoList.add(pi4);
		
		return personInfoList;
	}

 

可以使用Java 8的Stream API和Collectors工具类来实现集合分组并按照数量排序的操作。具体步骤如下: 1. 使用`Collectors.groupingBy`方法对集合进行分组分组的依据可以是元素本身或者根据某个属性进行分组。例如,以下代码将一个字符串集合按照首字母进行分组: ``` Map<Character, List<String>> groupMap = list.stream() .collect(Collectors.groupingBy(s -> s.charAt(0))); ``` 2. 使用`Collectors.counting`方法对分组后的每个组进行计数,得到每个组的元素数量。例如,以下代码将上一步得到的分组Map按照组内元素数量进行计数: ``` Map<Character, Long> countMap = groupMap.entrySet().stream() .collect(Collectors.toMap( Map.Entry::getKey, e -> (long) e.getValue().size() )); ``` 3. 使用Java 8新的`Comparator`接口,定义一个按照Map值的大小进行排序的比较器。例如,以下代码定义一个按照countMap值的大小进行排序的比较器: ``` Comparator<Character> comparator = Comparator.comparing(countMap::get); ``` 4. 使用`Collectors.toMap`方法将排序后的结果转换为一个新的Map。例如,以下代码将countMap按照值的大小进行排序,并将结果保存在一个新的Map: ``` Map<Character, Long> sortedMap = countMap.entrySet().stream() .sorted(Map.Entry.comparingByValue(comparator.reversed())) .collect(Collectors.toMap( Map.Entry::getKey, Map.Entry::getValue, (oldValue, newValue) -> oldValue, LinkedHashMap::new )); ``` 最后,得到的`sortedMap`就是按照分组后每个组的元素数量进行排序的结果。 完整代码示例: ``` List<String> list = Arrays.asList("apple", "banana", "cat", "dog", "elephant", "fig", "goat", "hippo"); Map<Character, List<String>> groupMap = list.stream() .collect(Collectors.groupingBy(s -> s.charAt(0))); Map<Character, Long> countMap = groupMap.entrySet().stream() .collect(Collectors.toMap( Map.Entry::getKey, e -> (long) e.getValue().size() )); Comparator<Character> comparator = Comparator.comparing(countMap::get); Map<Character, Long> sortedMap = countMap.entrySet().stream() .sorted(Map.Entry.comparingByValue(comparator.reversed())) .collect(Collectors.toMap( Map.Entry::getKey, Map.Entry::getValue, (oldValue, newValue) -> oldValue, LinkedHashMap::new )); System.out.println(sortedMap); // 输出: {e=2, a=1, b=1, c=1, d=1, f=1, g=1, h=1} ```
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值