在开发Android的过程中，如果我们经常与服务器打交道，更新数据等等，那么json必然是个好的数据格式，但是有了json我们要解析它，使用原生的解析也可以，但是很不高效，所以这里介绍两种json数据解析的方式，一种是FastJSon ,这个是阿里巴巴出的，号称最快的解析速度。第二种使我们伟大的Google提供的Gson 来解析json，两个解析json都很方便，而且都很强大，在我使用中，基本上都满足了我的需求，下面简单就接受一下，我们的使用方法。

首先建立两个实体类，Student.Java 和 Teacher.java 

Student.java 和Teacher.java 的代码如下：

[java] view plain copy print ?
  1. package com.android.fastjson.bean;  
  2.   
  3. public class Student {  
  4.       
  5.     private int id;  
  6.     private String name;  
  7.     private int age;  
  8.       
  9.     /** 
  10.      * 默认的构造方法必须不能省，不然不能解析 
  11.      */  
  12.       
  13.     public Student(){  
  14.           
  15.     }  
  16.     public Student(int id,String name,int age) {  
  17.         this.id = id;  
  18.         this.name = name;  
  19.         this.age = age;  
  20.     }  
  21.   
  22.     public int getId() {  
  23.         return id;  
  24.     }  
  25.   
  26.     public void setId(int id) {  
  27.         this.id = id;  
  28.     }  
  29.   
  30.     public String getName() {  
  31.         return name;  
  32.     }  
  33.   
  34.     public void setName(String name) {  
  35.         this.name = name;  
  36.     }  
  37.   
  38.     public int getAge() {  
  39.         return age;  
  40.     }  
  41.   
  42.     public void setAge(int age) {  
  43.         this.age = age;  
  44.     }  
  45.       
  46.     @Override  
  47.     public String toString() {  
  48.         return “Student [id=” + id + “, name=” + name + “, age=” + age + “]”;  
  49.     }  
  50.       
  51. }  
