ListUtils 对 list数据 分组 ，统计，求和 。。。

listUtils:

package com.icil.report.utils;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.stream.Collectors;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
/**
 * *************************************************************************
 * <PRE>
 *  @ClassName:    : ListUtil 
 *
 *  @Description:    : 
 *
 *  @Creation Date   : 13 May 2019 2:48:52 PM
 *
 *  @Author          :  Sea
 *  
 *
 * </PRE>
 **************************************************************************
 */
public class ListUtil{
    
    private static Logger  LOGGER=LoggerFactory.getLogger(ListUtil.class);
/**
     * 分组依据接口，用于集合分组时，获取分组
     * T为要groupBy属性是类型，这个返回值为要groupBy的属性值
     */
    public interface GroupBy<T> {
        T groupBy(Object obj) ;
    }
    
    
    
/**
     * 通过属性对集合分组
     * @param colls
     * @param gb
     * @return
     * extends Comparable<T> 
     */
public static final <T,D> Map<T ,List<D>> groupBy(Collection<D> colls ,GroupBy<T> gb){
        Map<T ,List<D>> map = new HashMap<T, List<D>>();
        
        Iterator<D> iter = colls.iterator() ;
        
        while(iter.hasNext()) {
            D d = iter.next() ;
            T t = gb.groupBy(d) ;
            if(map.containsKey(t)) {
                map.get(t).add(d) ;
            } else {
                List<D> list = new ArrayList<D>() ;
                list.add(d) ;
                map.put(t, list) ;
            }
        }
        return map ;
    }



    /**
     * 通过属性名称对集合分组    
     * @param colls
     * @param fieldName为集合中对象的属性名称
     * @return
     * extends Comparable<T> 
     */
    @SuppressWarnings("unchecked")
    public static final <T,D> Map<T ,Long> groupByAndCounts(Collection<D> colls ,String fieldName){
        Map<Object, List<D>> groupBy = groupBy(colls,fieldName);
        HashMap<T,Long> hashMap = new HashMap<>();
        
        for (Entry<Object, List<D>> entry : groupBy.entrySet()) {
            hashMap.put((T) entry.getKey(), (long) entry.getValue().size());
        }
        return hashMap;
    }  
    
    
    
     /**
     * 通过属性名称对集合分组  添加合并 blank  
     * @param colls
     * @param fieldName为集合中对象的属性名称
     * @return
     * extends Comparable<T> 
     */
    @SuppressWarnings("unchecked")
    public static final <T,D> Map<T ,Long> groupByAndCounting(Collection<D> colls ,String fieldName){
        Map<Object, List<D>> groupBy = groupBy(colls,fieldName);
        HashMap<T,Long> hashMap = new HashMap<>();
        
        for (Entry<Object, List<D>> entry : groupBy.entrySet()) {
            hashMap.put((T) entry.getKey(), (long) entry.getValue().size());
        }
        
        //合并对个空key  '' ; '  ' ; null
        /**
         * find all null key and  sum those value
         */
        Long totalNullSize=0l;
        List<T> nullkeyList=new ArrayList<>();
        
         for (Entry<T, Long> entry : hashMap.entrySet()) 
        {
                T key = entry.getKey();
                if(key==null){
                    totalNullSize=entry.getValue()+totalNullSize;
                    nullkeyList.add(key);
                }else {
                    if(StringUtils.isBlank(key.toString())){
                        totalNullSize=entry.getValue()+totalNullSize;
                        nullkeyList.add(key);
                    }
                }
        }
        /**
         * remove all null
         */
         for (T key : nullkeyList) {
            hashMap.remove(key);
        }
         
        if(totalNullSize!=0){
            hashMap.put((T)(" "), totalNullSize);
        }
        
        return hashMap;
    }
    
   
    
