java使用泛型实现Bean类和Map的相互转换

java使用泛型实现Bean类和Map的相互转换,使用泛型可以这带来了很多好处:

首要就是类型安全, Java 程序的类型安全。通过知道使用泛型,这些假设就只存在于程序员的头脑中(或者如果幸运的话,还存在于代码注释中)。

      泛型允许编译器实施这些附加的类型约束。类型错误现在就可以在编译时被捕获了,而不是在运行时当作 ClassCastException 展示出来。

   将类型检查从运行时挪到编译时有助于您更容易找到错误,并可提高程序的可靠性。

  消除强制类型转换。 泛型的一个附带好处是,消除源代码中的许多强制类型转换。这使得代码更加可读,并且减少了出错机会。

主方法實現:

 1 public class BeanUtil {
 2
 3     public static void main(String[] args) throws Exception {
 4
 5         Map<String, Object> mp = new HashMap<String, Object>();
 6         mp.put("name", "Jack");
 7         mp.put("age", 40);
 8         mp.put("mN", "male");
 9
10         PersonBean person = map2Bean(mp, PersonBean.class);
11         System.out.println("transMap2Bean Map Info:");
12         for (Map.Entry<String, Object> entry : mp.entrySet()) {
13             System.out.println(entry.getKey() + ": " + entry.getValue());
14         }
15         System.out.println("Bean Info:");
16         System.out.println("name: " + person.getName());
17         System.out.println("age: " + person.getAge());
18         System.out.println("mN: " + person.getmN());
19
20         bean2Map(person, mp);
21         System.out.println("transBean2Map Map Info:");
22         for (Map.Entry<String, Object> entry : mp.entrySet()) {
23             System.out.println(entry.getKey() + ": " + entry.getValue());
24         }
25     }

mapToBean方法:

 1     public static <T, K, V> T map2Bean(Map<K, V> mp, Class<T> beanCls)
 2             throws Exception, IllegalArgumentException, InvocationTargetException {
 3         T t = null;
 4         try {
 5
 6             BeanInfo beanInfo = Introspector.getBeanInfo(beanCls);
 7             PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
 8
 9             t = beanCls.newInstance();
10
11             for (PropertyDescriptor property : propertyDescriptors) {
12                 String key = property.getName();
13
14                 if (mp.containsKey(key)) {
15                     Object value = mp.get(key);
16                     Method setter = property.getWriteMethod();// Java中提供了用来访问某个属性的
17                                                                 // getter/setter方法
18                     setter.invoke(t, value);
19                 }
20             }
21
22         } catch (IntrospectionException e) {
23
24             e.printStackTrace();
25         }
26         return t;
27     }

beanToMap方法:

 1 public static <T, K, V> Map<String, Object> bean2Map(T bean, Map<String, Object> mp)
 2             throws Exception, IllegalAccessException {
 3
 4         if (bean == null) {
 5             return null;
 6         }
 7
 8         try {
 9             BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
10             PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
11
12             for (PropertyDescriptor property : propertyDescriptors) {
13                 String key = property.getName();
14
15                 if (!key.equals("class")) {
16
17                     Method getter = property.getReadMethod();// Java中提供了用来访问某个属性的
18                                                                 // getter/setter方法
19                     Object value;
20
21                     value = getter.invoke(bean);
22                     mp.put(key, value);
23                 }
24
25             }
26
27         } catch (IntrospectionException e) {
28
29             e.printStackTrace();
30         } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
31             // TODO Auto-generated catch block
32             e.printStackTrace();
33
34         }
35         return mp;
36
37     }
38 }

  總結:使用泛型可以避免類型轉換錯誤,可以在集合框架(Collection framework)中看到泛型的动机。例如,Map 类允许您向一个 Map 添加任意类的对象,

即使最常见的情况是在给定映射(map)中保存某个特定类型(比如 String)的对象。因为 Map.get() 被定义为返回 Object,所以一般必须将 Map.get() 的结果强制类型转换为期望的类型,如下面的代码所示:

Map m = new HashMap();
m.put("key", "blarg");
String s = (String) m.get("key");

要让程序通过编译,必须将 get() 的结果强制类型转换为 String,并且希望结果真的是一个 String。但是有可能某人已经在该映射中保存了不是 String 的东西,这样的话,上面的代码将会抛出 ClassCastException。

