Biz工具类

向右看齐 2022-06-18 05:09 63阅读 0赞

package com.common.util;
    
    import java.beans.BeanInfo;
    import java.beans.IntrospectionException;
    import java.beans.Introspector;
    import java.beans.PropertyDescriptor;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.List;
    import java.util.Map;
    
    import org.apache.commons.beanutils.BeanComparator;
    import org.apache.commons.beanutils.BeanPropertyValueEqualsPredicate;
    import org.apache.commons.beanutils.BeanToPropertyValueTransformer;
    import org.apache.commons.beanutils.PropertyUtils;
    import org.apache.commons.collections.CollectionUtils;
    import org.apache.commons.collections.ComparatorUtils;
    import org.apache.commons.collections.Predicate;
    import org.apache.commons.collections.PredicateUtils;
    import org.apache.commons.collections.comparators.FixedOrderComparator;
    
    import com.google.common.base.Function;
    import com.google.common.base.Predicates;
    import com.google.common.collect.ArrayListMultimap;
    import com.google.common.collect.ListMultimap;
    import com.google.common.collect.Lists;
    import com.google.common.collect.Maps;
    import com.google.common.collect.Multimaps;
    
    @SuppressWarnings("unchecked")
    public class BizUtil {
    
      public static <K, V> Map<K, V> listToMap(String keyName, List<V> list) {
        Map<K, V> map = Maps.newHashMap();
        if (CollectionUtils.isNotEmpty(list)) {
          for (V val : list) {
            try {
              PropertyDescriptor pd = new PropertyDescriptor(keyName,val.getClass());
              Method getMethod = pd.getReadMethod();// 获得get方法
              Object o = getMethod.invoke(val);// 执行get方法返回一个Object
              if (o != null) {
                map.put((K) o, val);
              }
            } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException | IntrospectionException e) {
              e.printStackTrace();
            }
          }
        }
        return map;
      }
    
      // listToMap，1个key对应的是1个元素
      // listToMapList，1个key对应的是1个list。list中属性id一样的，放到1个小的list中。
      public static <K, V> Map<K, List<V>> listToMapList(String keyName,List<V> list) {
        ListMultimap<K, V> multimap = ArrayListMultimap.create();
        if (CollectionUtils.isNotEmpty(list)) {
          for (V val : list) {
            try {
              PropertyDescriptor pd = new PropertyDescriptor(keyName,val.getClass());
              Method getMethod = pd.getReadMethod();// 获得get方法
              Object o = getMethod.invoke(val);// 执行get方法返回一个Object
              if (o != null) {
                multimap.put((K) o, val);
              }
            } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException | IntrospectionException e) {
              e.printStackTrace();
            }
          }
        }
        return Multimaps.asMap(multimap);
      }
    
      /**
       * 把1个集合，转换成Map。用法示例：Map<String, Dictionary> dictionaryMap =
       * BizUtil.listToMap("BIANMA", dictionarys);
       * 
       * @param keyName 集合元素唯一字段的名称
       * @param list 集合元素
       * @return map
       */
      // list中的key重复会报错,Google工具Map会检查“唯一性”，实际情况中就算重复了，不影响的，直接覆盖就好了嘛
      public static <K, V> Map<K, V> listToMapMustUnique(final String keyName,List<V> list) {
        if (CollectionUtils.isEmpty(list)) {
          return null;
        }
        Map<K, V> map = Maps.uniqueIndex(list, new Function<V, K>() {
          @Override
          public K apply(V v) {
            try {
              return (K) PropertyUtils.getSimpleProperty(v, keyName);
            } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
              e.printStackTrace();
              return null;
            }
          }
        });
        return map;
      }
    
      /**
       * 
       * @Title: BeanToMap
       * @Description: bean转换成map
       * @param obj
       * @return map
       *
       */
      public static Map<String, Object> bean2Map(Object obj) {
        if (obj == null) {
          return null;
        }
        Map<String, Object> map = Maps.newHashMap();
        try {
          BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
          PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
          for (PropertyDescriptor property : propertyDescriptors) {
            String key = property.getName();
            // 过滤class属性
            if (!key.equalsIgnoreCase("class")) {
              // 得到property对应的getter方法
              Method getter = property.getReadMethod();
              Object value = getter.invoke(obj);
              map.put(key, value);
            }
          }
        } catch (Exception e) {
          e.printStackTrace();
        }
        return map;
      }
      /**
       * 
       * @Title: MapFilter
       * @Description: map批量过滤key的值
       * @param map
       * @param keys
       * @return map
       *
       */
      public static Map<String, Object> MapFilter(Map<String, Object> map,List<String> keys) {
        return Maps.filterKeys(map, Predicates.not(Predicates.in(keys)));
      }
    
      /**
       * 提取集合中的对象的一个属性, 组合成List.
       * 
       * @param collection 来源集合.
       * @param propertyName 要提取的属性名.
       */
      public static <T,F> List<T> extractToList(final Collection<F> collection,final String propertyName) {
        if (CollectionUtils.isEmpty(collection)) {
          return null;
        }
        List<T> list = new ArrayList<T>(collection.size());
        CollectionUtils.collect(collection, new BeanToPropertyValueTransformer(propertyName), list);
        return list;
      }
    
      /**
       * 提取集合中的对象的一个属性和属性值提取新的List
       * 
       * @param collection 来源集合
       * @param propertyName 要提取的属性名
       * @param propertyValue 要提取的属性名的值
       */
      public static <T,V> List<T> extractToList(final Collection<T> collection,final String propertyName,V propertyValue) {
        if (CollectionUtils.isEmpty(collection)) {
          return null;
        }
        List<T> list = new ArrayList<T>();
        CollectionUtils.select(collection, new BeanPropertyValueEqualsPredicate(propertyName,propertyValue), list);
        return list;
      }
      
      /**
       * 提取集合中的对象的一个属性的属性值在当前值集合中的对象列表
       * 
       * @param collection 来源集合
       * @param propertyName 要提取的属性名
       * @param propertyValues 要提取的属性名的值
       */
      public static <T,V> List<T> extractToList(final Collection<T> collection,final String propertyName,List<V> propertyValues) {
        if (CollectionUtils.isEmpty(collection)) {
          return null;
        }
        List<T> list = new ArrayList<T>();
        List<Predicate> predicates = Lists.transform(propertyValues, new Function<V, Predicate>(){
          @Override
          public Predicate apply(V v) {
            return new BeanPropertyValueEqualsPredicate(propertyName,v);
          }
        });
        CollectionUtils.select(collection, PredicateUtils.anyPredicate(predicates), list);
        return list;
      }
      
      /**
       * 提取集合中的对象的一个属性的属性值不在当前值集合中的对象列表
       * 
       * @param collection 来源集合
       * @param propertyName 要提取的属性名
       * @param propertyValues 要提取的属性名的值
       */
      public static <T,V> List<T> extractToReverseList(final Collection<T> collection,final String propertyName,List<V> propertyValues) {
        if (CollectionUtils.isEmpty(collection)) {
          return null;
        }
        List<T> list = new ArrayList<T>();
        List<Predicate> predicates = Lists.transform(propertyValues, new Function<V, Predicate>(){
          @Override
          public Predicate apply(V v) {
            return new BeanPropertyValueEqualsPredicate(propertyName,v);
          }
        });
        CollectionUtils.selectRejected(collection, PredicateUtils.anyPredicate(predicates), list);
        return list;
      }
      
      /**
       * id字符串转换为list
      * 
      * @param idStr id字符串
      * @param separator 切分符 {@linkplain com.buoumall.commonService.consts.Consts}
      * @return list
      *
       */
      public static List<Long> stringToLongList(String idStr, String separator) {
        List<Long> idList = Lists.newArrayList();
        String[] idArray = idStr.split(separator);
        if (idArray != null) {
          for (String id : idArray) {
            idList.add(Long.valueOf(id));
          }
        }
        return idList;
      }
      
      /**
       * id字符串转换为list并升序排列
      * 
      * @param idStr id字符串
      * @param separator 切分符 {@linkplain com.buoumall.commonService.consts.Consts}
      * @return list
      *
       */
      public static List<Long> stringToAscLongList(String str, String separator) {
        List<Long> idList = Lists.newArrayList();
        String[] idArray = str.split(separator);
        if (idArray != null) {
          for (String id : idArray) {
            idList.add(Long.valueOf(id));
          }
        }
        Collections.sort(idList);
        return idList;
      }
      
      /**
       * list根据某个属性排序
       * 
       * @param propertyName 属性名
       * @param list 需要排序的list
       * @param isAsc 是否升序（自然序）
       * @return list 排序后的list
       *
       */
      public static <T> List<T> sortList(String propertyName, List<T> list,boolean isAsc) {
        Comparator<T> comparator = ComparatorUtils.naturalComparator();
        comparator = new BeanComparator<T>(propertyName, comparator);
        if(!isAsc){
          comparator = ComparatorUtils.reversedComparator(comparator);
        }
        Collections.sort(list,comparator);
        return list;
      }
      
      /**
       * list根据某个属性给定的集合排序
       * 
       * @param propertyName 属性名
       * @param list 需要排序的list
       * @param from 属性对应的集合值
       * @return list 排序后的list
       *
       */
      public static <T,F> List<T> sortList(String propertyName, List<T> list,List<F> from) {
        FixedOrderComparator fixedOrderComparator = new FixedOrderComparator(from);
        Comparator<T> comparator = new BeanComparator<T>(propertyName,fixedOrderComparator);
        Collections.sort(list,comparator);
        return list;
      }
    }