     /**
     * 通过属性名称对集合分组
     * @param colls
     * @param fieldName为集合中对象的属性名称
     * @return
     * extends Comparable<T> 
     */
    public static final <T,D> Map<T ,List<D>> groupBy(Collection<D> colls ,String fieldName){
        return groupBy(colls,new GroupBy<T>(){
            @Override
            public T groupBy(Object obj){
                Object v=getFieldValueByName(obj,fieldName);
                return (T)v;
            }
        });
    }
    

    
    
    
    
    
    /** 
     * 根据属性名称获取属性值 
     * */  
   public static Object getFieldValueByName(Object o,String fieldName) {  
       try {    
           String firstLetter = fieldName.substring(0, 1).toUpperCase();    
           String getter = "get" + firstLetter + fieldName.substring(1);    
           Method method = o.getClass().getMethod(getter, new Class[] {});    
           Object value = method.invoke(o, new Object[] {});    
           return value;    
       } catch (Exception e) {    
           LOGGER.error(e.getMessage(),e);    
           return null;    
       }    
   }
   
   
   
   /** 
    * 根据属性名称获取属性值 (获取long型)
    * */  
  public static Long getFieldLongValueByName(Object o,String fieldName) {  
      try {    
          String firstLetter = fieldName.substring(0, 1).toUpperCase();    
          String getter = "get" + firstLetter + fieldName.substring(1);    
          Method method = o.getClass().getMethod(getter, new Class[] {});    
          Long value = (Long) method.invoke(o, new Object[] {});    
          return value;    
      } catch (Exception e) {    
          LOGGER.error(e.getMessage(),e);    
          return null;    
      }    
  }
   
   
   
   
   
   
   /**
    * 通过属性名称对集合分组
    * @Desc:java 8 stream api, list 会过滤掉group by filed 的非空字段
    * @param colls   集合必须为对象 eg: List<Employee>
    * @param fieldName为集合中对象的属性名称  eg: Employee-->name
    * @return
    * extends Comparable<T> 
    */
   public static final <D> Map<Object ,List<D>> groupByPro(Collection<D> colls ,String fieldName){
       
           //filter
        List<D> filterlist = colls.parallelStream().filter(r->getFieldValueByName(r,fieldName)!=null).collect(Collectors.toList());
        //group by 
        Map<Object, List<D>> collect = filterlist.stream().collect(Collectors.groupingBy(r->getFieldValueByName(r,fieldName)));
        return collect;
   }
   
   
   /**
    * 通过属性名称对集合分组统计
    * @Desc:java 8 stream api, list 会过滤掉group by filed 的非空字段
    * @param colls   集合必须为对象 eg: List<Employee>
    * @param fieldName为集合中对象的属性名称  eg: Employee-->name
    * @return
    * extends Comparable<T> 
    */
   public static final <D> Map<Object, Long>  groupByAndCount(Collection<D> colls ,String fieldName){
       
        //filter
         List<D> filterlist = colls.parallelStream().filter(r->getFieldValueByName(r,fieldName)!=null).collect(Collectors.toList());
         //group by 
         Map<Object, Long> collect = filterlist.parallelStream().collect(Collectors.groupingBy(r->getFieldValueByName(r,fieldName),Collectors.counting()));
        
        return collect;
   }
   
   

   /**
    * 通过属性名称对集合分组统计求和
    * @Desc:java 8 stream api, list 会过滤掉group by filed 的非空字段
    * @param colls   eg: List<Employee>
    * @param groupByFieldName  根据那个字段分组
    * @param sumFieldName      对那个字段进行求和
    * @return
    *  extends Comparable<T> 
    */
   public static final <D>  Map<Object, Long>  groupByAndSum(Collection<D> colls ,String groupByFieldName,String sumFieldName){
       
        //filter
         List<D> filterlist = colls.parallelStream().filter(r->getFieldValueByName(r,groupByFieldName)!=null).collect(Collectors.toList());
         //group by  and sum
         
         Map<Object, Long> collect = filterlist.stream().collect(
                 Collectors.groupingBy(r->getFieldValueByName(r,groupByFieldName), Collectors.summingLong(r->getFieldLongValueByName(r,sumFieldName))));
        return collect;
   }
   
   
   
   
}

ListUtils: pro

package com.icil.elsardcservice.untils;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.Set;
import java.util.TreeSet;
import java.util.stream.Collectors;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
 * *************************************************************************
 * <PRE>
 *  @ClassName:    : ListUtil 
 *
 *  @Description:    : 
 *
 *  @Creation Date   : 13 May 2019 2:48:52 PM
 *
 *  @Author          :  Sea
 *  
 *
 * </PRE>
 **************************************************************************
 */
@SuppressWarnings("all")
public class ListUtil{
    
