JavaBean于Map集合相互转换，使用反射

利于反射完成JavaBean转行成为Map集合，Map转换为JavaBean

1. 编写普通实体类（JavaBean）

/**
 * 测试javabean（实体类）
 * 
 * @author ajie
 *
 */
public class TestEntity {

    // 判断
    private boolean flag;

    // 名字
    private String name;

    // 工资
    private double salary;

    // 性别
    private char sex;

    // 年龄
    private int age;

    // 时间
    private Date time;

    public TestEntity() {

    }

    public Date getTime() {
        return time;
    }

    public void setTime(Date time) {
        this.time = time;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

}

设置基本私有属性和get、set方法，使用常用数据类型；
注意：Boolean类型在get方法为is，所以在编写转换帮助时，需要做下判断。

---

2. 编写转换帮助类

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import org.apache.log4j.Logger;


/**
 * 集合帮助类 map转换为javabean（实体类） javabean转换为map
 * 
 * @author ajie
 *
 */
public class CollectionUtils {

    // 创建log对象
    static Logger LOG = Logger.getLogger(CollectionUtils.class);

    /**
     * javabean转换为map集合
     * 
     * @param obj
     *            传入的Javabean
     * @return
     * @throws NoSuchMethodException
     * @throws SecurityException
     * @throws IllegalAccessException
     * @throws IllegalArgumentException
     * @throws InvocationTargetException
     */
    public static Map beanToMap(Object obj) throws NoSuchMethodException, SecurityException, IllegalAccessException,
            IllegalArgumentException, InvocationTargetException {
        // 判断javabean参数不能为空
        if (obj == null) {
            return null;
        }

        // 获取javabaen中所有的属性
        Field[] fields = obj.getClass().getDeclaredFields();

        // 创建map集合
        Map map = new HashMap<>();

        // 循环遍历
        for (Field fie : fields) {

            // 获取属性第一个字母，设置为大写
            String firstLetter = fie.getName().substring(0, 1).toUpperCase();

            LOG.debug("设置的属性第一个字母为==》》》" + firstLetter);

            // 获取属性的类型并反射为class
            Class paramType = fie.getType();

            LOG.debug("属性类型为==》》" + paramType.getName());

            // 用于获取封装好的属性get方法
            String getter = "";

            // 判断属性类型是否为Boolean类型
            if ("boolean".equals(paramType.getName())) {

                // 封装属性为boolean类型的is方法
                getter = "is" + firstLetter + fie.getName().substring(1);
            } else {

                // 封装属性get方法
                getter = "get" + firstLetter + fie.getName().substring(1);

            }

            LOG.debug("调用方法名==》》" + getter);

            // 获取javabean设置的方法
            Method method = obj.getClass().getMethod(getter, new Class[] {});

            LOG.debug("调用的方法==》》" + method.toString());

            // 执行javabean中方法，并接受返回的参数
            Object returnObj = method.invoke(obj, new Object[] {});

            // 判断属性类型为date类型时，格式化调用get的返回值
            if ("java.util.Date".equals(paramType.getName())) {

                // 获取格式化后的字符串
                returnObj = CollectionUtils.dateToString((Date) returnObj);

            }

            // 判断返回的值不能为空
            if (returnObj != null) {
                map.put(fie.getName(), returnObj);
            } else {
                map.put(fie.getName(), "");
            }

            LOG.debug("调用方法返回的参数值==》》" + returnObj);
        }

        LOG.debug("查看map集合中的值==》》" + map);

        return map;
    }

    /**
     * 将map集合转换为Javabean集合
     * 
     * @param map
     *            指定map集合
     * @param obj
     *            指定需要转换的javabean
     * @return
     * @throws NoSuchMethodException
     * @throws SecurityException
     * @throws NumberFormatException
     * @throws IllegalAccessException
     * @throws IllegalArgumentException
     * @throws InvocationTargetException
     */
    public static Object mapToBean(Map map, Object obj) throws NoSuchMethodException, SecurityException,
            NumberFormatException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {

        // 获取javabean中所有属性
        Field[] fields = obj.getClass().getDeclaredFields();

        // 循环遍历
        for (Field fie : fields) {

            // 判断是否有属性key值
            if (map.containsKey(fie.getName())) {

                // 获取当前map集合中为属性key值的value值
                String value = map.get(fie.getName()).toString();

                LOG.debug("mapToBean:map集合中的value值==》》" + value);

                // 获取属性首字母并设置为大写
                String firstLetter = fie.getName().substring(0, 1).toUpperCase();

                // 获取当前属性类型
                Class paramType = fie.getType();

                // 封装属性set方法
                String setter = "set" + firstLetter + fie.getName().substring(1);

                // 获取当前javabean中的方法，并设置参数类型
                Method method = obj.getClass().getMethod(setter, paramType);

                LOG.debug("mapTobean:调用javabean中的方法==》》" + method.toString());

                // 判断属性为double类型
                if ("double".equals(paramType.getName())) {

                    // 调用当前Javabean中set方法，并传入指定类型参数
                    method.invoke(obj, Double.valueOf(value));

                    // 属性为char类型时
                } else if ("char".equals(paramType.getName())) {

                    method.invoke(obj, CollectionUtils.StringToChar(value));

                    // 属性为Date类型时
                } else if ("java.util.Date".equals(paramType.getName())) {

                    // 判断如果值是空的，则返回空
                    Date date = (value == null || value.length() == 0) ? null : CollectionUtils.StringToDate(value);

                    method.invoke(obj, date);

                    // 属性为String类型时
                } else if ("java.lang.String".equals(paramType.getName())) {

                    method.invoke(obj, value);

                    // 属性为int类型时
                } else if ("int".equals(paramType.getName())) {

                    method.invoke(obj, Integer.valueOf(value == null ? "0" : value));

                }
            }
        }

        return obj;
    }

    /**
     * 将String转换为char
     * 
     * @param str
     * @return
     */
    public static char StringToChar(String str) {

        // 获取传入String转换为Char数组
        char[] charArray = str.toCharArray();

        // 设置char为空
        char newChar = Character.MIN_VALUE;

        // 循环拼接char
        for (char cha : charArray) {

            newChar += cha;

        }

        return newChar;
    }

    /**
     * 字符串转换为date，格式为：yyyy-MM-dd HH:mm:ss
     * 
     * @param str
     * @return
     */
    public static Date StringToDate(String str) {

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        Date date = null;

        try {
            date = sdf.parse(str);
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return date;
    }

    /**
     * date转换为字符串，格式为：yyyy-MM-dd HH:mm:ss
     * 
     * @param time
     * @return
     */
    public static String dateToString(Date time) {

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        return sdf.format(time);
    }

}

这里转换基本使用反射获取Javabean中的所有属性，

Field[] fields= Javabean.getClass().getDeclaredFields();，

根据获取的属性进行get字段封装，在get类型为boolean时，需要将get换位is，记住属性首字母需要转换为大写；
然后在获取属性的类型，用下代码：

Class paramType = fie.getType();，
根据属性类型封装get方法语句，在通过

Method method = Javabean.getClass().getMethod(getter, new Class[] {});
获取设置的实体类中的get方法，在通过Method方法类的invoke()方法执行，获取get方法返回值，代码如下：

Object returnObj = method.invoke(obj, new Object[] {});

根据Javabean的属性调用get方法完成对Map集合的转换，Map集合转换为Javabean也是同样的运行方式，只是将get转为set了，这就是使用反射将Javabean和Map集合进行互相转换，希望能帮助到正在学习的你，有更好的方式可以一起相互讨论；

下面是源代码下载地址：
map与Javabean相互转换实例源代码