利用反射机制转换成集合

package cn.linksla.common.utils;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.*;

public class BeanTools {

    /**
     * 获取get方法
     *
     * @param name get方法名
     * @param cls
     * @return
     */
    public static Method getGetMethod(String name, Class<?> cls) {
        Method[] methods = cls.getMethods();
        for (Method method : methods) {
            String getMethodName = method.getName();
            if (getMethodName.equalsIgnoreCase("get" + name)) {
                return method;
            }
        }
        return null;
    }

    /**
     * 获取set方法
     *
     * @param name set方法名
     * @param cls
     * @return
     */
    public static Method getSetMethod(String name, Class<?> cls) {
        Method[] methods = cls.getMethods();
        for (Method method : methods) {
            String getMethodName = method.getName();
            if (getMethodName.equalsIgnoreCase("set" + name)) {
                return method;
            }
        }
        return null;
    }

    /**
     * 利用反射实现，list对象根据指定字段组，转出listMap
     *
     * @param object
     * @return
     * @throws Exception
     */
    public static List<Map<String, Object>> mapListtArrToMapArr(List<Map> objectList, String[] strArr) throws Exception {
        List<String> strList = Arrays.asList(strArr);
        if (objectList == null) {
            return null;
        }
        List<Map<String, Object>> list = new ArrayList<>();
        for (Map obj : objectList) {
            Map<String, Object> map = new HashMap<String, Object>();
            List<String> fieldList = new ArrayList<>();
            fieldList.addAll(obj.keySet());
            for (String varName : fieldList) {
                if (strList.contains(varName)) {
                    map.put(varName, obj.get(varName));
                }
            }
            list.add(map);
        }
        return list;
    }

    /**
     * 利用反射实现，list对象根据指定字段组，转出listMap
     *
     * @param object
     * @return
     * @throws Exception
     */
    public static List<Map<String, Object>> objectArrToMapArr(Object object, String[] strArr) throws Exception {
        List<String> strList = Arrays.asList(strArr);
        if (object == null) {
            return null;
        }
        List<Object> objectList = (List<Object>) object;
        List<Map<String, Object>> list = new ArrayList<>();
        for (Object obj : objectList) {
            Map<String, Object> map = new HashMap<String, Object>();
            List<Field> fieldList = new ArrayList<>();
            Class objClass = obj.getClass();
            while (objClass != null) {//当父类为null的时候说明到达了最上层的父类(Object类).
                fieldList.addAll(Arrays.asList(objClass.getDeclaredFields()));
                objClass = objClass.getSuperclass(); //得到父类,然后赋给自己
            }
            for (Field field : fieldList) {
                String varName = field.getName();
                boolean accessFlag = field.isAccessible();
                field.setAccessible(true);// 允许通过反射访问该字段
                Object valueObj = field.get(obj);
                if (strList.contains(varName)) {
                    map.put(varName, valueObj);
                }
                field.setAccessible(accessFlag);
            }
            list.add(map);
        }
        return list;
    }

    /**
     * 利用反射实现，对象根据指定字段组，转出Map
     *
     * @param obj
     * @return
     * @throws Exception
     */
    public static Map<String, Object> objectToMap(Object obj, String[] strArr) throws Exception {
        List<String> strList = Arrays.asList(strArr);
        if (obj == null) {
            return null;
        }
        Map<String, Object> map = new HashMap<String, Object>();
        List<Field> fieldList = new ArrayList<>();
        Class objClass = obj.getClass();
        while (objClass != null) {//当父类为null的时候说明到达了最上层的父类(Object类).
            fieldList.addAll(Arrays.asList(objClass.getDeclaredFields()));
            objClass = objClass.getSuperclass(); //得到父类,然后赋给自己
        }
        for (Field field : fieldList) {
            String varName = field.getName();
            boolean accessFlag = field.isAccessible();
            field.setAccessible(true);// 允许通过反射访问该字段
            Object valueObj = field.get(obj);
            if (strList.contains(varName)) {
                map.put(varName, valueObj);
            }
            field.setAccessible(accessFlag);
        }
        return map;
    }


    /**
     * 利用反射实现，list对象根据指定字段组，转出listMap
     *
     * @return
     * @throws Exception
     */
    public static List<Map<String, Object>> mapArrToMapArr(List<Map> mapList, String[] strArr) throws Exception {
        List<String> strList = Arrays.asList(strArr);
        if (mapList == null) {
            return null;
        }
        List<Map<String, Object>> list = new ArrayList<>();
        for (Map objMap : mapList) {
            Map<String, Object> map = new HashMap<String, Object>();
            List<Field> fieldList = new ArrayList<>();
            for (Object key : objMap.keySet()) {
                if (strList.contains(key.toString())) {
                    map.put(key.toString(), objMap.get(key));
                }
            }
            list.add(map);
        }
        return list;
    }

}