前言
在使用Java编程过程中，经常会遇到获取的数据为Object类型，但只是以这种方式传输，实质还是Map类型，此时就涉及到两种类型的相互转换。
强制转换
在类型转换工程中，常见的转换方式为强制转换。如(String)map.get(key),(int)map.get(key)等。但是如果接收的类型为Map，此时强转(Map<String, Object>) obj则会报出警告。
治标不治本
很多人会使用@SuppressWarnings(“unchecked”)来解决编辑器中的警告，好看是好看了。但是这用来告诉编译器忽略警告，而警告却实实在在的存在。项目的风险还是存在。
方法一
可以使用java.lang.reflect.Field类完成Obj和Map之间的相互转换.

Object转Map类型

//Object转Map
public static Map<String, Object> getObjectToMap(Object obj) throws IllegalAccessException {
    Map<String, Object> map = new HashMap<String, Object>();
    Class<?> cla = obj.getClass();
    Field[] fields = cla.getDeclaredFields();
    for (Field field : fields) {
        field.setAccessible(true);
        String keyName = field.getName();
        Object value = field.get(obj);
        if (value == null)
            value = "";
        map.put(keyName, value);
    }
    return map;
}


Map转Object类型

//Map转Object
public static Object getMapToObject(Map<Object, Object> map, Class<?> cla) throws Exception {
    if (map == null)
        return null;
    Object obj = cla.newInstance();
    Class<?> cla = obj.getClass();
    Field[] fields = cla.getDeclaredFields();
    for (Field field : fields) {
        int mod = field.getModifiers();
        if (Modifier.isStatic(mod) || Modifier.isFinal(mod)) {
            continue;
        }
        field.setAccessible(true);
        if (map.containsKey(field.getName())) {
            field.set(obj, map.get(field.getName()));
        }
    }
    return obj;
}

通过Field类进行数据类型的转换。
方法二
通过BeanUtils工具类进行转换
//1、map转换为object

public static Object mapToObject(Map<String, Object> map, Class<?> cla)
　　　　throws Exception {
	if (map == null) 
		return null;
　　Object obj = clas.newInstance();
	org.apache.commons.beanutils.BeanUtils.populate(obj, map);
	return obj;
}

//2、object转换为map
public static Map<?, ?> objectToMap(Object obj) {
	if (obj == null) 
		return null;
	return new org.apache.commons.beanutils.BeanMap(obj);
}

总结
最后，通过调用这两个方法就可以实现Object转Map类型，Map转Object类型。

FindArchiveDto findArchiveDto = new FindArchiveDto();
findArchiveDto.setContractStatus("降龙");
findArchiveDto.setCustName("明华");
findArchiveDto.setDepartmentName("赵无极");

fastjson转换方法


//Object转Map
Map map = JSONObject.parseObject(JSONObject.toJSONString(findArchiveDto), Map.class);
Map<String,Object> map = JSONObject.parseObject(JSON.toJSONString(findArchiveDto));
//Map转Object
FindArchiveDto findArchiveDto1 = JSON.parseObject(JSON.toJSONString(map), FindArchiveDto.class);
FindArchiveDto findArchiveDto2 = JSONObject.toJavaObject(JSON.toJSONString(map), FindArchiveDto.class);

jackson的转换

ObjectMapper mapper = new ObjectMapper();
//对象转map
Map m = mapper.readValue(mapper.writeValueAsString(findArchiveDto), Map.class);
//map转对象
FindArchiveDto dto = mapper.readValue(mapper.writeValueAsString(m), FindArchiveDto.class);

还可以用org.apache.commons.beanutils.BeanMap进行转换

Map<String, Object> map = new org.apache.commons.beanutils.BeanMap(findArchiveDto);

还可以用org.apache.commons.beanutils.BeanUtils将map转为对象

BeanUtils.populate(findArchiveDto, map);


//Object转Map
public static Map<String, Object> getObjectToMap(Object obj) throws IllegalAccessException {
    Map<String, Object> map = new LinkedHashMap<String, Object>();
    Class<?> clazz = obj.getClass();
    System.out.println(clazz);
    for (Field field : clazz.getDeclaredFields()) {
        field.setAccessible(true);
        String fieldName = field.getName();
        Object value = field.get(obj);
        if (value == null){
            value = "";
        }
        map.put(fieldName, value);
    }
    return map;
}

//Map转Object
public static Object mapToObject(Map<Object, Object> map, Class<?> beanClass) throws Exception {
    if (map == null)
        return null;
    Object obj = beanClass.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);
        if (map.containsKey(field.getName())) {
            field.set(obj, map.get(field.getName()));
        }
    }
    return obj;
}

仅供参考

@Log4j

public class ObjectToMap {

    /*简单Object转成map*/

