java utils--6.map与对象互转

1      单个对象

1.1  适用简单类型

参看博客：https://blog.csdn.net/hechurui/article/details/60583497

适用不包含类的类（基本数据类型，数组，集合）

 

1.由于map是没有顺序的，在有些对数据顺序要求比较严格的

   2.map从内到外都是object类型，如果用到对象中包含对象

 

1.1.1  转换demo

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
import com.kun.xiangtan.service.Po; 
 
 
/**
 * @作用：单个map和对象互转
 * @意义：1.由于map是没有顺序的，在有些对数据顺序要求比较严格的
 *    2.map从内到外都是object类型，如果用到对象中包含对象
 * @试用范围：不包含类的类（基本数据类型，数组，集合）
 */ 
public classMapObject { 
   /**
     * 将一个 Map 对象转化为一个 JavaBean
     * @param clazz 要转化的类型
     * @param map 包含属性值的 map
     * @return转化出来的 JavaBean 对象
     * @throws IntrospectionException 如果分析类属性失败
     * @throws IllegalAccessException 如果实例化 JavaBean 失败
     * @throws InstantiationException 如果实例化 JavaBean 失败
     * @throws InvocationTargetException 如果调用属性的 setter 方法失败
     */ 
   @SuppressWarnings("rawtypes") 
   publicstatic<T> T toBean(Class<T> clazz, Map map){ 
        T obj = null; 
        try { 
            BeanInfo beanInfo = Introspector.getBeanInfo(clazz); 
            obj = clazz.newInstance(); // 创建 JavaBean 对象 
 
            // 给 JavaBean 对象的属性赋值 
            PropertyDescriptor[] propertyDescriptors= beanInfo.getPropertyDescriptors(); 
            for (int i = 0; i < propertyDescriptors.length; i++) { 
                PropertyDescriptor descriptor = propertyDescriptors[i]; 
                String propertyName = descriptor.getName(); 
                if (map.containsKey(propertyName)) { 
                    // 下面一句可以 try 起来，这样当一个属性赋值失败的时候就不会影响其他属性赋值。 
                    Object value = map.get(propertyName); 
                    if ("".equals(value)){ 
                        value = null; 
                    } 
                    Object[] args = new Object[1]; 
                    args[0] = value; 
                    try { 
                        descriptor.getWriteMethod().invoke(obj, args); 
                    } catch(InvocationTargetException e) { 
                        System.out.println("字段映射失败"); 
                    } 
                } 
            } 
        } catch (IllegalAccessException e) { 
            System.out.println("实例化 JavaBean 失败"); 
        } catch (IntrospectionException e) { 
            System.out.println("分析类属性失败"); 
       } catch (IllegalArgumentException e) { 
            System.out.println("映射错误"); 
        } catch (InstantiationException e) { 
            System.out.println("实例化 JavaBean 失败"); 
        } 
        return (T) obj; 
   } 
 
   /**
     * 将一个 JavaBean 对象转化为一个 Map
     * @param bean 要转化的JavaBean 对象
     * @return转化出来的 Map 对象
     * @throws IntrospectionException 如果分析类属性失败
     * @throws IllegalAccessException 如果实例化 JavaBean 失败
     * @throws InvocationTargetException 如果调用属性的 setter 方法失败
     */ 
   @SuppressWarnings("rawtypes") 
   publicstaticMap toMap(Object bean){ 
        Class<? extends Object> clazz = bean.getClass(); 
        Map<Object, Object> returnMap = new HashMap<Object,Object>(); 
        BeanInfo beanInfo = null; 
        try { 
            beanInfo = Introspector.getBeanInfo(clazz); 
            PropertyDescriptor[] propertyDescriptors= beanInfo.getPropertyDescriptors(); 
            for (int i = 0; i < propertyDescriptors.length; i++) { 
                PropertyDescriptor descriptor = propertyDescriptors[i]; 
                String propertyName = descriptor.getName(); 
                if (!propertyName.equals("class")){ 
                    Method readMethod = descriptor.getReadMethod(); 
                    Object result = null; 
                    result = readMethod.invoke(bean,newObject[0]); 
                    if (null != propertyName) { 
                        propertyName = propertyName.toString(); 
                    } 
                    if (null != result) { 
                        result = result.toString(); 
                    } 
                    returnMap.put(propertyName, result); 
                } 
            } 
        } catch (IntrospectionException e) { 
            System.out.println("分析类属性失败"); 
        } catch (IllegalAccessException e) { 
            System.out.println("实例化 JavaBean 失败"); 
        } catch (IllegalArgumentException e) { 
            System.out.println("映射错误"); 
        } catch (InvocationTargetException e) { 
            System.out.println("调用属性的 setter 方法失败"); 
        } 
        return returnMap; 
   } 
 
   publicstaticvoidmain(String[] args){
      //体现map无顺序
        Map<Object, Object> map = new HashMap<Object,Object>(); 
        map.put("id", "map1111"); 
        map.put("station_name", "map火车站"); 
        map.put("station_no", 2); 
        String [] arr = {"1", "55"};
        map.put("arr", arr);
        List l = new ArrayList<>();
        l.add("1111");
        l.add("1122");
        l.add("1133");
        map.put("l", l);
       
        //1.map转换成对象
        System.out.println("---------map转换成对象----------");
        System.out.println("原map:" + map);
        Po poObj = toBean(Po.class, map); 
        System.out.println("现对象：" + poObj);
       
        Po p = new Po(); 
        p.setId("111"); 
        p.setKind("up");
       
        //2.对象转换成map
        System.out.println("---------对象转换成map----------");
        System.out.println("原对象：" + p);
        Map mMap = toMap(p); 
        System.out.println("现map（还是无顺序的）：" + mMap); 
 
   } 
} 

1.1.2  输出结果