    private static Logger  LOGGER=LoggerFactory.getLogger(ListUtil.class);
/**
     * 分组依据接口，用于集合分组时，获取分组
     * T为要groupBy属性是类型，这个返回值为要groupBy的属性值
     */
    public interface GroupBy<T> {
        T groupBy(Object obj) ;
    }
    
    
    
/**
     * 通过属性对集合分组
     * @param colls
     * @param gb
     * @return
     * extends Comparable<T> 
     */
public static final <T,D> Map<T ,List<D>> groupBy(Collection<D> colls ,GroupBy<T> gb){
        Map<T ,List<D>> map = new HashMap<T, List<D>>();
        
        Iterator<D> iter = colls.iterator() ;
        
        while(iter.hasNext()) {
            D d = iter.next() ;
            T t = gb.groupBy(d) ;
            if(map.containsKey(t)) {
                map.get(t).add(d) ;
            } else {
                List<D> list = new ArrayList<D>() ;
                list.add(d) ;
                map.put(t, list) ;
            }
        }
        return map ;
    }



/**
 * 通过属性名称对集合分组
 * @param colls
 * @param fieldName为集合中对象的属性名称
 * @return
 * extends Comparable<T> 
 */
public static final <T,D> Map<T ,List<D>> groupBy(Collection<D> colls ,String fieldName){
    return groupBy(colls,new GroupBy<T>(){
        @Override
        public T groupBy(Object obj){
            Object v=getFieldValueByName(obj,fieldName);
            return (T)v;
        }
    });
}



/**
 * 通过属性对集合分组，并对blank(null 和“ ” )的数据进行合并
 * @param colls
 * @param gb
 * @return
 * extends Comparable<T> 
 */
public static final <T,D> Map<T ,List<D>> groupByAndMergeBlank(Collection<D> colls ,GroupBy<T> gb){
    Map<T ,List<D>> map = new HashMap<T, List<D>>();
    
    Iterator<D> iter = colls.iterator() ;
    
    while(iter.hasNext()) 
    {
        D d = iter.next() ;
        T t = gb.groupBy(d) ;
        
        
        //merge blank and null
        if(t!=null){
            if("String".equalsIgnoreCase(t.getClass().getSimpleName())){
                
                if(StringUtils.isBlank((CharSequence) t)){
                    t=null;
                }
            }
        }
        
        if(map.containsKey(t)) {
            map.get(t).add(d) ;
        } else {
            List<D> list = new ArrayList<D>() ;
            list.add(d) ;
            map.put(t, list) ;
        }
    }
    return map ;
}


/**
 * 通过属性名称对集合分组
 * @param colls
 * @param fieldName为集合中对象的属性名称
 * @return
 * extends Comparable<T> 
 */
public static final <T,D> Map<T ,List<D>> groupByAndMergeBlank(Collection<D> colls ,String fieldName){
    return groupByAndMergeBlank(colls,new GroupBy<T>(){
        @Override
        public T groupBy(Object obj){
            Object v=getFieldValueByName(obj,fieldName);
            return (T)v;
        }
    });
}






    /**
     * 通过属性名称对集合分组    
     * @param colls
     * @param fieldName为集合中对象的属性名称
     * @return
     * extends Comparable<T> 
     */
    @SuppressWarnings("unchecked")
    public static final <T,D> Map<T ,Long> groupByAndCounts(Collection<D> colls ,String fieldName){
        Map<Object, List<D>> groupBy = groupBy(colls,fieldName);
        HashMap<T,Long> hashMap = new HashMap<>();
        
        for (Entry<Object, List<D>> entry : groupBy.entrySet()) {
            hashMap.put((T) entry.getKey(), (long) entry.getValue().size());
        }
        return hashMap;
    }  
    
    
    /**
     * @Desc : 例如：根据customer 分组，统计每个customer 的个数， 并且统计每个customer分组下的courier的数量(需要去重)
     * @param colls
     * @param firstfieldName
     * @param afterGbFieldName
     * @return
     */
    @SuppressWarnings("unchecked")
    public static final <T,D> Map<T ,String> groupByGroupByAndCounting(Collection<D> colls ,String firstfieldName,String secondGbFieldName){
        HashMap<T,String> hashMap = new HashMap<>();
        Map<Object, List<D>> firstGroupBy = groupByAndMergeBlank(colls, firstfieldName);
        
        for (Entry<Object, List<D>> entry : firstGroupBy.entrySet()) {
                TreeSet<Object> secondFieldSet = new  TreeSet<Object>();
                List<D> firstfieldNamelist = entry.getValue();
                for (D d : firstfieldNamelist) {
                     Object value=getFieldValueByName(d,secondGbFieldName);
                    secondFieldSet.add(value);
                } 
                hashMap.put((T) entry.getKey(),  entry.getValue().size()+","+secondFieldSet.size());
        }
        
        return hashMap;
    } 
    
    
    
