android2.3提供的json解析类
android的json解析部分都在包org.json下，主要有以下几个类：
JSONObject：可以看作是一个json对象
JSONStringer：json文本构建类
JSONArray：可以看作是json的数组
JSONTokener：json解析类
JSONException：json中用到的异常

JSONObject, JSONArray来构建json文本

            
                    
  1. // 假设现在要创建这样一个json文本  
    2.                 
  2. //  {  
    3.                 
  3. //      "phone" : ["12345678", "87654321"], // 数组  
    4.                 
  4. //      "name" : "yuanzhifei89", // 字符串  
    5.                 
  5. //      "age" : 100, // 数值  
    6.                 
  6. //      "address" : { "country" : "china", "province" : "jiangsu" }, // 对象  
    7.                 
  7. //      "married" : false // 布尔值  
    8.                 
  8. //  }  
    9.                 
  9.  
    10.                 
  10. try {  
    11.                 
  11.     // 首先最外层是{}，是创建一个对象  
    12.                 
  12.     JSONObject person = new JSONObject();  
    13.                 
  13.     // 第一个键phone的值是数组，所以需要创建数组对象  
    14.                 
  14.     JSONArray phone = new JSONArray();  
    15.                 
  15.     phone.put("12345678").put("87654321");  
    16.                 
  16.     person.put("phone", phone);  
    17.                 
  17.  
    18.                 
  18.     person.put("name", "yuanzhifei89");  
    19.                 
  19.     person.put("age", 100);  
    20.                 
  20.     // 键address的值是对象，所以又要创建一个对象  
    21.                 
  21.     JSONObject address = new JSONObject();  
    22.                 
  22.     address.put("country", "china");  
    23.                 
  23.     address.put("province", "jiangsu");  
    24.                 
  24.     person.put("address", address);  
    25.                 
  25.  
    26.                 
  26.     person.put("married", false);  
    27.                 
  27. } catch (JSONException ex) {  
    28.                 
  28.     // 键为null或使用json不支持的数字格式(NaN, infinities)  
    29.                 
  29.     throw new RuntimeException(ex);  
    30.                 
  30. }  
    31.

getType和optType api的使用
getType可以将要获取的键的值转换为指定的类型，如果无法转换或没有值则抛出JSONException

optType也是将要获取的键的值转换为指定的类型，无法转换或没有值时返回用户提供或这默认提供的值

            
                    
  1. try {  
    2.                 
  2.     // 所有使用的对象都是用上面创建的对象  
    3.                 
  3.     // 将第一个电话号码转换为数值和将名字转换为数值  
    4.                 
  4.     phone.getLong(0);  
    5.                 
  5.     person.getLong("name"); // 会抛异常，因为名字无法转换为long  
    6.                 
  6.       
    7.                 
  7.     phone.optLong(0); // 代码内置的默认值  
    8.                 
  8.     phone.optLong(0, 1000); // 用户提供的默认值  
    9.                 
  9.     person.optLong("name");  
    10.                 
  10.     person.optLong("name", 1000); // 不像上面那样抛异常，而是返回1000  
    11.                 
  11. } catch (JSONException ex) {  
    12.                 
  12.     // 异常处理代码  
    13.                 
  13. }  
    14.

 

除了上面的两个类，还可以使用JSONStringer来构建json文本

            
                    
  1. try {  
    2.                 
  2.     JSONStringer jsonText = new JSONStringer();  
    3.                 
  3.     // 首先是{，对象开始。object和endObject必须配对使用  
    4.                 
  4.     jsonText.object();  
    5.                 
  5.       
    6.                 
  6.     jsonText.key("phone");  
    7.                 
  7.     // 键phone的值是数组。array和endArray必须配对使用  
    8.                 
  8.     jsonText.array();  
    9.                 
  9.     jsonText.value("12345678").value("87654321");  
    10.                 
  10.     jsonText.endArray();  
    11.                 
  11.       
    12.                 
  12.     jsonText.key("name");  
    13.                 
  13.     jsonText.value("yuanzhifei89");  
    14.                 
  14.     jsonText.key("age");  
    15.                 
  15.     jsonText.value(100);  
    16.                 
  16.       
    17.                 
  17.     jsonText.key("address");  
    18.                 
  18.     // 键address的值是对象  
    19.                 
  19.     jsonText.object();  
    20.                 
  20.     jsonText.key("country");  
    21.                 
  21.     jsonText.value("china");  
    22.                 
  22.     jsonText.key("province");  
    23.                 
  23.     jsonText.value("jiangsu");  
    24.                 
  24.     jsonText.endObject();  
    25.                 
  25.       
    26.                 
  26.     jsonText.key("married");  
    27.                 
  27.     jsonText.value(false);  
    28.                 
  28.       
    29.                 
  29.     // }，对象结束  
    30.                 
  30.     jsonText.endObject();  
    31.                 
  31. } catch (JSONException ex) {  
    32.                 
  32.     throw new RuntimeException(ex);  
    33.                 
  33. }  
    34.

 

