工具类

src/main/java/com/diagbot/util/ExtUtil.java

@@ -0,0 +1,221 @@
+package com.diagbot.util;
+
+import com.google.common.collect.Lists;
+import org.apache.commons.lang3.StringUtils;
+
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+/**
+ * @description: 扩展工具类
+ * @author: zhoutg
+ * @date: 2021/4/27 13:10
+ */
+public class ExtUtil {
+
+    /**
+     * 以Map<key, List<V> 形式返回
+     *
+     * @param list
+     * @param property
+     * @param <V>
+     * @return
+     */
+    public static <V> Map<String, List<V>> getKeyList(List<V> list, String property) {
+        if (ListUtil.isEmpty(list)) {
+            return new LinkedHashMap<>();
+        }
+        return list.stream().collect(
+                Collectors.groupingBy(k -> ReflectUtil.getProperty(k, property)));
+    }
+
+    /**
+     * 以Map<key, V> 形式返回，如果key相同，会覆盖前面的内容
+     *
+     * @param list
+     * @param property
+     * @param <V>
+     * @return
+     */
+    public static <V> Map<String, V> getKeyObject(List<V> list, String property) {
+        if (ListUtil.isEmpty(list)) {
+            return new LinkedHashMap<>();
+        }
+        return list.stream().collect(
+                Collectors.toMap(k -> ReflectUtil.getProperty(k, property), v -> v, (v1, v2) -> (v2)));
+    }
+
+    /**
+     * 以Map<key, V> 形式返回，如果key相同，会覆盖前面的内容
+     *
+     * @param list 列表
+     * @param splitSmybool key分隔符
+     * @param multiProperty 多个属性
+     * @param <V>
+     * @return
+     */
+    public static <V> Map<String, V> getMultiKeyObject(List<V> list, String splitSmybool, String... multiProperty) {
+        if (ListUtil.isEmpty(list)) {
+            return new LinkedHashMap<>();
+        }
+        return list.stream().collect(Collectors.toMap(k -> {
+            List<String> key = Lists.newArrayList();
+            for (String property : multiProperty) {
+                key.add(ReflectUtil.getProperty(k, property));
+            }
+            return StringUtils.join(key, splitSmybool);
+        }, v -> v, (v1, v2) -> (v2)));
+    }
+
+    /**
+     * 以Map<key, List<V>> 形式返回
+     *
+     * @param list 列表
+     * @param splitSmybool key分隔符
+     * @param multiProperty 多个属性
+     * @param <V>
+     * @return
+     */
+    public static <V> Map<String, List<V>> getMultiKeyList(List<V> list, String splitSmybool, String... multiProperty) {
+        if (ListUtil.isEmpty(list)) {
+            return new LinkedHashMap<>();
+        }
+        return list.stream().collect(Collectors.groupingBy(k -> {
+            List<String> key = Lists.newArrayList();
+            for (String property : multiProperty) {
+                key.add(ReflectUtil.getProperty(k, property));
+            }
+            return StringUtils.join(key, splitSmybool);
+        }));
+    }
+
+    /**
+     * 以Map<K, V> 形式返回
+     *
+     * @param list
+     * @param keyProperty
+     * @param valueProperty
+     * @param <K>
+     * @param <V>
+     * @return
+     */
+    public static <K, V> Map<K, V> getKeyValue(List<V> list, String keyProperty, String valueProperty) {
+        if (ListUtil.isEmpty(list)) {
+            return new LinkedHashMap<>();
+        }
+        return list.stream().collect(Collectors.toMap(k -> ReflectUtil.getProperty(k, keyProperty),
+                v -> ReflectUtil.getProperty(v, valueProperty), (v1, v2) -> (v2)));
+    }
+
+    /**
+     * 去除重复元素——主要用于字符串
+     *
+     * @param list
+     */
+    public static <T> List<T> removeRepeat(List<T> list) {
+        if (ListUtil.isNotEmpty(list) && list.size() > 1) {
+            list = list.stream().distinct().collect(Collectors.toList());
+        }
+        return list;
+    }
+
+    /**
+     * 根据属性去除重复元素——主要用于对象
+     *
+     * @param list
+     */
+    public static <T> void removeRepeat(List<T> list, String field) {
+        if (ListUtil.isEmpty(list) || list.size() < 2) {
+            return;
+        }
+        // value可以用来过滤字符串列表
+        if (StringUtil.isBlank(field)) {
+            field = "value";
+        }
+        List<Object> filterObj = Lists.newArrayList();// 过滤集
+        Iterator<T> iterator = list.iterator();
+        T t = null;
+        Object obj = null;
+        while (iterator.hasNext()) {
+            t = iterator.next();
+            obj = ReflectUtil.getProperty(t, field);
+            if (obj != null) {
+                if (filterObj.contains(obj)) {
+                    iterator.remove();
+                } else {
+                    filterObj.add(obj);
+                }
+            }
+        }
+    }
+
+    /**
+     * 在源列表中移除过滤的内容
+     *
+     * @param orginList
+     * @param filterList
+     * @param field
+     * @param <T>
+     * @param <V>
+     */
+    public static <T, V> void removeFilter(List<T> orginList, List<V> filterList, String field) {
+        if (ListUtil.isEmpty(orginList) || ListUtil.isEmpty(filterList)) {
+            return;
+        }
+        if (StringUtil.isBlank(field)) {
+            field = "value";
+        }
+        Object obj = null;
+        Iterator<T> itOrgin = orginList.iterator();
+        final String finalField = field; // field 可能会重新赋值为value，需要使用final修饰
+        List<Object> filterObj = filterList.stream().map(r -> ReflectUtil.getProperty(r, finalField))
+                .filter(Objects::nonNull).collect(Collectors.toList());
+        while (itOrgin.hasNext()) {
+            obj = ReflectUtil.getProperty(itOrgin.next(), finalField);
+            if (obj != null) {
+                if (filterObj.contains(obj)) {
+                    itOrgin.remove();
+                } else {
+                    filterObj.add(obj);
+                }
+            }
+        }
+    }
+
+    /**
+     * 将字符串转成List<Long>
+     *
+     * @param s
+     * @param split 分隔符，例如：“，”
+     * @return
+     */
+    public static List<Long> convLongList(String s, String split) {
+        if (StringUtil.isBlank(s)) {
+            return Lists.newArrayList();
+        }
+        return Arrays.stream(s.split(split)).map(r -> Long.valueOf(r)).collect(Collectors.toList());
+    }
+
+    /**
+     * 将字符串转成List<Integer>
+     *
+     * @param s
+     * @param splitSymbol 分隔符
+     * @return
+     */
+    public static List<Integer> convIntegerList(String s, String splitSymbol) {
+        if (StringUtil.isBlank(s)) {
+            return Lists.newArrayList();
+        }
+        return Arrays.stream(s.split(splitSymbol)).map(r -> Integer.valueOf(r)).collect(Collectors.toList());
+    }
+
+    public static void main(String[] args) {
+
+    }
+}