    public static Map<String,String> toMap(Object o){

        Map<String,String> map=new HashMap<String, String>();

        Field[] fields=o.getClass().getDeclaredFields();

        try {

            for (int i=0;i<fields.length;i++) {

                String name=fields[i].getName();

                Field field=o.getClass().getDeclaredField(name);

                field.setAccessible(true);

                if (null!=field){

                    map.put(name,field.get(o).toString());

                }

            }

        }catch(Exception e){

            log.error(e.getMessage(),e);

        }

        return map;

    }

    /*复杂Object转成map*/

    public static Map<String, Object> toObjectMap(Object object) {

        Map<String, Object> map = new HashMap<String, Object>();

        toMap(object.getClass(), object, map);

        return map;

    }

    private static void toMap(Class<?> clazz, Object object, Map<String, Object> map) {

        Method[] methods = clazz.getDeclaredMethods();

        if (methods != null && methods.length > 0) {

            for (Method method : methods) {

                String mname = method.getName();

                if (mname.startsWith("get") && method.getParameterTypes().length == 0) {

                    try {

                        String fieldName = mname.substring(3, 4).toLowerCase() + mname.substring(4);

                        if ("serialVersionUID".equals(fieldName)) {

                            continue;

                        } else if ("class".equals(fieldName)) {

                            continue;

                        }

                        Object fieldValue = method.invoke(object, null);

                        if (fieldValue != null) {

                            map.put(fieldName, fieldValue);

                        }

                    } catch (IllegalAccessException e) {

                        log.info(e.getMessage(),e);

                    } catch (InvocationTargetException e) {

                        log.info(e.getMessage(),e);

                    } catch (SecurityException e) {

                        log.error(e.getMessage(),e);

                    }

                }

            }

        }

        if (clazz.getSuperclass() != null) {

            toMap(clazz.getSuperclass(), object, map);

        }

    }

    public static void main(String[] args)throws Exception {

        Tests tests=new Tests(10,"zhangsan");

        ObjectToMap om= new ObjectToMap();

        Map<String,String> map= om.toMap(tests);

        System.out.println(map.toString());

        Map<String,Object> omap= om.toObjectMap(tests);

        System.out.println(omap.toString());

    }

}

class Tests{

    private int age;

    private String name;

    public Tests(int age,String name) {

        this.age=age;

        this.name=name;

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

}

1、定义一个实体类：

package reflect;

public class User {
    
    private String name;
    
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

2、Map转Object转换如下：
package reflect;

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

public class testMapToObject {
    
    public static void main(String[] args){
        
        //假设有一个Map存放了一个对象的姓名和年龄
        Map<String,Object> map = new HashMap<String,Object>();
        map.put("name", "Kobi");
        map.put("age", 39);
        
        User user = transferMapToUser(map,User.class);
        
        System.out.println(user.getName());
        System.out.println(user.getAge());
    }
    
    public static <T> T transferMapToUser(Map<String,Object> map,Class<T> classT){
        try {
            return transfer(map,classT.newInstance());
        } catch (InstantiationException ex) {
            System.out.println("what the fuck?");
        } catch (IllegalAccessException ex) {
            System.out.println("what the fuck?");
        }
        return null;
    }
    
    public static <T> T transfer(Map<String,Object> map,Object obj){
        
        try {
            BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
            PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();

            for (PropertyDescriptor property : propertyDescriptors) {
                String key = property.getName();
                if (map.containsKey(key)) {
                    Object value = map.get(key);
                    // 得到property对应的setter方法
                    Method setter = property.getWriteMethod();
                    try {
                        setter.invoke(obj, value);
                    } catch (IllegalArgumentException ex) {
                        System.out.println("what the fuck?");
                    }
                }
            }
        } catch (Exception ex) {
            System.out.println("what the fuck?");
        }

        return (T) obj;
    }
    
}
运行结果：
run:
Kobi
39
成功构建 (总时间: 0 秒)

3、Object转Map：
package reflect;

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.TreeMap;

public class testObjectToMap {
    
    public static void main(String[] args){
        User user = new User();
        user.setName("Kobi");
        user.setAge(39);
        
        Map<String, Object>  map = transBean2Map(user);
        System.out.println(map);
        
    }
 
    public static  Map<String, Object> transBean2Map(Object obj) {

        if (obj == null) {
            return null;
        }
        TreeMap<String, Object> map = new TreeMap<>();
        try {
            BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
            PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
            for (PropertyDescriptor property : propertyDescriptors) {
                String key = property.getName();
                // 过滤class属性
                if (key.equals("class")) {
                    continue;
                }
                
                // 得到property对应的getter方法
                Method getter = property.getReadMethod();
                Object value = getter.invoke(obj);
                
                map.put(key, value);
            }
        } catch (Exception e) {
            System.out.println("transBean2Map Error " + e);
        }
        return map;
    }
}
运行结果：


run:
{age=39, name=Kobi}
成功构建 (总时间: 0 秒)