时间: 2024-10-20 10:03:48

java使用泛型实现Bean类和Map的相互转换的相关文章

java实现Bean类和Map的相互转换

创建类PersonBean,有属性name,age和mN,生成get和set方法 主方法 map2Bean方法: Bean2map方法: 测试结果: 总结: javaBean与Map<String,Object>互转利用到了java的内省( Introspector )和反射(reflect)机制. 其思路为: 通过类 Introspector 来获取某个对象的 BeanInfo 信息,然后通过 BeanInfo 来获取属性的描述器 PropertyDescriptor,再利用属性描述器获取某

java中Bean类和Map的相互转换

1 package com.studey.mapTbean; 2 3 import java.beans.BeanInfo; 4 import java.beans.IntrospectionException; 5 import java.beans.Introspector; 6 import java.beans.PropertyDescriptor; 7 import java.lang.reflect.InvocationTargetException; 8 import java.l

java处理json的工具类(list,map和json的之间的转换)

需要下载第三方的jar :net.sf.json import java.io.BufferedReader; import java.io.InputStream; import java.io.InputStreamReader; import java.net.URL; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.Map; import java

Java基础---泛型、集合框架工具类:collections和Arrays

第一讲     泛型(Generic) 一.概述 1.JDK1.5版本以后出现的新特性.用于解决安全问题,是一个类型安全机制. 2.JDK1.5的集合类希望在定义集合时,明确表明你要向集合中装入那种类型的数据,无法加入指定类型以外的数据. 3.泛型是提供给javac编译器使用的可以限定集合中的输入类型说明的集合时,会去掉“类型”信息,使程序运行效率不受影响,对参数化的泛型类型,getClass()方法的返回值和原始类型完全一样. 4.由于编译生成的字节码会去掉泛型的类型信息,只要能跳过编译器,就

java.lang.IllegalStateException: Ambiguous mapping found. Cannot map &#39;XXXXX&#39; bean

今天启动srpingmvc项目的时候出现了这个异常, 原因: 在同个项目中,我复制了其中一个 Controller 作为备份 却忘记修改  @RequestMapping("/xxx") 在springmvc中不能同时映射一个名字(@RequestMapping("/xxx") java.lang.IllegalStateException: Ambiguous mapping found. Cannot map 'XXXXX' bean

Java 容器 & 泛型:一、认识容器

Writer:BYSocket(泥沙砖瓦浆木匠) 微博:BYSocket 豆瓣:BYSocket 容器是Java语言学习中重要的一部分.泥瓦匠我的感觉是刚开始挺难学的,但等你熟悉它,接触多了,也就"顺理成章"地知道了.Java的容器类主要由两个接口派生而出:Collection和Map. 一.Collection vs Collections 首先,Collection 和 Collections 是两个不同的概念.之所以放在一起,是为了更好的比较.Collection是容器层次结构中

Java基础----Java API中的常用类

System:描述系统的一些信息 preperties();获取系统信息 Properties prop =new System.getProperties(); 是hashtable 的子类.用map的方法去除该类集合中的元素.该集合中存储的都是字符串,没有泛型定义. String calue=(String)prop.get(obj); System.out.println(obj+":"+value); //如何在系统中自定义一些特有信息? System.setProperty(

JAVA中封装JSONUtils工具类及使用

在JAVA中用json-lib-2.3-jdk15.jar包中提供了JSONObject和JSONArray基类,用于JSON的序列化和反序列化的操作.但是我们更习惯将其进一步封装,达到更好的重用. 封装后的JSON工具类JSONUtils.java代码如下: JSONUtils代码,点击展开 import java.util.ArrayList;import java.util.Collection;import java.util.HashMap;import java.util.Itera

Java 容器 & 泛型:三、HashSet,TreeSet 和 LinkedHashSet比较

Writer:BYSocket(泥沙砖瓦浆木匠) 微博:BYSocket 豆瓣:BYSocket 上一篇总结了下ArrayList .LinkedList和Vector比较,今天泥瓦匠总结下Hash .LinkedList和Vector比较.其实大家都是Collection,只不过有点各自特性.那就是数据结构的不同表现. 一.Set回顾 一个不包括重复元素(包括可变对象)的Collection,是一种无序的集合.Set不包含满 a.equals(b) 的元素对a和b,并且最多有一个null.泥瓦