1月 212015
 

网上找到的关于Gson各特殊类型转换的代码实例,非常好,分享下。

转自:http://blog.csdn.net/lk_blog/article/details/7685190

Json转换利器Gson之实例一-简单对象转化和带泛型的List转化

Gson 是 Google 提供的用来在 Java 对象和 JSON 数据之间进行映射的 Java 类库。可以将一个 JSON 字符串转成一个 Java 对象,或者反过来。

jar和源码下载地址: http://code.google.com/p/google-gson/downloads/list


实体类:

[java] view plaincopy

  1.   
[java] view plaincopy

  1. public class Student {  
  2.     private int id;  
  3.     private String name;  
  4.     private Date birthDay;  
  5.   
  6.     public int getId() {  
  7.         return id;  
  8.     }  
  9.   
  10.     public void setId(int id) {  
  11.         this.id = id;  
  12.     }  
  13.   
  14.     public String getName() {  
  15.         return name;  
  16.     }  
  17.   
  18.     public void setName(String name) {  
  19.         this.name = name;  
  20.     }  
  21.   
  22.     public Date getBirthDay() {  
  23.         return birthDay;  
  24.     }  
  25.   
  26.     public void setBirthDay(Date birthDay) {  
  27.         this.birthDay = birthDay;  
  28.     }  
  29.   
  30.     @Override  
  31.     public String toString() {  
  32.         return “Student [birthDay=” + birthDay + “, id=” + id + “, name=”  
  33.                 + name + “]”;  
  34.     }  
  35.   
  36. }  

测试类:

[html] view plaincopy

  1. import java.util.ArrayList;  
  2. import java.util.Date;  
  3. import java.util.List;  
  4.   
  5. import com.google.gson.Gson;  
  6. import com.google.gson.reflect.TypeToken;  
  7.   
  8. public class GsonTest1 {  
  9.   
  10.     public static void main(String[] args) {  
  11.         Gson gson = new Gson();  
  12.   
  13.         Student student1 = new Student();  
  14.         student1.setId(1);  
  15.         student1.setName(“李坤”);  
  16.         student1.setBirthDay(new Date());  
  17.   
  18.         // //////////////////////////////////////////////////////////  
  19.         System.out.println(“———-简单对象之间的转化————-“);  
  20.         // 简单的bean转为json  
  21.         String s1 = gson.toJson(student1);  
  22.         System.out.println(“简单Bean转化为Json===” + s1);  
  23.   
  24.         // json转为简单Bean  
  25.         Student student = gson.fromJson(s1, Student.class);  
  26.         System.out.println(“Json转为简单Bean===” + student);  
  27.         // 结果:  
  28.         // 简单Bean转化为Json==={“id”:1,”name”:”李坤”,”birthDay”:”Jun 22, 2012 8:27:52 AM”}  
  29.         // Json转为简单Bean===Student [birthDay=Fri Jun 22 08:27:52 CST 2012, id=1,  
  30.         // name=李坤]  
  31.         // //////////////////////////////////////////////////////////  
  32.   
  33.         Student student2 = new Student();  
  34.         student2.setId(2);  
  35.         student2.setName(“曹贵生”);  
  36.         student2.setBirthDay(new Date());  
  37.   
  38.         Student student3 = new Student();  
  39.         student3.setId(3);  
  40.         student3.setName(“柳波”);  
  41.         student3.setBirthDay(new Date());  
  42.   
  43.         List<Student> list = new ArrayList<Student>();  
  44.         list.add(student1);  
  45.         list.add(student2);  
  46.         list.add(student3);  
  47.   
  48.         System.out.println(“———-带泛型的List之间的转化————-“);  
  49.         // 带泛型的list转化为json  
  50.         String s2 = gson.toJson(list);  
  51.         System.out.println(“带泛型的list转化为json==” + s2);  
  52.   
  53.         // json转为带泛型的list  
  54.         List<Student> retList = gson.fromJson(s2,  
  55.                 new TypeToken<List<Student>>() {  
  56.                 }.getType());  
  57.         for (Student stu : retList) {  
  58.             System.out.println(stu);  
  59.         }  
  60.   
  61.         // 结果:  
  62.         // 带泛型的list转化为json==[{“id”:1,”name”:”李坤”,”birthDay”:”Jun 22, 2012 8:28:52 AM”},{“id”:2,”name”:”曹贵生”,”birthDay”:”Jun 22, 2012 8:28:52 AM”},{“id”:3,”name”:”柳波”,”birthDay”:”Jun 22, 2012 8:28:52 AM”}]  
  63.         // Student [birthDay=Fri Jun 22 08:28:52 CST 2012, id=1name=李坤]  
  64.         // Student [birthDay=Fri Jun 22 08:28:52 CST 2012, id=2name=曹贵生]  
  65.         // Student [birthDay=Fri Jun 22 08:28:52 CST 2012, id=3name=柳波]  
  66.   
  67.     }  
  68. }  

执行结果:

[plain] view plaincopy

  1. ———-简单对象之间的转化————-  
  2. 简单Bean转化为Json==={“id”:1,”name”:”李坤”,”birthDay”:”Jun 22, 2012 9:10:31 PM”}  
  3. Json转为简单Bean===Student [birthDay=Fri Jun 22 21:10:31 CST 2012, id=1, name=李坤]  
  4. ———-带泛型的List之间的转化————-  
  5. 带泛型的list转化为json==[{“id”:1,”name”:”李坤”,”birthDay”:”Jun 22, 2012 9:10:31 PM”},{“id”:2,”name”:”曹贵生”,”birthDay”:”Jun 22, 2012 9:10:31 PM”},{“id”:3,”name”:”柳波”,”birthDay”:”Jun 22, 2012 9:10:31 PM”}]  
  6. Student [birthDay=Fri Jun 22 21:10:31 CST 2012, id=1, name=李坤]  
  7. Student [birthDay=Fri Jun 22 21:10:31 CST 2012, id=2, name=曹贵生]  
  8. Student [birthDay=Fri Jun 22 21:10:31 CST 2012, id=3, name=柳波]  

Json转换利器Gson之实例二-Gson注解和GsonBuilder

有时候我们不需要把实体的所有属性都导出,只想把一部分属性导出为Json.

有时候我们的实体类会随着版本的升级而修改.

有时候我们想对输出的json默认排好格式.

… …

请看下面的例子吧:

实体类:

[java] view plaincopy

  1. import java.util.Date;  
  2.   
  3. import com.google.gson.annotations.Expose;  
  4. import com.google.gson.annotations.SerializedName;  
  5.   
  6. public class Student {  
  7.     private int id;  
  8.       
  9.     @Expose  
  10.     private String name;  
  11.       
  12.     @Expose  
  13.     @SerializedName(“bir”)  
  14.     private Date birthDay;  
  15.   
  16.     public int getId() {  
  17.         return id;  
  18.     }  
  19.   
  20.     public void setId(int id) {  
  21.         this.id = id;  
  22.     }  
  23.   
  24.     public String getName() {  
  25.         return name;  
  26.     }  
  27.   
  28.     public void setName(String name) {  
  29.         this.name = name;  
  30.     }  
  31.   
  32.     public Date getBirthDay() {  
  33.         return birthDay;  
  34.     }  
  35.   
  36.     public void setBirthDay(Date birthDay) {  
  37.         this.birthDay = birthDay;  
  38.     }  
  39.   
  40.     @Override  
  41.     public String toString() {  
  42.         return “Student [birthDay=” + birthDay + “, id=” + id + “, name=”  
  43.                 + name + “]”;  
  44.     }  
  45.   
  46. }  