src/main/java/com/diagbot/util/ReflectUtil.java

@@ -0,0 +1,106 @@
+package com.diagbot.util;
+
+import com.google.common.collect.Lists;
+
+import java.lang.reflect.Field;
+import java.util.List;
+
+/**
+ * @description: 反射工具类
+ * @author: zhoutg
+ * @date: 2021/4/27 13:29
+ */
+public class ReflectUtil {
+
+    /**
+     * 获取属性对应的值，以list形式返回
+     *
+     * @param list
+     * @param propertyName
+     * @param <T>
+     * @param <V>
+     * @return
+     */
+    public static <T, V> List<V> getPropertyList(List<T> list, String propertyName) {
+        List<V> res = Lists.newArrayList();
+        if (ListUtil.isEmpty(list)) {
+            return res;
+        }
+        for (T t : list) {
+            try {
+                V val = getProperty(t, propertyName);
+                if (val != null) {
+                    // 字符串类型不为空判断
+                    if (StringUtil.isNotBlank(String.valueOf(val))) {
+                        res.add(val);
+                    }
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+        return res;
+    }
+
+    /**
+     * 获取属性对应的值，以list形式返回——重载
+     *
+     * @param list
+     * @param <T>
+     * @return
+     */
+    public static <T> List<String> getPropertyList(List<T> list) {
+        return getPropertyList(list, "name");
+    }
+
+    /**
+     * 循环向上转型, 获取对象的 DeclaredField
+     *
+     * @param object    : 子类对象
+     * @param fieldName : 父类中的属性名
+     * @return 父类中的属性对象
+     */
+    public static Field getDeclaredField(Object object, String fieldName) {
+        Field field = null;
+        Class<?> clazz = object.getClass();
+        for (; clazz != Object.class; clazz = clazz.getSuperclass()) {
+            try {
+                field = clazz.getDeclaredField(fieldName);
+                return field;
+            } catch (Exception e) {
+                //这里甚么都不要做！并且这里的异常必须这样写，不能抛出去。
+                //如果这里的异常打印或者往外抛，则就不会执行clazz = clazz.getSuperclass(),最后就不会进入到父类中了
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 获取对象的属性值,直接使用getDeclaredFields()方法只能获取当前类声明的字段，需要递归向上获取
+     *
+     * @param object    : 子类对象
+     * @param fieldName : 父类中的属性名
+     * @return : 父类中的属性值
+     */
+    public static <T> T getProperty(Object object, String fieldName) {
+        try {
+            //根据 对象和属性名通过反射获取Field对象
+            Field field = getDeclaredField(object, fieldName);
+            // 容错处理
+            if (field == null) {
+                return null;
+            }
+            //抑制Java对其的检查
+            field.setAccessible(true);
+            //获取 object 中 field 所代表的属性值
+            return (T) field.get(object);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public static void main(String[] args) {
+
+    }
+}