json文本解析类JSONTokener
按照RFC4627规范将json文本解析为相应的对象。

对于将json文本解析为对象，只需要用到该类的两个api：
构造函数
public Object nextValue();

            
                    
  1. //  {  
    2.                 
  2. //      "phone" : ["12345678", "87654321"], // 数组  
    3.                 
  3. //      "name" : "yuanzhifei89", // 字符串  
    4.                 
  4. //      "age" : 100, // 数值  
    5.                 
  5. //      "address" : { "country" : "china", "province" : "jiangsu" }, // 对象  
    6.                 
  6. //      "married" : false // 布尔值  
    7.                 
  7. //  }  
    8.                 
  8.  
    9.                 
  9. private static final String JSON =   
    10.                 
  10. "{" +  
    11.                 
  11.     "   \"phone\" : [\"12345678\", \"87654321\"]," +  
    12.                 
  12.     "   \"name\" : \"yuanzhifei89\"," +  
    13.                 
  13.     "   \"age\" : 100," +  
    14.                 
  14.     "   \"address\" : { \"country\" : \"china\", \"province\" : \"jiangsu\" }," +  
    15.                 
  15.     "   \"married\" : false," +  
    16.                 
  16. "}";  
    17.                 
  17.  
    18.                 
  18. try {  
    19.                 
  19.     JSONTokener jsonParser = new JSONTokener(JSON);  
    20.                 
  20.     // 此时还未读取任何json文本，直接读取就是一个JSONObject对象。  
    21.                 
  21.     // 如果此时的读取位置在"name" : 了，那么nextValue就是"yuanzhifei89"（String）  
    22.                 
  22.     JSONObject person = (JSONObject) jsonParser.nextValue();  
    23.                 
  23.     // 接下来的就是JSON对象的操作了  
    24.                 
  24.     person.getJSONArray("phone");  
    25.                 
  25.     person.getString("name");  
    26.                 
  26.     person.getInt("age");  
    27.                 
  27.     person.getJSONObject("address");  
    28.                 
  28.     person.getBoolean("married");  
    29.                 
  29. } catch (JSONException ex) {  
    30.                 
  30.     // 异常处理代码  
    31.                 
  31. }  
    32.

其它的api基本就是用来查看json文本中的文本的
 

            
                    
  1. try {  
    2.                 
  2.     JSONTokener jsonParser = new JSONTokener(JSON);  
    3.                 
  3.     // 继续向下读8个json文本中的字符。此时刚开始，即在{处  
    4.                 
  4.     jsonParser.next(8); //{    "phone。tab算一个字符  
    5.                 
  5.       
    6.                 
  6.     // 继续向下读1个json文本中的字符  
    7.                 
  7.     jsonParser.next(); //"  
    8.                 
  8.       
    9.                 
  9.     // 继续向下读取一个json文本中的字符。该字符不是空白、同时也不是注视中的字符  
    10.                 
  10.     jsonParser.nextClean(); //:  
    11.                 
  11.       
    12.                 
  12.     // 返回当前的读取位置到第一次遇到'a'之间的字符串（不包括a）。  
    13.                 
  13.     jsonParser.nextString('a'); //  ["12345678", "87654321"],    "n（前面有两个空格）  
    14.                 
  14.       
    15.                 
  15.     // 返回当前读取位置到第一次遇到字符串中(如"0089")任意字符之间的字符串，同时该字符是trimmed的。（此处就是第一次遇到了89）  
    16.                 
  16.     jsonParser.nextTo("0089"); //me" : "yuanzhifei  
    17.                 
  17.       
    18.                 
  18.     // 读取位置撤销一个  
    19.                 
  19.     jsonParser.back();  
    20.                 
  20.     jsonParser.next(); //i  
    21.                 
  21.       
    22.                 
  22.     // 读取位置前进到指定字符串处（包括字符串）  
    23.                 
  23.     jsonParser.skipPast("address");  
    24.                 
  24.     jsonParser.next(8); //" : { "c  
    25.                 
  25.       
    26.                 
  26.     // 读取位置前进到执行字符处（不包括字符）  
    27.                 
  27.     jsonParser.skipTo('m');  
    28.                 
  28.     jsonParser.next(8); //married"  
    29.                 
  29. } catch (JSONException ex) {  
    30.                 
  30.     // 异常处理代码  
    31.                 
  31. }  
    32.