测试类:

[java] view plaincopy

  1. import java.util.ArrayList;  
  2. import java.util.Date;  
  3. import java.util.List;  
  4.   
  5. import com.google.gson.FieldNamingPolicy;  
  6. import com.google.gson.Gson;  
  7. import com.google.gson.GsonBuilder;  
  8. import com.google.gson.reflect.TypeToken;  
  9.   
  10. public class GsonTest2 {  
  11.   
  12.     public static void main(String[] args) {  
  13.         //注意这里的Gson的构建方式为GsonBuilder,区别于test1中的Gson gson = new Gson();  
  14.         Gson gson = new GsonBuilder()  
  15.         .excludeFieldsWithoutExposeAnnotation() //不导出实体中没有用@Expose注解的属性  
  16.         .enableComplexMapKeySerialization() //支持Map的key为复杂对象的形式  
  17.         .serializeNulls().setDateFormat(“yyyy-MM-dd HH:mm:ss:SSS”)//时间转化为特定格式    
  18.         .setFieldNamingPolicy(FieldNamingPolicy.UPPER_CAMEL_CASE)//会把字段首字母大写,注:对于实体上使用了@SerializedName注解的不会生效.  
  19.         .setPrettyPrinting() //对json结果格式化.  
  20.         .setVersion(1.0)    //有的字段不是一开始就有的,会随着版本的升级添加进来,那么在进行序列化和返序列化的时候就会根据版本号来选择是否要序列化.  
  21.                             //@Since(版本号)能完美地实现这个功能.还的字段可能,随着版本的升级而删除,那么  
  22.                             //@Until(版本号)也能实现这个功能,GsonBuilder.setVersion(double)方法需要调用.  
  23.         .create();  
  24.           
  25.           
  26.   
  27.         Student student1 = new Student();  
  28.         student1.setId(1);  
  29.         student1.setName(“李坤”);  
  30.         student1.setBirthDay(new Date());  
  31.   
  32.         // //////////////////////////////////////////////////////////  
  33.         System.out.println(“———-简单对象之间的转化————-“);  
  34.         // 简单的bean转为json  
  35.         String s1 = gson.toJson(student1);  
  36.         System.out.println(“简单Bean转化为Json===” + s1);  
  37.   
  38.         // json转为简单Bean  
  39.         Student student = gson.fromJson(s1, Student.class);  
  40.         System.out.println(“Json转为简单Bean===” + student);  
  41.         // //////////////////////////////////////////////////////////  
  42.   
  43.         Student student2 = new Student();  
  44.         student2.setId(2);  
  45.         student2.setName(“曹贵生”);  
  46.         student2.setBirthDay(new Date());  
  47.   
  48.         Student student3 = new Student();  
  49.         student3.setId(3);  
  50.         student3.setName(“柳波”);  
  51.         student3.setBirthDay(new Date());  
  52.   
  53.         List<Student> list = new ArrayList<Student>();  
  54.         list.add(student1);  
  55.         list.add(student2);  
  56.         list.add(student3);  
  57.   
  58.         System.out.println(“———-带泛型的List之间的转化————-“);  
  59.         // 带泛型的list转化为json  
  60.         String s2 = gson.toJson(list);  
  61.         System.out.println(“带泛型的list转化为json==” + s2);  
  62.   
  63.         // json转为带泛型的list  
  64.         List<Student> retList = gson.fromJson(s2,  
  65.                 new TypeToken<List<Student>>() {  
  66.                 }.getType());  
  67.         for (Student stu : retList) {  
  68.             System.out.println(stu);  
  69.         }  
  70.           
  71.     }  
  72. }  

输出结果:

[plain] view plaincopy

  1. ———-简单对象之间的转化————-  
  2. 简单Bean转化为Json==={  
  3.   “Name”: “李坤”,  
  4.   “bir”: “2012-06-22 21:26:40:592”  
  5. }  
  6. Json转为简单Bean===Student [birthDay=Fri Jun 22 21:26:40 CST 2012, id=0, name=李坤]  
  7. ———-带泛型的List之间的转化————-  
  8. 带泛型的list转化为json==[  
  9.   {  
  10.     “Name”: “李坤”,  
  11.     “bir”: “2012-06-22 21:26:40:592”  
  12.   },  
  13.   {  
  14.     “Name”: “曹贵生”,  
  15.     “bir”: “2012-06-22 21:26:40:625”  
  16.   },  
  17.   {  
  18.     “Name”: “柳波”,  
  19.     “bir”: “2012-06-22 21:26:40:625”  
  20.   }  
  21. ]  
  22. Student [birthDay=Fri Jun 22 21:26:40 CST 2012, id=0, name=李坤]  
  23. Student [birthDay=Fri Jun 22 21:26:40 CST 2012, id=0, name=曹贵生]  
  24. Student [birthDay=Fri Jun 22 21:26:40 CST 2012, id=0, name=柳波]  

 

Json转换利器Gson之实例三-Map处理

Map的存储结构式Key/Value形式,Key 和 Value可以是普通类型,也可以是自己写的JavaBean(本文),还可以是带有泛型的List(下一篇博客).本例中您要重点看如何将Json转回为普通JavaBean对象时TypeToken的定义.

实体类:

[java] view plaincopy

  1. public class Point {  
  2.     private int x;  
  3.     private int y;  
  4.   
  5.     public Point(int x, int y) {  
  6.         this.x = x;  
  7.         this.y = y;  
  8.     }  
  9.   
  10.     public int getX() {  
  11.         return x;  
  12.     }  
  13.   
  14.     public void setX(int x) {  
  15.         this.x = x;  
  16.     }  
  17.   
  18.     public int getY() {  
  19.         return y;  
  20.     }  
  21.   
  22.     public void setY(int y) {  
  23.         this.y = y;  
  24.     }  
  25.   
  26.     @Override  
  27.     public String toString() {  
  28.         return “Point [x=” + x + “, y=” + y + “]”;  
  29.     }  
  30.   
  31. }  

测试类:

[java] view plaincopy

  1. import java.util.LinkedHashMap;  
  2. import java.util.Map;  
  3.   
  4. import com.google.gson.Gson;  
  5. import com.google.gson.GsonBuilder;  
  6. import com.google.gson.reflect.TypeToken;  
  7.   
  8. public class GsonTest3 {  
  9.   
  10.     public static void main(String[] args) {  
  11.         Gson gson = new GsonBuilder().enableComplexMapKeySerialization()  
  12.                 .create();  
  13.   
  14.         Map<Point, String> map1 = new LinkedHashMap<Point, String>();// 使用LinkedHashMap将结果按先进先出顺序排列  
  15.         map1.put(new Point(56), “a”);  
  16.         map1.put(new Point(88), “b”);  
  17.         String s = gson.toJson(map1);  
  18.         System.out.println(s);// 结果:[[{“x”:5,”y”:6},”a”],[{“x”:8,”y”:8},”b”]]  
  19.   
  20.         Map<Point, String> retMap = gson.fromJson(s,  
  21.                 new TypeToken<Map<Point, String>>() {  
  22.                 }.getType());  
  23.         for (Point p : retMap.keySet()) {  
  24.             System.out.println(“key:” + p + ” values:” + retMap.get(p));  
  25.         }  
  26.         System.out.println(retMap);  
  27.   
  28.         System.out.println(“———————————-“);  
  29.         Map<String, Point> map2 = new LinkedHashMap<String, Point>();  
  30.         map2.put(“a”new Point(34));  
  31.         map2.put(“b”new Point(56));  
  32.         String s2 = gson.toJson(map2);  
  33.         System.out.println(s2);  
  34.   
  35.         Map<String, Point> retMap2 = gson.fromJson(s2,  
  36.                 new TypeToken<Map<String, Point>>() {  
  37.                 }.getType());  
  38.         for (String key : retMap2.keySet()) {  
  39.             System.out.println(“key:” + key + ” values:” + retMap2.get(key));  
  40.         }  
  41.   
  42.     }  
  43. }  

结果:

[plain] view plaincopy

  1. [[{“x”:5,”y”:6},”a”],[{“x”:8,”y”:8},”b”]]  
  2. key:Point [x=5, y=6] values:a  
  3. key:Point [x=8, y=8] values:b  
  4. {Point [x=5, y=6]=a, Point [x=8, y=8]=b}  
  5. ———————————-  
  6. {“a”:{“x”:3,”y”:4},”b”:{“x”:5,”y”:6}}  
  7. key:a values:Point [x=3, y=4]  
  8. key:b values:Point [x=5, y=6]  

Map的存储结构式Key/Value形式,Key 和 Value可以是普通类型,也可以是自己写的JavaBean,还可以是带有泛型的List(本文).本例中您要重点看如何将Json转回为带泛型的对象List,并且List中的泛型对象有多种实体.

实体类:

[java] view plaincopy

  1. import java.util.Date;  
  2.   
  3. public class Student {  
  4.     private int id;  
  5.     private String name;  
  6.     private Date birthDay;  
  7.   
  8.     public int getId() {  
  9.         return id;  
  10.     }  
  11.   
  12.     public void setId(int id) {  
  13.         this.id = id;  
  14.     }  
  15.   
  16.     public String getName() {  
  17.         return name;  
  18.     }  
  19.   
  20.     public void setName(String name) {  
  21.         this.name = name;  
  22.     }  
  23.   
  24.     public Date getBirthDay() {  
  25.         return birthDay;  
  26.     }  
  27.   
  28.     public void setBirthDay(Date birthDay) {  
  29.         this.birthDay = birthDay;  
  30.     }  
  31.   
  32.     @Override  
  33.     public String toString() {  
  34.         return “Student [birthDay=” + birthDay + “, id=” + id + “, name=”  
  35.                 + name + “]”;  
  36.     }  
  37.   
  38. }  

[java] view plaincopy

  1. public class Teacher {  
  2.     private int id;  
  3.   
  4.     private String name;  
  5.   
  6.     private String title;  
  7.   
  8.     public int getId() {  
  9.         return id;  
  10.     }  
  11.   
  12.     public void setId(int id) {  
  13.         this.id = id;  
  14.     }  
  15.   
  16.     public String getName() {  
  17.         return name;  
  18.     }  
  19.   
  20.     public void setName(String name) {  
  21.         this.name = name;  
  22.     }  
  23.   
  24.     public String getTitle() {  
  25.         return title;  
  26.     }  
  27.   
  28.     public void setTitle(String title) {  
  29.         this.title = title;  
  30.     }  
  31.   
  32.     @Override  
  33.     public String toString() {  
  34.         return “Teacher [id=” + id + “, name=” + name + “, title=” + title  
  35.                 + “]”;  
  36.     }  
  37.   
  38. }  

测试类:

[java] view plaincopy

  1. package com.tgb.lk.demo.gson.test4;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.Date;  
  5. import java.util.LinkedHashMap;  
  6. import java.util.List;  
  7. import java.util.Map;  
  8.   
  9. import com.google.gson.Gson;  
  10. import com.google.gson.reflect.TypeToken;  
  11.   
  12. public class GsonTest4 {  
  13.     public static void main(String[] args) {  
  14.         Student student1 = new Student();  
  15.         student1.setId(1);  
  16.         student1.setName(“李坤”);  
  17.         student1.setBirthDay(new Date());  
  18.   
  19.         Student student2 = new Student();  
  20.         student2.setId(2);  
  21.         student2.setName(“曹贵生”);  
  22.         student2.setBirthDay(new Date());  
  23.   
  24.         Student student3 = new Student();  
  25.         student3.setId(3);  
  26.         student3.setName(“柳波”);  
  27.         student3.setBirthDay(new Date());  
  28.   
  29.         List<Student> stulist = new ArrayList<Student>();  
  30.         stulist.add(student1);  
  31.         stulist.add(student2);  
  32.         stulist.add(student3);  
  33.   
  34.         Teacher teacher1 = new Teacher();  
  35.         teacher1.setId(1);  
  36.         teacher1.setName(“米老师”);  
  37.         teacher1.setTitle(“教授”);  
  38.   
  39.         Teacher teacher2 = new Teacher();  
  40.         teacher2.setId(2);  
  41.         teacher2.setName(“丁老师”);  
  42.         teacher2.setTitle(“讲师”);  
  43.         List<Teacher> teacherList = new ArrayList<Teacher>();  
  44.         teacherList.add(teacher1);  
  45.         teacherList.add(teacher2);  
  46.   
  47.         Map<String, Object> map = new LinkedHashMap<String, Object>();  
  48.         map.put(“students”, stulist);  
  49.         map.put(“teachers”, teacherList);  
  50.   
  51.         Gson gson = new Gson();  
  52.         String s = gson.toJson(map);  
  53.         System.out.println(s);  
  54.   
  55.         System.out.println(“———————————-“);  
  56.   
  57.         Map<String, Object> retMap = gson.fromJson(s,  
  58.                 new TypeToken<Map<String, List<Object>>>() {  
  59.                 }.getType());  
  60.   
  61.         for (String key : retMap.keySet()) {  
  62.             System.out.println(“key:” + key + ” values:” + retMap.get(key));  
  63.             if (key.equals(“students”)) {  
  64.                 List<Student> stuList = (List<Student>) retMap.get(key);  
  65.                 System.out.println(stuList);  
  66.             } else if (key.equals(“teachers”)) {  
  67.                 List<Teacher> tchrList = (List<Teacher>) retMap.get(key);  
  68.                 System.out.println(tchrList);  
  69.             }  
  70.         }  
  71.   
  72.     }  
  73. }  

输出结果:

[plain] view plaincopy

  1. {“students”:[{“id”:1,”name”:”李坤”,”birthDay”:”Jun 22, 2012 9:48:19 PM”},{“id”:2,”name”:”曹贵生”,”birthDay”:”Jun 22, 2012 9:48:19 PM”},{“id”:3,”name”:”柳波”,”birthDay”:”Jun 22, 2012 9:48:19 PM”}],”teachers”:[{“id”:1,”name”:”米老师”,”title”:”教授”},{“id”:2,”name”:”丁老师”,”title”:”讲师”}]}  
  2. ———————————-  
  3. key:students values:[{id=1.0, name=李坤, birthDay=Jun 22, 2012 9:48:19 PM}, {id=2.0, name=曹贵生, birthDay=Jun 22, 2012 9:48:19 PM}, {id=3.0, name=柳波, birthDay=Jun 22, 2012 9:48:19 PM}]  
  4. [{id=1.0, name=李坤, birthDay=Jun 22, 2012 9:48:19 PM}, {id=2.0, name=曹贵生, birthDay=Jun 22, 2012 9:48:19 PM}, {id=3.0, name=柳波, birthDay=Jun 22, 2012 9:48:19 PM}]  
  5. key:teachers values:[{id=1.0, name=米老师, title=教授}, {id=2.0, name=丁老师, title=讲师}]  
  6. [{id=1.0, name=米老师, title=教授}, {id=2.0, name=丁老师, title=讲师}]  

 

Json转换利器Gson之实例-实际开发中的特殊需求处理

前面博客基本上可以满足我们处理的绝大多数需求,但有时项目中对json有特殊的格式规定.比如下面的json串解析:

[{“tableName”:”students”,”tableData”:[{“id”:1,”name”:”李坤”,”birthDay”:”Jun 22, 2012 9:54:49 PM”},{“id”:2,”name”:”曹贵生”,”birthDay”:”Jun 22, 2012 9:54:49 PM”},{“id”:3,”name”:”柳波”,”birthDay”:”Jun 22, 2012 9:54:49 PM”}]},{“tableName”:”teachers”,”tableData”:[{“id”:1,”name”:”米老师”,”title”:”教授”},{“id”:2,”name”:”丁老师”,”title”:”讲师”}]}]

分析之后我们发现使用前面博客中用到的都不好处理上面的json串.请看本文是如何处理的吧:

实体类:

[java] view plaincopy

  1. import java.util.Date;  
  2.   
  3. public class Student {  
  4.     private int id;  
  5.     private String name;  
  6.     private Date birthDay;  
  7.   
  8.     public int getId() {  
  9.         return id;  
  10.     }  
  11.   
  12.     public void setId(int id) {  
  13.         this.id = id;  
  14.     }  
  15.   
  16.     public String getName() {  
  17.         return name;  
  18.     }  
  19.   
  20.     public void setName(String name) {  
  21.         this.name = name;  
  22.     }  
  23.   
  24.     public Date getBirthDay() {  
  25.         return birthDay;  
  26.     }  
  27.   
  28.     public void setBirthDay(Date birthDay) {  
  29.         this.birthDay = birthDay;  
  30.     }  
  31.   
  32.     @Override  
  33.     public String toString() {  
  34.         return “Student [birthDay=” + birthDay + “, id=” + id + “, name=”  
  35.                 + name + “]”;  
  36.     }  
  37.   
  38. }  

[java] view plaincopy

  1. public class Teacher {  
  2.     private int id;  
  3.   
  4.     private String name;  
  5.   
  6.     private String title;  
  7.   
  8.     public int getId() {  
  9.         return id;  
  10.     }  
  11.   
  12.     public void setId(int id) {  
  13.         this.id = id;  
  14.     }  
  15.   
  16.     public String getName() {  
  17.         return name;  
  18.     }  
  19.   
  20.     public void setName(String name) {  
  21.         this.name = name;  
  22.     }  
  23.   
  24.     public String getTitle() {  
  25.         return title;  
  26.     }  
  27.   
  28.     public void setTitle(String title) {  
  29.         this.title = title;  
  30.     }  
  31.   
  32.     @Override  
  33.     public String toString() {  
  34.         return “Teacher [id=” + id + “, name=” + name + “, title=” + title  
  35.                 + “]”;  
  36.     }  
  37.   
  38. }  

注意这里定义了一个TableData实体类:

[java] view plaincopy

  1. import java.util.List;  
  2.   
  3. public class TableData {  
  4.   
  5.     private String tableName;  
  6.   
  7.     private List tableData;  
  8.   
  9.     public String getTableName() {  
  10.         return tableName;  
  11.     }  
  12.   
  13.     public void setTableName(String tableName) {  
  14.         this.tableName = tableName;  
  15.     }  
  16.   
  17.     public List getTableData() {  
  18.         return tableData;  
  19.     }  
  20.   
  21.     public void setTableData(List tableData) {  
  22.         this.tableData = tableData;  
  23.     }  
  24. }  

测试类:

(仔细看将json转回为对象的实现,这里经过两次转化,第一次转回的结果是map不是我们所期望的对象,对map再次转为json后再转为对象,我引用的是Gson2.1的jar处理正常,好像使用Gson1.6的jar会报错,所以建议用最新版本)

