前言

在使用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类型。

在项目中我们传值时，常常需要把对象集合转成Json集合进行传递。可用如下代码来进行转换：

@Test
	public void test() throws Exception {
		List<JSONObject> dataJson = getDataJson();
		System.out.println(dataJson);
	}
	
	public List<JSONObject> getDataJson() throws Exception {
		List<JSONObject> li=new ArrayList<JSONObject>();
		List<DB2> db2 = getDataFromDB2("3"); // 这个是自己的数据源，就是一个对象集合
		for(DB2 d:db2) {
			Map<String, Object> map = objectToMap(d);
			li.add(new JSONObject(map));
		}
		return li;
	}
	
	 public Map<String, Object> objectToMap(Object obj) throws IllegalAccessException {
        Map<String, Object> map = new HashMap<String,Object>();
        Class<?> clazz = obj.getClass();
        for (Field field : clazz.getDeclaredFields()) {
            field.setAccessible(true);
            String fieldName = field.getName();
            Object value = field.get(obj);
            map.put(fieldName, value);
        }
        return map;
    }

结果如下：

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;
}