    /**
     * @Desc:根据一个集合的filed, 去掉重复，并返回去重后改field 的集合 ,比如：List<User>   现在要提取 所有的user.name
     * @param colls
     * @param firstfieldName
     * @param secondGbFieldName
     * @return
     */
    public static final <D> Set<D> DistinctByFiled(Collection<D> colls ,String fieldName){
        TreeSet<D> distinctSet = new  TreeSet<D>();
        for (D d : colls) {
            Object value = getFieldValueByName(d, fieldName);
            distinctSet.add((D) value);
        }
        return distinctSet;
    } 
    
    
    
    
    /**
     * 通过属性名称对集合分组  添加合并 blank  
     * @param colls
     * @param fieldName为集合中对象的属性名称
     * @return
     * extends Comparable<T> 
     */
    public static final <T,D> Map<T ,Long> groupByAndMergeBlankCounting(Collection<D> colls ,String fieldName){
        Map<Object, List<D>> groupBy = groupByAndMergeBlank(colls,fieldName);
        HashMap<T,Long> hashMap = new HashMap<>();
        for (Entry<Object, List<D>> entry : groupBy.entrySet()) {
            hashMap.put((T) entry.getKey(), (long) entry.getValue().size());
        }
        return hashMap;
    }
    
    
     /**
     * 通过属性名称对集合分组  添加合并 blank 然后计数 
     * @param colls
     * @param fieldName为集合中对象的属性名称
     * @return
     * extends Comparable<T> 
     */
    public static final <T,D> Map<T ,Long> groupByAndCounting(Collection<D> colls ,String fieldName){
        Map<Object, List<D>> groupBy = groupBy(colls,fieldName);
        HashMap<T,Long> hashMap = new HashMap<>();
        for (Entry<Object, List<D>> entry : groupBy.entrySet()) {
            hashMap.put((T) entry.getKey(), (long) entry.getValue().size());
        }
        //合并对个空key  '' ; '  ' ; null
        /**
         * find all null key and  sum those value
         */
        Long totalNullSize=0l;
        List<T> nullkeyList=new ArrayList<>();
         for (Entry<T, Long> entry : hashMap.entrySet()) 
        {
                T key = entry.getKey();
                if(key==null){
                    totalNullSize=entry.getValue()+totalNullSize;
                    nullkeyList.add(key);
                }else {
                    if(StringUtils.isBlank(key.toString())){
                        totalNullSize=entry.getValue()+totalNullSize;
                        nullkeyList.add(key);
                    }
                }
        }
        /**
         * remove all null
         */
         for (T key : nullkeyList) {
            hashMap.remove(key);
        }
         
        if(totalNullSize!=0){
            hashMap.put((T)(" "), totalNullSize);
        }
        
        return hashMap;
    }
    
   
    
    
    
    /** 
     * 根据属性名称获取属性值 
     * */  
   public static Object getFieldValueByName(Object o,String fieldName) {  
       try {    
           String firstLetter = fieldName.substring(0, 1).toUpperCase();    
           String getter = "get" + firstLetter + fieldName.substring(1);    
           Method method = o.getClass().getMethod(getter, new Class[] {});    
           Object value = method.invoke(o, new Object[] {});    
           return value;    
       } catch (Exception e) {    
           LOGGER.error(e.getMessage(),e);    
           return null;    
       }    
   }
   
   
   