[java] view plaincopy

  1. import java.util.ArrayList;  
  2. import java.util.Date;  
  3. import java.util.List;  
  4.   
  5. import com.google.gson.Gson;  
  6. import com.google.gson.reflect.TypeToken;  
  7.   
  8. public class GsonTest5 {  
  9.   
  10.     /** 
  11.      * @param args 
  12.      */  
  13.     public static void main(String[] args) {  
  14.         // 对象转为Json–>start  
  15.         Student student1 = new Student();  
  16.         student1.setId(1);  
  17.         student1.setName(“李坤”);  
  18.         student1.setBirthDay(new Date());  
  19.   
  20.         Student student2 = new Student();  
  21.         student2.setId(2);  
  22.         student2.setName(“曹贵生”);  
  23.         student2.setBirthDay(new Date());  
  24.   
  25.         Student student3 = new Student();  
  26.         student3.setId(3);  
  27.         student3.setName(“柳波”);  
  28.         student3.setBirthDay(new Date());  
  29.   
  30.         List<Student> stulist = new ArrayList<Student>();  
  31.         stulist.add(student1);  
  32.         stulist.add(student2);  
  33.         stulist.add(student3);  
  34.   
  35.         Teacher teacher1 = new Teacher();  
  36.         teacher1.setId(1);  
  37.         teacher1.setName(“米老师”);  
  38.         teacher1.setTitle(“教授”);  
  39.   
  40.         Teacher teacher2 = new Teacher();  
  41.         teacher2.setId(2);  
  42.         teacher2.setName(“丁老师”);  
  43.         teacher2.setTitle(“讲师”);  
  44.         List<Teacher> teacherList = new ArrayList<Teacher>();  
  45.         teacherList.add(teacher1);  
  46.         teacherList.add(teacher2);  
  47.   
  48.         TableData td1 = new TableData();  
  49.         td1.setTableName(“students”);  
  50.         td1.setTableData(stulist);  
  51.   
  52.         TableData td2 = new TableData();  
  53.         td2.setTableName(“teachers”);  
  54.         td2.setTableData(teacherList);  
  55.   
  56.         List<TableData> tdList = new ArrayList<TableData>();  
  57.         tdList.add(td1);  
  58.         tdList.add(td2);  
  59.         Gson gson = new Gson();  
  60.         String s = gson.toJson(tdList);  
  61.   
  62.         System.out.println(s);  
  63.         // 结果:[{“tableName”:”students”,”tableData”:[{“id”:1,”name”:”李坤”,”birthDay”:”Jun 22, 2012 10:44:16 AM”},{“id”:2,”name”:”曹贵生”,”birthDay”:”Jun 22, 2012 10:44:16 AM”},{“id”:3,”name”:”柳波”,”birthDay”:”Jun 22, 2012 10:44:16 AM”}]},{“tableName”:”teachers”,”tableData”:[{“id”:1,”name”:”米老师”,”title”:”教授”},{“id”:2,”name”:”丁老师”,”title”:”讲师”}]}]  
  64.         // 对象转为Json–>end  
  65.   
  66.         // /////////////////////////////////////////////////////////////////////  
  67.   
  68.         // 将json转为数据–>start  
  69.         List<TableData> tableDatas2 = gson.fromJson(s,  
  70.                 new TypeToken<List<TableData>>() {  
  71.                 }.getType());  
  72.         for (int i = 0; i < tableDatas2.size(); i++) {  
  73.             TableData entityData = tableDatas2.get(i);  
  74.             String tableName = entityData.getTableName();  
  75.             List tableData = entityData.getTableData();  
  76.             String s2 = gson.toJson(tableData);  
  77.             // System.out.println(s2);  
  78.             // System.out.println(entityData.getData());  
  79.             if (tableName.equals(“students”)) {  
  80.                 System.out.println(“students”);  
  81.                 List<Student> retStuList = gson.fromJson(s2,  
  82.                         new TypeToken<List<Student>>() {  
  83.                         }.getType());  
  84.                 for (int j = 0; j < retStuList.size(); j++) {  
  85.                     System.out.println(retStuList.get(j));  
  86.                 }  
  87.   
  88.             } else if (tableName.equals(“teachers”)) {  
  89.                 System.out.println(“teachers”);  
  90.                 List<Teacher> retTchrList = gson.fromJson(s2,  
  91.                         new TypeToken<List<Teacher>>() {  
  92.                         }.getType());  
  93.                 for (int j = 0; j < retTchrList.size(); j++) {  
  94.                     System.out.println(retTchrList.get(j));  
  95.                 }  
  96.             }  
  97.         }  
  98.   
  99.         // Json转为对象–>end  
  100.     }  
  101. }  

输出结果:

[plain] view plaincopy

  1. [{“tableName”:”students”,”tableData”:[{“id”:1,”name”:”李坤”,”birthDay”:”Jun 22, 2012 10:04:12 PM”},{“id”:2,”name”:”曹贵生”,”birthDay”:”Jun 22, 2012 10:04:12 PM”},{“id”:3,”name”:”柳波”,”birthDay”:”Jun 22, 2012 10:04:12 PM”}]},{“tableName”:”teachers”,”tableData”:[{“id”:1,”name”:”米老师”,”title”:”教授”},{“id”:2,”name”:”丁老师”,”title”:”讲师”}]}]  
  2. students  
  3. Student [birthDay=Fri Jun 22 22:04:12 CST 2012, id=1, name=李坤]  
  4. Student [birthDay=Fri Jun 22 22:04:12 CST 2012, id=2, name=曹贵生]  
  5. Student [birthDay=Fri Jun 22 22:04:12 CST 2012, id=3, name=柳波]  
  6. teachers  
  7. Teacher [id=1, name=米老师, title=教授]  
  8. Teacher [id=2, name=丁老师, title=讲师]  

Json转换利器Gson之实例六-注册TypeAdapter及处理Enum类型

枚举类型给我们的程序带来了好处,如何用Gson来实现与Json的互转呢?请看本文.

本文重点掌握如何自己写一个TypeAdapter及注册TypeAdapter和处理Enum类型.

实体类:

[java] view plaincopy

  1. public enum PackageState {  
  2.     PLAY, UPDATE, UPDATING, DOWNLOAD, DOWNLOADING,  
  3. }  

[java] view plaincopy

  1. public class PackageItem {  
  2.     private String name;  
  3.     private PackageState state;  
  4.     private String size;  
  5.   
  6.     public String getName() {  
  7.         return name;  
  8.     }  
  9.   
  10.     public void setName(String name) {  
  11.         this.name = name;  
  12.     }  
  13.   
  14.     public PackageState getState() {  
  15.         return state;  
  16.     }  
  17.   
  18.     public void setState(PackageState state) {  
  19.         this.state = state;  
  20.     }  
  21.   
  22.     public String getSize() {  
  23.         return size;  
  24.     }  
  25.   
  26.     public void setSize(String size) {  
  27.         this.size = size;  
  28.     }  
  29.   
  30.     @Override  
  31.     public String toString() {  
  32.         return “PackageItem [name=” + name + “, size=” + size + “, state=”  
  33.                 + state + “]”;  
  34.     }  
  35. }  

自己写一个转换器实现JsonSerializer<T>接口和jsonDeserializer<T>接口:

[java] view plaincopy

  1. mport java.lang.reflect.Type;  
  2.   
  3. import com.google.gson.JsonDeserializationContext;  
  4. import com.google.gson.JsonDeserializer;  
  5. import com.google.gson.JsonElement;  
  6. import com.google.gson.JsonParseException;  
  7. import com.google.gson.JsonPrimitive;  
  8. import com.google.gson.JsonSerializationContext;  
  9. import com.google.gson.JsonSerializer;  
  10.   
  11. public class EnumSerializer implements JsonSerializer<PackageState>,  
  12.         JsonDeserializer<PackageState> {  
  13.   
  14.     // 对象转为Json时调用,实现JsonSerializer<PackageState>接口  
  15.     @Override  
  16.     public JsonElement serialize(PackageState state, Type arg1,  
  17.             JsonSerializationContext arg2) {  
  18.         return new JsonPrimitive(state.ordinal());  
  19.     }  
  20.   
  21.     // json转为对象时调用,实现JsonDeserializer<PackageState>接口  
  22.     @Override  
  23.     public PackageState deserialize(JsonElement json, Type typeOfT,  
  24.             JsonDeserializationContext context) throws JsonParseException {  
  25.         if (json.getAsInt() < PackageState.values().length)  
  26.             return PackageState.values()[json.getAsInt()];  
  27.         return null;  
  28.     }  
  29.   
  30. }  

测试类:

[java] view plaincopy

  1. import com.google.gson.Gson;  
  2. import com.google.gson.GsonBuilder;  
  3.   
  4. public class GsonTest6 {  
  5.   
  6.     public static void main(String[] args) {  
  7.         GsonBuilder gsonBuilder = new GsonBuilder();  
  8.         gsonBuilder.registerTypeAdapter(PackageState.class,  
  9.                 new EnumSerializer());  
  10.         Gson gson = gsonBuilder.create();  
  11.         PackageItem item = new PackageItem();  
  12.         item.setName(“item_name”);  
  13.         item.setSize(“500M”);  
  14.         item.setState(PackageState.UPDATING);// 这个 state是枚举值  
  15.   
  16.         String s = gson.toJson(item);  
  17.         System.out.println(s);  
  18.   
  19.         System.out.println(“——————————–“);  
  20.   
  21.         PackageItem retItem = gson.fromJson(s, PackageItem.class);  
  22.         System.out.println(retItem);  
  23.     }  
  24. }  


