Java 泛型示例

package com.liangblog.utils;

import com.alibaba.fastjson.JSONObject;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class ListUtils {
    public static <T> List<T> listMapToListObj(List<Map<String, Object>> mapList, Class<T> tclass) {
        List<T> tList = new ArrayList<>();
        for (Map<String, Object> map : mapList) {
            T t = MapUtils.map2Class(map, tclass);
            tList.add(t);
        }

        return tList;
    }

//     示例
   public static void main(String[] args) {
        class Apple{
            String appleName;
            String appleCllor;

            public String getAppleName() {
                return appleName;
            }

            public void setAppleName(String appleName) {
                this.appleName = appleName;
            }

            public String getAppleCllor() {
                return appleCllor;
            }

            public void setAppleCllor(String appleCllor) {
                this.appleCllor = appleCllor;
            }
        }
        List<Map<String,Object>> mapList=new ArrayList<>();
        Map<String,Object> map=new HashMap<>();
        map.put("apple_name","苹果一号");
        map.put("apple_cllor","red");
        mapList.add(map);

        List<Apple> apples = listMapToListObj(mapList, Apple.class);

        System.out.println(JSONObject.toJSONString(apples));
    }
}

package com.liangblog.utils;


import com.alibaba.fastjson.TypeReference;
import org.apache.commons.lang3.StringUtils;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.HashMap;
import java.util.Map;

public class MapUtils {
    public static final char UNDERLINE_CHAR = '_';

    /**
     * 返回带单引号的字段
     * 如：'苹果'
     */
    public static String quotesField(String field) {
        field = "'" + field + "'";
        return field;
    }

    /**
     * 下划线转驼峰
     *
     * @param underlineStr
     * @return
     */
    public static String underline2Camel(String underlineStr) {

        if (StringUtils.isEmpty(underlineStr)) {

            return StringUtils.EMPTY;
        }

        int len = underlineStr.length();
        StringBuilder strb = new StringBuilder(len);
        for (int i = 0; i < len; i++) {

            char c = underlineStr.charAt(i);
            if (c == UNDERLINE_CHAR && (++i) < len) {

                c = underlineStr.charAt(i);
                strb.append(Character.toUpperCase(c));
            } else {

                strb.append(c);
            }
        }
        return strb.toString();
    }

    /**
     * 驼峰转下划线
     *
     * @param camelStr
     * @return
     */
    public static String camel2Underline(String camelStr) {

        if (StringUtils.isEmpty(camelStr)) {

            return StringUtils.EMPTY;
        }

        int len = camelStr.length();
        StringBuilder strb = new StringBuilder(len + len >> 1);
        for (int i = 0; i < len; i++) {

            char c = camelStr.charAt(i);
            if (Character.isUpperCase(c)) {

                strb.append(UNDERLINE_CHAR);
                strb.append(Character.toLowerCase(c));
            } else {

                strb.append(c);
            }
        }
        return strb.toString();
    }

    /**
     * 带下划线的key的Map转成驼峰形式的实体对象
     *
     * @param map   map实体对象包含属性
     * @param clazz 实体对象类型
     * @return
     */
    public static Object map2Object(Map<String, Object> map, Class<?> clazz) {
        if (map == null) {
            return null;
        }
        Object obj = null;
        try {
            obj = clazz.newInstance();
            Field[] fields = obj.getClass().getDeclaredFields();
            for (Field field : fields) {
                int mod = field.getModifiers();
                if (Modifier.isStatic(mod) || Modifier.isFinal(mod)) {
                    continue;
                }
                field.setAccessible(true);
                field.set(obj, map.get(camel2Underline(field.getName()))); // 获取带_下划线的名称的value值
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return obj;
    }

    /**
     * 带下划线的key的Map转成驼峰形式的实体对象
     *
     * @param map   map实体对象包含属性
     * @param clazz 实体对象类型
     * @return
     */
    public static <T> T map2Class(Map<String, Object> map, Class<T> clazz) {
        if (map == null) {
            return null;
        }
        T t = null;
        try {
             t = clazz.newInstance();
            Field[] fields = t.getClass().getDeclaredFields();
            for (Field field : fields) {
                int mod = field.getModifiers();
                if (Modifier.isStatic(mod) || Modifier.isFinal(mod)) {
                    continue;
                }
                field.setAccessible(true);
                field.set(t, map.get(camel2Underline(field.getName()))); // 获取带_下划线的名称的value值
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return t;

    }

    /**
     * 驼峰形式的实体对象转成带下划线的key的Map
     * --------------------------------
     * java 驼峰实体类和数据库下划线对应
     *
     * @param obj 实体对象
     * @return
     */
    public static Map<String, Object> object2Map(Object obj) {
        Class<?> clazz = obj.getClass();
        if (clazz == null) {
            return null;
        }
        Map<String, Object> map = new HashMap<>();
        try {
//            obj = clazz.newInstance();
            Field[] fields = obj.getClass().getDeclaredFields();
            for (Field field : fields) {
                int mod = field.getModifiers();
                if (Modifier.isStatic(mod) || Modifier.isFinal(mod)) {
                    continue;
                }
                field.setAccessible(true);
                String name = field.getName();
                //根据属性名获取属性值
                Object fieldValueByName = getFieldValueByName(name, obj);

                map.put(camel2Underline(name), fieldValueByName);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return map;
    }

    /**
     * 根据属性名获取属性值
     *
     * @param fieldName
     * @param o
     * @return
     */
    private static Object getFieldValueByName(String fieldName, Object o) {
        try {
            //get方法的get 后的第一个字母是大写的
            //get方法的get 后的第一个字母是大写的
            //get方法的get 后的第一个字母是大写的
            fieldName = fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1, fieldName.length());
            String getter = "get" + fieldName;
            Method method = o.getClass().getMethod(getter, new Class[]{});
            Object value = method.invoke(o, new Object[]{});
            return value;
        } catch (Exception e) {
            return null;
        }
    }
    /* 根据属性名获取属性值
     * */
  /*  private static Object getFieldValueByName(String fieldName, Object o) {
        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) {

            return null;
        }
    }   */

}