欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

List对象集合按照属性排序、分组,并按照分组后每组的多少进行排序。

程序员文章站 2022-04-15 18:03:49
需求描述:有一个用户list对象集合,想按照名字分类,先按照分类后每组的数量排序,在按照名字排序,最后按照分数进行排序。想要的效果:UserInfo [username=d, fRate=9.9]UserInfo [username=d, fRate=8.5]UserInfo [username=d, fRate=5.5]UserInfo [username=d, fRate=4.5]UserInfo [username=b, fRate=9.5]UserInfo [username=b,...

需求描述:有一个用户list对象集合,想按照名字分类,先按照分类后每组的数量排序,在按照名字排序,最后按照分数进行排序。

想要的效果:

UserInfo [username=d, fRate=9.9]
UserInfo [username=d, fRate=8.5]
UserInfo [username=d, fRate=5.5]
UserInfo [username=d, fRate=4.5]

UserInfo [username=a, fRate=9.5]
UserInfo [username=a, fRate=7.5]
UserInfo [username=a, fRate=5.5]

UserInfo [username=b, fRate=9.5]
UserInfo [username=b, fRate=2.5]
package com.cetcnav.lbs.pis.util;

import java.lang.reflect.Field;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import com.cetcnav.lbs.pis.ws.monitor.model.UlrateMonth;


/**
 * @author wp
 * 在数据库中查出来的列表中,往往需要对不同的字段重新排序。 一般的做法都是使用排序的字段,重新到数据库中查询。
 * 如果不到数据库查询,直接在第一次查出来的list中排序,无疑会提高系统的性能。 下面就写一个通用的方法,对list排序,
 * 
 * 至少需要满足以下5点:
 * 
 * ①.list元素对象类型任意 
 *         ---->使用泛型解决
 * 
 * ②.可以按照list元素对象的任意多个属性进行排序,即可以同时指定多个属性进行排序 
 *         --->使用java的可变参数解决
 * 
 * ③.list元素对象属性的类型可以是数字(byte、short、int、long、float、double等,包括正数、负数、0)、字符串(char、String)、日期(java.util.Date)
 *         --->对于数字:统一转换为固定长度的字符串解决,比如数字3和123,转换为"003"和"123" ;再比如"-15"和"7"转换为"-015"和"007" 
 *         --->对于日期:可以先把日期转化为long类型的数字,数字的解决方法如上
 * 
 * ④.list元素对象的属性可以没有相应的getter和setter方法 
 *         --->可以使用java反射进行获取private和protected修饰的属性值
 * 
 * ⑤.list元素对象的对象的每个属性都可以指定是升序还是降序
 *           -->使用2个重写的方法(一个方法满足所有属性都按照升序(降序),另外一个方法满足每个属性都能指定是升序(降序))
 * 
 *
 */
public class ListUtils {
    /**
     * 对list的元素按照多个属性名称排序,
     * list元素的属性可以是数字(byte、short、int、long、float、double等,支持正数、负数、0)、char、String、java.util.Date
     * 
     * 
     * @param lsit
     * @param sortname
     *            list元素的属性名称
     * @param isAsc
     *            true升序,false降序
     */
    public static <E> void sort(List<E> list, final boolean isAsc, final String... sortnameArr) {
        Collections.sort(list, new Comparator<E>() {

            public int compare(E a, E b) {
                int ret = 0;
                try {
                    for (int i = 0; i < sortnameArr.length; i++) {
                        ret = ListUtils.compareObject(sortnameArr[i], isAsc, a, b);
                        if (0 != ret) {
                            break;
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return ret;
            }
        });
    }
    
    /**
     * 给list的每个属性都指定是升序还是降序
     * 
     * @param list
     * @param sortnameArr  参数数组
     * @param typeArr      每个属性对应的升降序数组, true升序,false降序
     */

    public static <E> void sort(List<E> list, final String[] sortnameArr, final boolean[] typeArr) {
        if (sortnameArr.length != typeArr.length) {
            throw new RuntimeException("属性数组元素个数和升降序数组元素个数不相等");
        }
        Collections.sort(list, new Comparator<E>() {
            public int compare(E a, E b) {
                int ret = 0;
                try {
                    for (int i = 0; i < sortnameArr.length; i++) {
                        ret = ListUtils.compareObject(sortnameArr[i], typeArr[i], a, b);
                        if (0 != ret) {
                            break;
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return ret;
            }
        });
    }

    /**
     * 对2个对象按照指定属性名称进行排序
     * 
     * @param sortname
     *            属性名称
     * @param isAsc
     *            true升序,false降序
     * @param a
     * @param b
     * @return
     * @throws Exception
     */
    private static <E> int compareObject(final String sortname, final boolean isAsc, E a, E b) throws Exception {
        int ret;
        Object value1 = ListUtils.forceGetFieldValue(a, sortname);
        Object value2 = ListUtils.forceGetFieldValue(b, sortname);
        String str1 = value1.toString();
        String str2 = value2.toString();
        if (value1 instanceof Number && value2 instanceof Number) {
            int maxlen = Math.max(str1.length(), str2.length());
            str1 = ListUtils.addZero2Str((Number) value1, maxlen);
            str2 = ListUtils.addZero2Str((Number) value2, maxlen);
        } else if (value1 instanceof Date && value2 instanceof Date) {
            long time1 = ((Date) value1).getTime();
            long time2 = ((Date) value2).getTime();
            int maxlen = Long.toString(Math.max(time1, time2)).length();
            str1 = ListUtils.addZero2Str(time1, maxlen);
            str2 = ListUtils.addZero2Str(time2, maxlen);
        }
        if (isAsc) {
            ret = str1.compareTo(str2);
        } else {
            ret = str2.compareTo(str1);
        }
        return ret;
    }

    /**
     * 给数字对象按照指定长度在左侧补0.
     * 
     * 使用案例: addZero2Str(11,4) 返回 "0011", addZero2Str(-18,6)返回 "-000018"
     * 
     * @param numObj
     *            数字对象
     * @param length
     *            指定的长度
     * @return
     */
    public static String addZero2Str(Number numObj, int length) {
        NumberFormat nf = NumberFormat.getInstance();
        // 设置是否使用分组
        nf.setGroupingUsed(false);
        // 设置最大整数位数
        nf.setMaximumIntegerDigits(length);
        // 设置最小整数位数
        nf.setMinimumIntegerDigits(length);
        return nf.format(numObj);
    }

    /**
     * 获取指定对象的指定属性值(去除private,protected的限制)
     * 
     * @param obj
     *            属性名称所在的对象
     * @param fieldName
     *            属性名称
     * @return
     * @throws Exception
     */
    public static Object forceGetFieldValue(Object obj, String fieldName) throws Exception {
        Field field = obj.getClass().getDeclaredField(fieldName);
        Object object = null;
        boolean accessible = field.isAccessible();
        if (!accessible) {
            // 如果是private,protected修饰的属性,需要修改为可以访问的
            field.setAccessible(true);
            object = field.get(obj);
            // 还原private,protected属性的访问性质
            field.setAccessible(accessible);
            return object;
        }
        object = field.get(obj);
        return object;
    }
    
    /**
     * list分组排序
     * <p>Title: sort</p>
     * <p>Description: </p>
     * @param list
     * @param sortNameArr
     * @param isAscArr
     * @return
     * 创建时间:2020年11月12日 下午3:01:13
     */
    @SuppressWarnings("unused")
	public static List<UlrateMonth> sort(List<UlrateMonth> list,String[] sortNameArr,Boolean[] isAscArr){
    	//排序
    	ListUtils.sort(list,sortNameArr,isAscArr);
    	//排序后打印
//    	printfUserInfoList(list);
    	//按照 ···进行分组
    	Map<String, List<UlrateMonth>> collect = list.stream().collect(Collectors.groupingBy(UlrateMonth::getDevname));
    	
    	//创建list对象数组
    	@SuppressWarnings("unchecked")
    	List<UlrateMonth> arr[] = new ArrayList[collect.size()];
		int num =0;
        for(String key:collect.keySet()){
//			System.out.println(key+":" +collect.get(key).size());
//			System.out.println(collect.get(key));
			arr[num] = (collect.get(key));
			num++;
		}
        
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j].size() < arr[j + 1].size()) {
                	List<UlrateMonth> temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        List<UlrateMonth> newList = new ArrayList<UlrateMonth>();
        for(int b=0;b<arr.length;b++){
        	newList.addAll(arr[b]);
        } 
        return newList;
    }
    
    private static void printfUserInfoList(List<UlrateMonth> list) {
        for (UlrateMonth user : list) {
            System.out.println(user.toString());
        }
    }
    
}

 public static void main(String[] args) throws Exception {

        ListUtilsTest testObj = new ListUtilsTest();

        List<UlrateMonth> list = new ArrayList<UlrateMonth>();
        // public UserInfo(Integer userId, String username, Date birthDate,Integer age, float fRate, char ch)
        SimpleDateFormat formater = new SimpleDateFormat("yyyy-MM-dd");
        UlrateMonth user1 = new UlrateMonth("a",7.5d);
        UlrateMonth user2 = new UlrateMonth("a",5.5d);
        UlrateMonth user3 = new UlrateMonth("a",9.5d);
        UlrateMonth user4 = new UlrateMonth("b",2.5d);
        UlrateMonth user5 = new UlrateMonth("b",9.5d);
        UlrateMonth user6 = new UlrateMonth("d",5.5d);
        UlrateMonth user7 = new UlrateMonth("d",4.5d);
        UlrateMonth user8 = new UlrateMonth("d",9.9d);
        UlrateMonth user9 = new UlrateMonth("d",8.5d);

        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);
        list.add(user5);
        list.add(user6);
        list.add(user7);
        list.add(user8);
        list.add(user9);

        System.out.println("\n-------原来序列-------------------");
        testObj.printfUserInfoList(list);

        // 按userId升序、username降序、birthDate升序排序
        String [] sortNameArr = {"username","fRate"};
        boolean [] isAscArr = {false,false};
        ListUtils.sort(list,sortNameArr,isAscArr);
        System.out.println("\n--------按按userId升序、username降序、birthDate升序排序(如果userId相同,则按照username降序,如果username相同,则按照birthDate升序)------------------");
        testObj.printfUserInfoList(list);
        
        
        Map<String, List<UlrateMonth>> collect = list.stream().collect(Collectors.groupingBy(UlrateMonth::getUsername));
		
		@SuppressWarnings("unchecked")
		List<UlrateMonth> arr[] = new ArrayList[collect.size()];
		int num =0;
        for(String key:collect.keySet()){
			System.out.println(key+":" +collect.get(key).size());
			System.out.println(collect.get(key));
			arr[num] = (collect.get(key));
			num++;
		}
        
        
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j].size() < arr[j + 1].size()) {
                	List<UlrateMonth> temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        List<UlrateMonth> newList = new ArrayList<UlrateMonth>();
        for(int b=0;b<arr.length;b++){
        	newList.addAll(arr[b]);
        } 
        testObj.printfUserInfoList(newList);
		

本文地址:https://blog.csdn.net/qq_33651286/article/details/109643242