输出结果(结果中已经将state的对应枚举类型转为了int类型):

[plain] view plaincopy

  1. {“name”:”item_name”,”state”:2,”size”:”500M”}  
  2. ——————————–  
  3. PackageItem [name=item_name, size=500M, state=UPDATING]  

4月 172014
 

在使用Spring的JdbcTemplate实现DAO的时候,经常会用到一个类ParameterizedBeanPropertyRowMapper。它的静态方法newInstance()接受一个Class类型的参数,用于将ResultSet中的属性映射到传入的这个Class类型的Bean对象中,再组成列表返回。

 

如果要想把这个DAO做成泛型的,就必须要知道Class的类型。但是直接写成T.class显然是不行的。从网上查了不少资料,结果只有一个,由于Java的泛型实现使用了“擦拭法”(具体细节没深究,呵呵),导致Java的泛型不能直接获取到自身的声明的泛型类型。

 

不过从江南白衣的blog文章里搜到了有用的东西:使用反射来获得“T.class”。

原文地址:http://www.blogjava.net/calvin/archive/2009/12/10/43830.html

 

主要用到的是这么一句:

[c-sharp] view plaincopy

  1. Class <T> entityClass = (Class <T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];   

 

我查询了Java API,在Class类中有这么两个方法: getGenericInterfaces()和getGenericSuperclass()

 

先来看看这两个方法都是干什么用的:

 

1. public Type getGenericSuperclass()

用来返回表示当前Class 所表示的实体(类、接口、基本类型或 void)的直接超类的Type。如果这个直接超类是参数化类型的,则返回的Type对象必须明确反映在源代码中声明时使用的类型。比如:

[java] view plaincopy

  1. package com.mot.hyena.test;  
  2. import java.lang.reflect.ParameterizedType;  
  3. public class GT1 extends GT2<Integer>{  
  4.     public static void main(String[] args) {  
  5.         System.out.println(((ParameterizedType)new GT1().getClass().getGenericSuperclass()));  
  6.     }  
  7. }  

则输出结果即为:com.mot.hyena.test.GT2<java.lang.Integer>

 

如果此Class代表的是Object 类、接口、基本类型或 void,则返回 null。。如果此对象表示一个数组类,则返回表示 Object 类的 Class 对象。

 

2. public Type[] getGenericInterfaces()

与上面那个方法类似,只不过Java的类可以实现多个接口,所以返回的Type必须用数组来存储。

 

 

以上两个方法返回的都是Type对象或数组,在我们的这个话题中,Class都是代表的参数化类型,因此可以将Type对象Cast成ParameterizedType对象。而 ParameterizedType对象有一个方法, getActualTypeArguments()。

public Type[] getActualTypeArguments()

用来返回一个Type对象数组,这个数组代表着这个Type声明中实际使用的类型。接着使用上面的例子:

[java] view plaincopy

  1. package com.mot.hyena.test;  
  2. import java.lang.reflect.ParameterizedType;  
  3. public class GT1 extends GT2<Integer>{  
  4.     public static void main(String[] args) {  
  5.     System.out.println(((ParameterizedType)new GT1().getClass().getGenericSuperclass()).getActualTypeArguments()[0]);  
  6.     }  
  7. }  

这次的显示结果将是:class java.lang.Integer

 

因此,我们可以通过继承+反射的方法,来的到T.class。

 

需要说明的是,江南白衣使用的方法是将关键语句

Class < T >  entityClass  =  (Class < T > ) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[ 0 ];

放在了超类,也就是声明泛型的那个类的构造方法中。这样一来,子类在继承具有泛型的超类时,会自动调用超类的构造方法。在此超类的构造方法中,调用的getClass返回的是子类的Class类型(与通常的重写机制有悖,呵呵,有待深究,但测试结果确是如此),则在子类中就无需再显式地使用getGenericInterfaces()和getGenericSuperclass()等方法了。

 

接着,再使用(Class<T>)对 getActualTypeArguments()返回的元素做casting,即可得到所谓的T.class。

转自:http://blog.csdn.net/gengv/article/details/5178055

3月 202014
 

泛型是什么意思在这就不多说了,而Java中泛型类的定义也比较简单,例如:public class Test<T>{}。这样就定义了一个泛型类Test,在实例化该类时,必须指明泛型T的具体类型,例如:Test<Object> t = new Test<Object>();,指明泛型T的类型为Object。

       但是Java中的泛型方法就比较复杂了。

       泛型类,是在实例化类的时候指明泛型的具体类型;泛型方法,是在调用方法的时候指明泛型的具体类型。

 

       定义泛型方法语法格式如下:

      

       调用泛型方法语法格式如下:

 

       说明一下,定义泛型方法时,必须在返回值前边加一个<T>,来声明这是一个泛型方法,持有一个泛型T,然后才可以用泛型T作为方法的返回值。

       Class<T>的作用就是指明泛型的具体类型,而Class<T>类型的变量c,可以用来创建泛型类的对象。

       为什么要用变量c来创建对象呢?既然是泛型方法,就代表着我们不知道具体的类型是什么,也不知道构造方法如何,因此没有办法去new一个对象,但可以利用变量c的newInstance方法去创建对象,也就是利用反射创建对象。

       泛型方法要求的参数是Class<T>类型,而Class.forName()方法的返回值也是Class<T>,因此可以用Class.forName()作为参数。其中,forName()方法中的参数是何种类型,返回的Class<T>就是何种类型。在本例中,forName()方法中传入的是User类的完整路径,因此返回的是Class<User>类型的对象,因此调用泛型方法时,变量c的类型就是Class<User>,因此泛型方法中的泛型T就被指明为User,因此变量obj的类型为User。

       当然,泛型方法不是仅仅可以有一个参数Class<T>,可以根据需要添加其他参数。

       为什么要使用泛型方法呢?因为泛型类要在实例化的时候就指明类型,如果想换一种类型,不得不重新new一次,可能不够灵活;而泛型方法可以在调用的时候指明类型,更加灵活。

转自:http://www.cnblogs.com/iyangyuan/archive/2013/04/09/3011274.html

Java泛型简明教程(转)

 java  Java泛型简明教程(转)已关闭评论
3月 292013
 

泛型是Java SE 5.0中引入的一项特征,自从这项语言特征出现多年来,我相信,几乎所有的Java程序员不仅听说过,而且使用过它。关于Java泛型的教程,免费的,不免费的,有很多。我遇到的最好的教材有:

尽管有这么多丰富的资料,有时我感觉,有很多的程序员仍然不太明白Java泛型的功用和意义。这就是为什么我想使用一种最简单的形式来总结一下程序员需要知道的关于Java泛型的最基本的知识。

Java泛型由来的动机