   /** 
    * 根据属性名称获取属性值 (获取long型)
    * */  
  public static Long getFieldLongValueByName(Object o,String fieldName) {  
      try {    
          String firstLetter = fieldName.substring(0, 1).toUpperCase();    
          String getter = "get" + firstLetter + fieldName.substring(1);    
          Method method = o.getClass().getMethod(getter, new Class[] {});    
          Long value = (Long) method.invoke(o, new Object[] {});    
          return value;    
      } catch (Exception e) {    
          LOGGER.error(e.getMessage(),e);    
          return null;    
      }    
  }
   
  
  /**
   *   
   * @param pojo
   * @param fieldName
   * @param value just can be  Integer(int)   Double(double)    Long(ong)  Date  String
   */
  public static void setFieldValueByName(Object pojo,String fieldName,Object value) {  
      try {    
          String firstLetter = fieldName.substring(0, 1).toUpperCase();    
          String seter = "set" + firstLetter + fieldName.substring(1);    
           value = Optional.ofNullable(value).orElseGet(()-> new String("null"));
          String simpleName = value.getClass().getSimpleName();
         Class  class1; 
        switch (simpleName) {
          case "Integer":
              class1=Integer.class;
            break;
          case "Double":
              class1=Double.class;
              break;
          case "Long":
              class1=Long.class;
              break;
          case "Date":
              class1=Date.class;
              break;
          default:
              class1=String.class;
            break;
        }
          Method setmethod = pojo.getClass().getMethod(seter, class1);  
          setmethod.invoke(pojo,value);    
              
      } catch (Exception e) { 
          LOGGER.error(e.getMessage(),e);  
         }    
  } 
   
   
   
   
   /**
    * 通过属性名称对集合分组
    * @Desc:java 8 stream api, list 会过滤掉group by filed 的非空字段
    * @param colls   集合必须为对象 eg: List<Employee>
    * @param fieldName为集合中对象的属性名称  eg: Employee-->name
    * @return
    * extends Comparable<T> 
    */
   public static final <D> Map<Object ,List<D>> groupByPro(Collection<D> colls ,String fieldName){
       
           //filter
//        List<D> filterlist = colls.parallelStream().filter(r->getFieldValueByName(r,fieldName)!=null).collect(Collectors.toList());
        colls.parallelStream().forEach( d->{
                 if(ListUtil.getFieldValueByName(d, fieldName)==null){
                       ListUtil.setFieldValueByName(d, fieldName, "null");
                   }
                });
        //group by 
        Map<Object, List<D>> collect = colls.stream().collect(Collectors.groupingBy(r->getFieldValueByName(r,fieldName)));
        return collect;
   }
   
   
   /**
    * 通过属性名称对集合分组统计
    * @Desc:java 8 stream api, list 会过滤掉group by filed 的非空字段
    * @param colls   集合必须为对象 eg: List<Employee>
    * @param fieldName为集合中对象的属性名称  eg: Employee-->name
    * @return
    * extends Comparable<T> 
    */
   public static final <D> Map<Object, Long>  groupByAndCount(Collection<D> colls ,String fieldName){
       
        //filter
         List<D> filterlist = colls.parallelStream().filter(r->getFieldValueByName(r,fieldName)!=null).collect(Collectors.toList());
         //group by 
         Map<Object, Long> collect = filterlist.parallelStream().collect(Collectors.groupingBy(r->getFieldValueByName(r,fieldName),Collectors.counting()));
        
        return collect;
   }
   
   

   /**
    * 通过属性名称对集合分组统计求和
    * @Desc:java 8 stream api, list 会过滤掉group by filed 的非空字段
    * @param colls   eg: List<Employee>
    * @param groupByFieldName  根据那个字段分组
    * @param sumFieldName      对那个字段进行求和
    * @return
    *  extends Comparable<T> 
    */
   public static final <D>  Map<Object, Long>  groupByAndSum(Collection<D> colls ,String groupByFieldName,String sumFieldName){
       
        //filter
         List<D> filterlist = colls.parallelStream().filter(r->getFieldValueByName(r,groupByFieldName)!=null).collect(Collectors.toList());
         //group by  and sum
         
         Map<Object, Long> collect = filterlist.stream().collect(
                 Collectors.groupingBy(r->getFieldValueByName(r,groupByFieldName), Collectors.summingLong(r->getFieldLongValueByName(r,sumFieldName))));
        return collect;
   }
   
   
   
   
   

   
   
   
}