package com.android.fastjson.bean;public class Student {    private int id;    private String name;    private int age;    /**     * 默认的构造方法必须不能省，不然不能解析     */    public Student(){    }    public Student(int id,String name,int age) {        this.id = id;        this.name = name;        this.age = age;    }    public int getId() {        return id;    }    public void setId(int id) {        this.id = id;    }    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;    }    @Override    public String toString() {        return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";    }}

[java] view plain copy print ?
  1. package com.android.fastjson.bean;  
  2.   
  3. import java.util.List;  
  4.   
  5. public class Teacher {  
  6.       
  7.     private int id;  
  8.     private String name;  
  9.       
  10.     private List students;  
  11.       
  12.   
  13.     /** 
  14.      * 默认的构造方法必须不能省，不然不能解析 
  15.      */  
  16.     public Teacher() {  
  17.           
  18.     }  
  19.     public Teacher(int id,String name) {  
  20.         this.id = id;  
  21.         this.name = name;  
  22.     }  
  23.       
  24.     public int getId() {  
  25.         return id;  
  26.     }  
  27.     public void setId(int id) {  
  28.         this.id = id;  
  29.     }  
  30.     public String getName() {  
  31.         return name;  
  32.     }  
  33.     public void setName(String name) {  
  34.         this.name = name;  
  35.     }  
  36.   
  37.     public List getStudents() {  
  38.         return students;  
  39.     }  
  40.     public void setStudents(List students) {  
  41.         this.students = students;  
  42.     }  
  43.     @Override  
  44.     public String toString() {  
  45.         return “Teacher [id=” + id + “, name=” + name + “, mStudents=”  
  46.                 + students + ”]”;  
  47.     }  
  48.       
  49.       
  50. }  
package com.android.fastjson.bean;import java.util.List;public class Teacher {    private int id;    private String name;    private List students;    /**     * 默认的构造方法必须不能省，不然不能解析     */    public Teacher() {    }    public Teacher(int id,String name) {        this.id = id;        this.name = name;    }    public int getId() {        return id;    }    public void setId(int id) {        this.id = id;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public List getStudents() {        return students;    }    public void setStudents(List students) {        this.students = students;    }    @Override    public String toString() {        return "Teacher [id=" + id + ", name=" + name + ", mStudents="                + students + "]";    }}

上面 的代码比较简单，主要就几个属性，这里值得注意的是， 默认的构造函数一定要写，不然是无法解析的。（对于fastjson 严格按照JavaBean的规范来，有一点不对就无法解析，这里一定要切记，每一个实体类的属性的get , set 方法必须写，切方法第四个字母必须大写，最好使用Eclipse的source->genreal setters and getters 生成get,set 方法，切记，切记 ）。对于Gson 这里就没有这么多的要求了，但最好还是按照JavaBean来写，避免一些位置的错误。

上面主要基本的介绍完了，就开始解析，首先要下载fastjson 和Gson的jar包，这个网上很多请自行下载。

首先看 fastjson 的解析

首先解析一个实体类为json 格式。

[html] view plain copy print ?
  1. Student student = new Student(0, “Aaron”, 24);  
  2.         System.out.println(JSON.toJSONString(student));  
Student student = new Student(0, "Aaron", 24);        System.out.println(JSON.toJSONString(student));
[html] view plain copy print ?
  1. 输出结果为：{“age”:24,”id”:0,”name”:”Aaron”}  
输出结果为：{"age":24,"id":0,"name":"Aaron"}
输出的json格式与我们的Student中定义的属性其实是不一致的，这个其实不影响我们生成以及后面的解析，因为他有严格的get和set方法定义。

更复杂一点的数据类型也可以很方便的使用JSON.toJsonString(Object o) 这个方法进行解析成json格式。

[java] view plain copy print ?
  1. List students = new ArrayList();  
  2.         for(int i=0;i<5;i++) {  
  3.             Student stu = new Student(i, “Student” + i, 18 +i);   
  4.             students.add(stu);  
  5.         }  
List students = new ArrayList();        for(int i=0;i<5;i++) {            Student stu = new Student(i, "Student" + i, 18 +i);             students.add(stu);        }
解析结果为： [plain] view plain copy print ?
  1. [{“age”:18,”id”:0,”name”:”Student0”},{“age”:19,”id”:1,”name”:”Student1”},{“age”:20,”id”:2,”name”:”Student2”},{“age”:21,”id”:3,”name”:”Student3”},{“age”:22,”id”:4,”name”:”Student4”}]  
[{"age":18,"id":0,"name":"Student0"},{"age":19,"id":1,"name":"Student1"},{"age":20,"id":2,"name":"Student2"},{"age":21,"id":3,"name":"Student3"},{"age":22,"id":4,"name":"Student4"}]
   我们来看看更复杂一点的结构。  我们将一个Teacher 列表来解析，一个Teacher对象中是包含Student 列表的这个也在我们常用的数据模型，下面看看代码：

[java] view plain copy print ?
  1. List teaList = new ArrayList();  
  2.         long time = System.currentTimeMillis();  
  3.         for(int i=0;i<10;i++) {  
  4.             Teacher teacher = new Teacher(i, “Teacher ” + i);  
  5.             List stus = new ArrayList();  
  6.             for(int j = 0 ;j<4;j++) {  
  7.                 Student s = new Student(j, “Student” + j, 18 +j);   
  8.                 stus.add(s);  
  9.             }  
  10.             teacher.setStudents(stus);  
  11.             teaList.add(teacher);  
  12.         }  
  13.         String jsonTeach = JSON.toJSONString(teaList);  
  14.         System.out.println(”fastjson = ” + jsonTeach);  
List teaList = new ArrayList();        long time = System.currentTimeMillis();        for(int i=0;i<10;i++) {            Teacher teacher = new Teacher(i, "Teacher " + i);            List stus = new ArrayList();            for(int j = 0 ;j<4;j++) {                Student s = new Student(j, "Student" + j, 18 +j);                 stus.add(s);            }            teacher.setStudents(stus);            teaList.add(teacher);        }        String jsonTeach = JSON.toJSONString(teaList);        System.out.println("fastjson = " + jsonTeach);

结果为：

[plain] view plain copy print ?
  1. fastjson = [{“id”:0,”name”:”Teacher 0”,”students”:[{“age”:18,”id”:0,”name”:”Student0”},{“age”:19,”id”:1,”name”:”Student1”}]},{“id”:1,”name”:”Teacher 1”,”students”:[{“age”:18,”id”:0,”name”:”Student0”},{“age”:19,”id”:1,”name”:”Student1”}]},{“id”:2,”name”:”Teacher 2”,”students”:[{“age”:18,”id”:0,”name”:”Student0”},{“age”:19,”id”:1,”name”:”Student1”}]},{“id”:3,”name”:”Teacher 3”,”students”:[{“age”:18,”id”:0,”name”:”Student0”},{“age”:19,”id”:1,”name”:”Student1”}]}]  
fastjson = [{"id":0,"name":"Teacher 0","students":[{"age":18,"id":0,"name":"Student0"},{"age":19,"id":1,"name":"Student1"}]},{"id":1,"name":"Teacher 1","students":[{"age":18,"id":0,"name":"Student0"},{"age":19,"id":1,"name":"Student1"}]},{"id":2,"name":"Teacher 2","students":[{"age":18,"id":0,"name":"Student0"},{"age":19,"id":1,"name":"Student1"}]},{"id":3,"name":"Teacher 3","students":[{"age":18,"id":0,"name":"Student0"},{"age":19,"id":1,"name":"Student1"}]}]
[plain] view plain copy print ?
  1. 还是一个简单的函数而已，就能办到。  
 还是一个简单的函数而已，就能办到。
[plain] view plain copy print ?
  1. 这个还有toJSONString 重载的方法，有很多，在给一个就是可以按照标准的json 格式输出，上面的输出都不规范，我们来看看，  
这个还有toJSONString 重载的方法，有很多，在给一个就是可以按照标准的json 格式输出，上面的输出都不规范，我们来看看，
[plain] view plain copy print ?
  1. Student student = new Student(0, “Aaron”, 24);  
  2.         System.out.println(JSON.toJSONString(student,true));  
  3. 输出为：  
  4. {  
  5. “age”:24,  
  6. “id”:0,  
  7. “name”:”Aaron”  
  8. }  
Student student = new Student(0, "Aaron", 24);        System.out.println(JSON.toJSONString(student,true));输出为：{"age":24,"id":0,"name":"Aaron"}


    
    
如果我们想要将实体类中的某个字段或某几个不进行解析呢？那么我们可以使用transient 关键字，来标记它为不需要的，在fastjson中还提供了一种便捷的方法来自定义我们需要序列化的字段，
                      [java] view plain        copy               print ?                
          
  1. SimplePropertyPreFilter filter = new SimplePropertyPreFilter(实体类.class, “字段1”,“字段2”); 字段为我们需要序列化的字段，如果实体类中没有改字段则不解析放弃该字段而不会报错。  
    2.      
                   
SimplePropertyPreFilter filter = new SimplePropertyPreFilter(实体类.class, "字段1","字段2"); 字段为我们需要序列化的字段，如果实体类中没有改字段则不解析放弃该字段而不会报错。
    
    
如下：
    
                      [java] view plain        copy               print ?                
          
  1. SimplePropertyPreFilter filter = new SimplePropertyPreFilter(Student.class, “id”,“age”);  
    2.       
  2.         String jsonStu =JSON.toJSONString(students,filter);  
    3.      
                   
SimplePropertyPreFilter filter = new SimplePropertyPreFilter(Student.class, "id","age");        String jsonStu =JSON.toJSONString(students,filter);
     这样就只会序列化 id和age 的字段。    
    
    
    
下面进行fastjson 的反序列化，这个也是很常用的功能，
    
还是拿最简单的来进行示范，
    
                      [java] view plain        copy               print ?                
          
  1. Student student = new Student(0, “Aaron”, 24);  
    2.       
  2.         String str = JSON.toJSONString(student,true);  
    3.       
  3.         System.out.println(JSON.parseObject(str,Student.class));  
    4.      
                   
Student student = new Student(0, "Aaron", 24);        String str = JSON.toJSONString(student,true);        System.out.println(JSON.parseObject(str,Student.class));
    反序列化主要使用的是JSON.parseObject(str,class); 它就能把我们的str 转化为class 类型的对象，当然还有更复杂的对象，比如：    
    
                      [java] view plain        copy               print ?                
          
  1.         List students = new ArrayList();  
    2.       
  2.         for(int i=0;i<5;i++) {  
    3.       
  3.             Student stu = new Student(i, “Student” + i, 18 +i);   
    4.       
  4.             students.add(stu);  
    5.       
  5.         }  
    6.       
  6.         // 过滤哪些属性需要转换  
    7.       
  7. //      SimplePropertyPreFilter filter = new SimplePropertyPreFilter(Student.class, “id”,”age”);  
    8.       
  8. //      String jsonStu =JSON.toJSONString(students,filter);  
    9.       
  9.         String jsonStu =JSON.toJSONString(students);  
    10.       
  10.         System.out.println(jsonStu);  
    11.       
  11.           
    12.       
  12.         List stu =JSON.parseObject(jsonStu, new TypeReference>(){});  
    13.       
  13.         for(int i=0;i
    14.       
  14.         {  
    15.       
  15.             System.out.println(stu.get(i));  
    16.       
  16.         }  
    17.      
                   
     List students = new ArrayList();        for(int i=0;i<5;i++) {            Student stu = new Student(i, "Student" + i, 18 +i);             students.add(stu);        }        // 过滤哪些属性需要转换//      SimplePropertyPreFilter filter = new SimplePropertyPreFilter(Student.class, "id","age");//      String jsonStu =JSON.toJSONString(students,filter);        String jsonStu =JSON.toJSONString(students);        System.out.println(jsonStu);        List stu =JSON.parseObject(jsonStu, new TypeReference>(){});        for(int i=0;i
    前面    就是添加数据，然后在后面解析为json格式，然后在转化为类的对象，这里转为List 对象，主要用到    new TypeReference<数据返回类型> (){}，我们使用的就是new TypeReference>(){} 返回的结果就是List 也不需要强制转化，我们看看上面输出的结果为:    
    
                      [java] view plain        copy               print ?                
          
  1. Student [id=0, name=Student0, age=18]  
    2.       
  2. Student [id=1, name=Student1, age=19]  
    3.       
  3. Student [id=2, name=Student2, age=20]  
    4.       
  4. Student [id=3, name=Student3, age=21]  
    5.       
  5. Student [id=4, name=Student4, age=22]  
    6.      
                   
Student [id=0, name=Student0, age=18]Student [id=1, name=Student1, age=19]Student [id=2, name=Student2, age=20]Student [id=3, name=Student3, age=21]Student [id=4, name=Student4, age=22]
    
    
    
当然fastjson 能处理的数据类型还有很多很多，我主要列了我常用的数据类型，今天主要就讲到这里。
    

 
    
后面我会将也简单介绍下Gson 的基本使用，然后在和fastjson进行对比，看看时间是否真的比gson 快6倍。
    
好久没有写博客了，文采一般，但希望大家能够喜欢，多提意见，一起进步。大家有什么想要了解的也可以留言，我后面慢慢的进行学习，然后进行讲解。








更多相关文章
	

    

  1. Effective Java读书笔记、感悟——1.创建和销毁对象
  2. 如何检测 Android(安卓)Cursor 泄漏
  3. 你真的懂Android(安卓)Handler吗？（一）
  4. Android9.0应用弹窗“此应用专为旧版Android打造，因此可能无法正
  5. Android面试题2018年整理
  6. 读写Android中assets目录下的文件的方法详解
  7. Android(安卓)动态权限最全解析
  8. Android(安卓)Activity 完全解析（上）
  9. 事件处理机制之Gestures(手势)



随机推荐
	

    

  1. 
[置顶] Android中资源文件的详解和androi
    2. 

  2. 
android 学习文章收藏（链接）
    3. 

  3. 
Android(安卓)fragment中弹出的dialogfra
    4. 

  4. 
进阶准备
    5. 

  5. 
android 一
    6. 

  6. 
android 2.2 apidemos 赏析笔记
    7. 

  7. 
Android_使用StrictMode 调试开发
    8. 

  8. 
Android Environment 的作用以及常用的方
    9. 

  9. 
关于android示例程序(bitmapfun)——高效
    10. 

  10. 
Android中再按一次退出实现
    11.