理解Java泛型最简单的方法是把它看成一种便捷语法,能节省你某些Java类型转换(casting)上的操作:

1 List<Apple> box = ...;
2 Apple apple = box.get(0);

上面的代码自身已表达的很清楚:box是一个装有Apple对象的List。get方法返回一个Apple对象实例,这个过程不需要进行类型转换。没有泛型,上面的代码需要写成这样:

1 List box = ...;
2 Apple apple = (Apple) box.get(0);

很明显,泛型的主要好处就是让编译器保留参数的类型信息,执行类型检查,执行类型转换操作:编译器保证了这些类型转换的绝对无误。

相对于依赖程序员来记住对象类型、执行类型转换——这会导致程序运行时的失败,很难调试和解决,而编译器能够帮助程序员在编译时强制进行大量的类型检查,发现其中的错误。

泛型的构成

由泛型的构成引出了一个类型变量的概念。根据Java语言规范,类型变量是一种没有限制的标志符,产生于以下几种情况:

  • 泛型类声明
  • 泛型接口声明
  • 泛型方法声明
  • 泛型构造器(constructor)声明

 

泛型类和接口

如果一个类或接口上有一个或多个类型变量,那它就是泛型。类型变量由尖括号界定,放在类或接口名的后面:

1 public interface List<T> extends Collection<T> {
2 ...
3 }

简单的说,类型变量扮演的角色就如同一个参数,它提供给编译器用来类型检查的信息。

Java类库里的很多类,例如整个Collection框架都做了泛型化的修改。例如,我们在上面的第一段代码里用到的List接口就是一个泛型类。在那段代码里,box是一个List<Apple>对象,它是一个带有一个Apple类型变量的List接口的类实现的实例。编译器使用这个类型变量参数在get方法被调用、返回一个Apple对象时自动对其进行类型转换。

实际上,这新出现的泛型标记,或者说这个List接口里的get方法是这样的:

1 T get(int index);

get方法实际返回的是一个类型为T的对象,T是在List<T>声明中的类型变量。

泛型方法和构造器(Constructor)

非常的相似,如果方法和构造器上声明了一个或多个类型变量,它们也可以泛型化。

1 public static <t> T getFirst(List<T> list)

这个方法将会接受一个List<T>类型的参数,返回一个T类型的对象。

例子

你既可以使用Java类库里提供的泛型类,也可以使用自己的泛型类。

类型安全的写入数据…

下面的这段代码是个例子,我们创建了一个List<String>实例,然后装入一些数据:

1 List<String> str = new ArrayList<String>();
2 str.add("Hello ");
3 str.add("World.");

如果我们试图在List<String>装入另外一种对象,编译器就会提示错误:

1 str.add(1); // 不能编译

类型安全的读取数据…

当我们在使用List<String>对象时,它总能保证我们得到的是一个String对象:

1 String myString = str.get(0);

遍历

类库中的很多类,诸如Iterator<T>,功能都有所增强,被泛型化。List<T>接口里的iterator()方法现在返回的是Iterator<T>,由它的T next()方法返回的对象不需要再进行类型转换,你直接得到正确的类型。

1 for (Iterator<String> iter = str.iterator(); iter.hasNext();) {
2 String s = iter.next();
3 System.out.print(s);
4 }

使用foreach

“for each”语法同样受益于泛型。前面的代码可以写出这样:

1 for (String s: str) {
2 System.out.print(s);
3 }

这样既容易阅读也容易维护。

自动封装(Autoboxing)和自动拆封(Autounboxing)

在使用Java泛型时,autoboxing/autounboxing这两个特征会被自动的用到,就像下面的这段代码:

1 List<Integer> ints = new ArrayList<Integer>();
2 ints.add(0);
3 ints.add(1);
4  
5 int sum = 0;
6 for (int i : ints) {
7 sum += i;
8 }

然而,你要明白的一点是,封装和解封会带来性能上的损失,所有,通用要谨慎的使用。

子类型

在Java中,跟其它具有面向对象类型的语言一样,类型的层级可以被设计成这样:
类型继承
在Java中,类型T的子类型既可以是类型T的一个扩展,也可以是类型T的一个直接或非直接实现(如果T是一个接口的话)。因为“成为某类型的子类型”是一个具有传递性质的关系,如果类型A是B的一个子类型,B是C的子类型,那么A也是C的子类型。在上面的图中:

  • FujiApple(富士苹果)是Apple的子类型
  • Apple是Fruit(水果)的子类型
  • FujiApple(富士苹果)是Fruit(水果)的子类型

所有Java类型都是Object类型的子类型。

B类型的任何一个子类型A都可以被赋给一个类型B的声明:

1 Apple a = ...;
2 Fruit f = a;

泛型类型的子类型

如果一个Apple对象的实例可以被赋给一个Fruit对象的声明,就像上面看到的,那么,List<Apple> 和 a List<Fruit>之间又是个什么关系呢?更通用些,如果类型A是类型B的子类型,那C<A> 和 C<B>之间是什么关系?

答案会出乎你的意料:没有任何关系。用更通俗的话,泛型类型跟其是否子类型没有任何关系。

这意味着下面的这段代码是无效的:

1 List<Apple> apples = ...;
2 List<Fruit> fruits = apples;

下面的同样也不允许:

1 List<Apple> apples;
2 List<Fruit> fruits = ...;
3 apples = fruits;

为什么?一个苹果是一个水果,为什么一箱苹果不能是一箱水果?

在某些事情上,这种说法可以成立,但在类型(类)封装的状态和操作上不成立。如果把一箱苹果当成一箱水果会发生什么情况?

1 List<Apple> apples = ...;
2 List<Fruit> fruits = apples;
3 fruits.add(new Strawberry());

如果可以这样的话,我们就可以在list里装入各种不同的水果子类型,这是绝对不允许的。

另外一种方式会让你有更直观的理解:一箱水果不是一箱苹果,因为它有可能是一箱另外一种水果,比如草莓(子类型)。

这是一个需要注意的问题吗?

应该不是个大问题。而程序员对此感到意外的最大原因是数组和泛型类型上用法的不一致。对于泛型类型,它们和类型的子类型之间是没什么关系的。而对于数组,它们和子类型是相关的:如果类型A是类型B的子类型,那么A[]是B[]的子类型:

1 Apple[] apples = ...;
2 Fruit[] fruits = apples;

可是稍等一下!如果我们把前面的那个议论中暴露出的问题放在这里,我们仍然能够在一个apple类型的数组中加入strawberrie(草莓)对象:

1 Apple[] apples = new Apple[1];
2 Fruit[] fruits = apples;
3 fruits[0] = new Strawberry();

这样写真的可以编译,但是在运行时抛出ArrayStoreException异常。因为数组的这特点,在存储数据的操作上,Java运行时需要检查类型的兼容性。这种检查,很显然,会带来一定的性能问题,你需要明白这一点。

重申一下,泛型使用起来更安全,能“纠正”Java数组中这种类型上的缺陷。

现在估计你会感到很奇怪,为什么在数组上会有这种类型和子类型的关系,我来给你一个《Java Generics and Collections》这本书上给出的答案:如果它们不相关,你就没有办法把一个未知类型的对象数组传入一个方法里(不经过每次都封装成Object[]),就像下面的:

1 void sort(Object[] o);

泛型出现后,数组的这个个性已经不再有使用上的必要了(下面一部分我们会谈到这个),实际上是应该避免使用。

通配符

在本文的前面的部分里已经说过了泛型类型的子类型的不相关性。但有些时候,我们希望能够像使用普通类型那样使用泛型类型:

  • 向上造型一个泛型对象的引用
  • 向下造型一个泛型对象的引用

向上造型一个泛型对象的引用

例如,假设我们有很多箱子,每个箱子里都装有不同的水果,我们需要找到一种方法能够通用的处理任何一箱水果。更通俗的说法,A是B的子类型,我们需要找到一种方法能够将C<A>类型的实例赋给一个C<B>类型的声明。

为了完成这种操作,我们需要使用带有通配符的扩展声明,就像下面的例子里那样:

1 List<Apple> apples = new ArrayList<Apple>();
2 List<? extends Fruit> fruits = apples;

“? extends”是泛型类型的子类型相关性成为现实:Apple是Fruit的子类型,List<Apple> 是 List<? extends Fruit> 的子类型。

向下造型一个泛型对象的引用

现在我来介绍另外一种通配符:? super。如果类型B是类型A的超类型(父类型),那么C<B> 是 C<? super A> 的子类型:

1 List<Fruit> fruits = new ArrayList<Fruit>();
2 List<? super Apple> = fruits;

为什么使用通配符标记能行得通?

原理现在已经很明白:我们如何利用这种新的语法结构?

? extends

让我们重新看看这第二部分使用的一个例子,其中谈到了Java数组的子类型相关性:

1 Apple[] apples = new Apple[1];
2 Fruit[] fruits = apples;
3 fruits[0] = new Strawberry();

就像我们看到的,当你往一个声明为Fruit数组的Apple对象数组里加入Strawberry对象后,代码可以编译,但在运行时抛出异常。

现在我们可以使用通配符把相关的代码转换成泛型:因为Apple是Fruit的一个子类,我们使用? extends 通配符,这样就能将一个List<Apple>对象的定义赋到一个List<? extends Fruit>的声明上:

1 List<Apple> apples = new ArrayList<Apple>();
2 List<? extends Fruit> fruits = apples;
3 fruits.add(new Strawberry());

这次,代码就编译不过去了!Java编译器会阻止你往一个Fruit list里加入strawberry。在编译时我们就能检测到错误,在运行时就不需要进行检查来确保往列表里加入不兼容的类型了。即使你往list里加入Fruit对象也不行:

1 fruits.add(new Fruit());

你没有办法做到这些。事实上你不能够往一个使用了? extends的数据结构里写入任何的值。

原因非常的简单,你可以这样想:这个? extends T 通配符告诉编译器我们在处理一个类型T的子类型,但我们不知道这个子类型究竟是什么。因为没法确定,为了保证类型安全,我们就不允许往里面加入任何这种类型的数据。另一方面,因为我们知道,不论它是什么类型,它总是类型T的子类型,当我们在读取数据时,能确保得到的数据是一个T类型的实例:

1 Fruit get = fruits.get(0);

? super

使用 ? super 通配符一般是什么情况?让我们先看看这个:

1 List<Fruit> fruits = new ArrayList<Fruit>();
2 List<? super Apple> = fruits;

我们看到fruits指向的是一个装有Apple的某种超类(supertype)的List。同样的,我们不知道究竟是什么超类,但我们知道Apple和任何Apple的子类都跟它的类型兼容。既然这个未知的类型即是Apple,也是GreenApple的超类,我们就可以写入:

1 fruits.add(new Apple());
2 fruits.add(new GreenApple());

如果我们想往里面加入Apple的超类,编译器就会警告你:

1 fruits.add(new Fruit());
2 fruits.add(new Object());

因为我们不知道它是怎样的超类,所有这样的实例就不允许加入。

从这种形式的类型里获取数据又是怎么样的呢?结果表明,你只能取出Object实例:因为我们不知道超类究竟是什么,编译器唯一能保证的只是它是个Object,因为Object是任何Java类型的超类。

存取原则和PECS法则

总结 ? extends 和 the ? super 通配符的特征,我们可以得出以下结论:

  • 如果你想从一个数据类型里获取数据,使用 ? extends 通配符
  • 如果你想把对象写入一个数据结构里,使用 ? super 通配符
  • 如果你既想存,又想取,那就别用通配符。

这就是Maurice Naftalin在他的《Java Generics and Collections》这本书中所说的存取原则,以及Joshua Bloch在他的《Effective Java》这本书中所说的PECS法则。

Bloch提醒说,这PECS是指”Producer Extends, Consumer Super”,这个更容易记忆和运用。

[英文原文:Java Generics Quick Tutorial ]
转自:http://www.aqee.net/java-generics-quick-tutorial/
 Posted by at 下午6:04  Tagged with:

JAVA 泛型 – Class

 java  JAVA 泛型 – Class已关闭评论
3月 152013
 

Class<T>

类 Class 已经泛型化了,但是很多人一开始都感觉其泛型化的方式很混乱。Class<T> 中类型参数 T 的含义是什么?事实证明它是所引用的类接口。怎么会是这样的呢?那是一个循环推理?如果不是的话,为什么这样定义它?

在以前的 JDK 中,Class.newInstance() 方法的定义返回 Object,您很可能要将该返回类型强制转换为另一种类型:

class Class { 

     Object newInstance();

 }

 

但是使用泛型,您定义 Class.newInstance() 方法具有一个更加特定的返回类型:

class Class<T> { 

     T newInstance(); 

}

 

如何创建一个 Class<T> 类型的实例?就像使用非泛型代码一样,有两种方式:调用方法 Class.forName() 或者使用类常量X.class。Class.forName() 被定义为返回 Class<?>。另一方面,类常量 X.class 被定义为具有类型 Class<X>,所以 String.class 是Class<String> 类型的。

让 Foo.class 是 Class<Foo> 类型的有什么好处?大的好处是,通过类型推理的魔力,可以提高使用反射的代码的类型安全。另外,还不需要将 Foo.class.newInstance() 强制类型转换为 Foo。

考虑一个方法,它从数据库检索一组对象,并返回 JavaBeans 对象的一个集合。您通过反射来实例化和初始化创建的对象,但是这并不意味着类型安全必须完全被抛至脑后。考虑下面这个方法:

public static<T> List<T> getRecords(Class<T> c, Selector s) {

     // Use Selector to select rows 

     List<T> list = new ArrayList<T>();

     for (/* iterate over results */) {

         T row = c.newInstance(); // use reflection to set fields from result 

         list.add(row); 

      } 

      return list; 

}

 

可以像下面这样简单地调用该方法:

List<FooRecord> l = getRecords(FooRecord.class, fooSelector);

 

编译器将会根据 FooRecord.class 是 Class<FooRecord> 类型的这一事实,推断 getRecords() 的返回类型。您使用类常量来构造新的实例并提供编译器在类型检查中要用到的类型信息。

转自:http://blog.chinaunix.net/uid-1911213-id-3085866.html