json中的null和java中的null注意：
 

            
                    
  1. // json对象的成员为null可能有两种情况：  
    2.                 
  2. // 1: 不出现该成员的名称（对应java中的null）  
    3.                 
  3. // 2: 成员值为null。（对应java中的JSONObject.NULL）  
    4.                 
  4.  
    5.                 
  5. // 完整的Json  
    6.                 
  6. //  {    
    7.                 
  7. //      "phone" : ["12345678", "87654321"], // 数组    
    8.                 
  8. //      "name" : "yuanzhifei89", // 字符串    
    9.                 
  9. //      "age" : 100, // 数值    
    10.                 
  10. //      "address" : { "country" : "china", "province" : "jiangsu" }, // 对象    
    11.                 
  11. //      "married" : false // 布尔值    
    12.                 
  12. //  }    
    13.                 
  13.  
    14.                 
  14. // 第一种情况：不出现某成员的名称(address)  
    15.                 
  15. String jsonText = "{" +    
    16.                 
  16.     "   \"phone\" : [\"12345678\", \"87654321\"]," +    
    17.                 
  17.     "   \"name\" : \"yuanzhifei89\"," +    
    18.                 
  18.     "   \"age\" : 100," +    
    19.                 
  19.     "   \"married\" : false," +    
    20.                 
  20. "}";   
    21.                 
  21.  
    22.                 
  22. try {  
    23.                 
  23.     JSONTokener t = new JSONTokener(jsonText);  
    24.                 
  24.     JSONObject obj = (JSONObject) t.nextValue();  
    25.                 
  25.     if (obj.optJSONObject("address") == null || obj.isNull("address")) {  
    26.                 
  26.     }  
    27.                 
  27. } catch (JSONException ex) {  
    28.                 
  28.     ex.printStackTrace();  
    29.                 
  29. }  
    30.                 
  30.  
    31.                 
  31. // 第二种情况：成员值为null(address为null)  
    32.                 
  32. String jsonText = "{" +    
    33.                 
  33.     "   \"phone\" : [\"12345678\", \"87654321\"]," +    
    34.                 
  34.     "   \"name\" : \"yuanzhifei89\"," +    
    35.                 
  35.     "   \"age\" : 100," +    
    36.                 
  36.     "   \"address\" : null," +    
    37.                 
  37.     "   \"married\" : false," +    
    38.                 
  38. "}";   
    39.                 
  39. try {  
    40.                 
  40.     JSONTokener t = new JSONTokener(jsonText);  
    41.                 
  41.     JSONObject obj = (JSONObject) t.nextValue();  
    42.                 
  42.       
    43.                 
  43.     // 应该这样判断json是否为null  
    44.                 
  44.     if (obj.get("address") == JSONObject.NULL || obj.isNull("address")) {  
    45.                 
  45.     }  
    46.                 
  46. } catch (JSONException ex) {  
    47.                 
  47.     ex.printStackTrace();  
    48.                 
  48. }  
    49.

json中的对象不存在和java中的对应关系
 

            
                    
  1. json中的null对应java中的JSONObject.NULL，所以jsonObj.put("key", JSONObject.NULL) 相当于{"key" : null}  
    2.                 
  2.  
    3.                 
  3. json中的不出现某成员对应Java中的null，所以jsonObj.put("key", null)相当于删除该成员，即：{}  
    4.

 

 

 

更多相关文章

  1. Android实现简单字符驱动程序及测试
  2. Android中intent传递对象和Bundle的用法
  3. android okhttp+Retrofit 发送带有/ ^等特殊字符返回400
  4. EditText实时判断输入字符数
  5. Android Base64字符串转换成图片
  6. Android——字符高亮显示
  7. Android系统移植(三)-按键字符表
  8. Android 基本属性绘制文本对象FontMetrics介绍
  9. android Activity之间传递对象

随机推荐

  1. ROW_NUMBER SQL Server 2005的LIMIT功能
  2. SQL SERVER数据操作类代码
  3. 用SQL统计SQLServe表存储空间大小的代码
  4. 浅谈SQL Server中统计对于查询的影响分析
  5. INSERT INTO SELECT语句与SELECT INTO FR
  6. SQL Server中的执行引擎入门 图解
  7. 分析SQL语句性能3种方法分享
  8. sqlserver中重复数据值只取一条的sql语句
  9. SQL 特殊语句(学习笔记)
  10. sqlserver通用的删除服务器上的所有相同