Android中發起網絡訪問的方式，以及Json、Gson的網絡解析

什麼是JSON ?
JSON是一種輕量級的數據交換格式，採用完全獨立於語言的文本格式，易於人閱讀和編寫，
同時也易於機器解析和生成（數據量相對較少，網絡傳輸速度相對較快）。
JSON語法：
JSON語法有JSONObject與JSONArray之分
JSONArray(用於描述JSON數組)：
--【JSONArray用於以JSON的格式描述數組數據】
--【JSONArray也有下標與長度的用法】
--【JSONArray中根據元素不同的類型有不同的格式：
屬性值類型爲字符串時，需要使用雙引號；
屬性值類型爲數字、boolean、數組等類型時，不需要任何符號】
JSONObject(用於描述JSON對象)：
--【JSONObject中所含有的屬性使用key:value的方式存儲】
--【JSONObject的屬性之間使用“,”分割】
--【JSONObject中屬性名必須使用雙引號】
--【JSONObject中的屬性值根據不同類型有不同的格式：
屬性值類型爲字符串時，需要使用雙引號；
屬性值類型爲數字、boolean、數組等類型時，不需要任何符號】
JSON的語法事例：
{"programmers":[
{"firstName":"Brett","lastName":"McLaughlin","email":"aaaa"},
{"firstName":"Jason","lastName":"Hunter","email":"bbbb"},
{"firstName":"Elliotte","lastName":"Harold","email":"cccc"}
],
"authors":[
{"firstName":"Lsaac","lastName":"Asimov","genre":"sciencefiction"},
{"firstName":"Tad","lastName":"Williams","genre":"fantasy"},
{"firstName":"Frank","lastName":"Peretti","genre":"christianfiction"}
]
}

使用HC(HttpClient)/UC(HttpURLConnection)進行網絡訪問的基本步驟：


0. 申請權限 INTERNET訪問權限


1. 任何網絡訪問的相關代碼，必須在工作線程中執行！


2. 創建HC/UC對象


3. 聲明發起網絡訪問的方式(GET/POST)


4. 進行網絡連接


5. 獲得服務器響應的結果


6. 解析結果，提取需要的內容


7. 解析結果要提交到UI線程進行呈現


利用HttpClient的POST方式發起帶參數的請求
利用POST方式發起請求，參數要放到請求實體中，並且在請求頭中添加對實體中參數的說明

JSON字符串的解析


1）可以使用String，就按照一個普普通通符串來進行數據的提取


2）JSONLib（apache）


   JSONLib中兩個常用類：


   JSONObject，用來描述對象


   JSONArray，用了描述數組


   解析實例：


   {"result":"ok", 


     "data": [ 


         {"id":1, 


          "name":"zhangsan", 


          "salary":12345.0, 


          "age":12, 


          "gender":"m"},


         {"id":2, 


          "name":"zhangsan", 


          "salary":12345.0, 


          "age":12, 


          "gender":"m"}


         ] 
    }
   1）根據JSON字符串創建JSONObject對象


 JSONObject obj = new JSONObject（json字符串）


  2）根據需要提取的數據類型，調用obj對象的getXXX方法


  3）利用取出的各種數據，構建成一個Java實體類對象


   Emp emp = new Emp();


   emp.setAge(obj.getInt());


   emp.setName(obj.getString());

Android中JSON解析：
android sdk中爲我們提供了org.json，可以用來解析json，
在android3.0又爲在android.util包JsonReader和JsonWriter來進行json的解析和生成。
Json解析使用的一般步驟：
1.寫一個實體類封裝相關屬性信息，並寫相關屬性的set、get方法
2.寫一個JsonUtil類，Json字符串爲發起網絡訪問後返回的字符串
package com.example.ems.util;

import java.util.ArrayList;
import java.util.List;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import com.example.ems.bean.Emp;

public class JsonUtil {
public static List<Emp> getAllEmps(String result){
try {
//根據JSON字符串創建JSONObject對象
JSONObject obj = new JSONObject(result);
//取出"data"鍵對應的值
JSONArray arr = obj.getJSONArray("data");
List<Emp> emps = new ArrayList<Emp>();
for(int i=0;i<arr.length();i++){
JSONObject jsonobj = arr.getJSONObject(i);
Emp emp = new Emp();
emp.setAge(jsonobj.getInt("age"));
emp.setGender(jsonobj.getString("gender"));
emp.setName(jsonobj.getString("name"));
emp.setSalary(jsonobj.getDouble("salary"));
emps.add(emp);
}
return emps;
} catch (JSONException e) {
e.printStackTrace();
throw new RuntimeException("JSON字符串解析出現異常");
}

}
}
3.寫一個HttpUtil類，發起網絡訪問（兩種網絡訪問方式），通過監聽器回調結果
以員工登錄系統爲例：
package com.example.ems.util;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.json.JSONArray;
import org.json.JSONObject;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.os.Handler;
import android.os.Looper;
import android.util.Log;

import com.example.ems.bean.Emp;
import com.example.ems.bean.User;
import com.example.ems.bean.ValueObject;
import com.example.ems.listener.OnAddEmpFinishListener;
import com.example.ems.listener.OnLoadEmpsFinishListener;
import com.example.ems.listener.OnLoginFinishListener;
import com.example.ems.listener.OnRefreshVertifyCodeListener;
import com.example.ems.listener.OnRegistFinishListener;

public class EmsUtil {


public static void registUser(Context context, final User user,
final OnRegistFinishListener listener) {
new AsyncTask<Void, Void, String>() {


@Override
protected String doInBackground(Void... params) {

try {
HttpClient client = new DefaultHttpClient();
HttpPost post = new HttpPost("http://172.60.50.82:8080/ems/regist.do");
//添加一個請求頭，對請求實體中的參數做一個說明
post.setHeader("Content-Type", "application/x-www-form-urlencoded");
//在post中添加請求參數
//請求參數會添加在請求實體中
List<NameValuePair> parameters = new ArrayList<NameValuePair>();
parameters.add(new BasicNameValuePair("loginname", user.getName()));
parameters.add(new BasicNameValuePair("password", user.getPassword()));
parameters.add(new BasicNameValuePair("realname", user.getRealname()));
parameters.add(new BasicNameValuePair("email", user.getEmail()));
HttpEntity entity = new UrlEncodedFormEntity(parameters);
post.setEntity(entity);

HttpResponse resp = client.execute(post);
HttpEntity respEntity = resp.getEntity();
// InputStream is = respEntity.getContent();
//
// BufferedReader br = new BufferedReader(new InputStreamReader(is));
//
// String line = br.readLine();
//
// br.close();


String line = EntityUtils.toString(respEntity);

return line;

} catch (Exception e) {
e.printStackTrace();
}


return null;
}

protected void onPostExecute(String result) {
listener.onRegistFinish(result);
};

}.execute();


}

public static void registUser2(Context context,final User user, final OnRegistFinishListener listener){
//HttpURLConnection進行註冊
new Thread(){
public void run() {
try {
URL url = new URL("http://172.60.50.82:8080/ems/regist.do");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("POST");
connection.setDoInput(true);//接收服務器響應的內容
connection.setDoOutput(true);//要向服務器提交內容
//在請求頭中，爲請求實體中的內容做說明
connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
connection.connect();
//客戶端向服務器提交參數
OutputStream out = connection.getOutputStream();
PrintWriter pw = new PrintWriter(out, true);
//String params = "loginname="+user.getName()+"&password="+user.getPassword()+"&realname="+user.getRealname()+"&email="+user.getEmail();
String params = getParams(user);
pw.print(params);
pw.close();
//客戶端獲取服務器的響應內容
InputStream in = connection.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(in));
final String result = br.readLine();
br.close();
//在主線程執行
new Handler(Looper.getMainLooper()).post(new Runnable() {

@Override
public void run() {
listener.onRegistFinish(result);
}
});

} catch (Exception e) {
e.printStackTrace();
}
};
}.start();


}

protected static String getParams(User user) {
Map<String,String> map = new HashMap<String, String>();
map.put("loginname", user.getName());
map.put("password", user.getPassword());
map.put("realname", user.getRealname());
map.put("email", user.getEmail());

StringBuilder sb = new StringBuilder();

for(Entry<String, String> entry:map.entrySet()){
sb.append(entry.getKey()).
append("=").
append(entry.getValue()).
append("&");
}

return sb.substring(0, sb.length()-1);
}

public static void getVertify(final OnRefreshVertifyCodeListener listener) {
new AsyncTask<Void, Void, ValueObject>(){

@Override
protected ValueObject doInBackground(Void... params) {
try {
HttpClient client = new DefaultHttpClient();
HttpGet get = new HttpGet("http://172.60.50.82:8080/ems/getCode.do");
HttpResponse resp = client.execute(get);
Header header = resp.getFirstHeader("Set-Cookie");
String value = header.getValue().split(";")[0];
HttpEntity entity = resp.getEntity();
InputStream is = entity.getContent();
Bitmap bitmap = BitmapFactory.decodeStream(is);
is.close();

ValueObject vo = new ValueObject();
vo.setBitmap(bitmap);
vo.setSessionid(value);

return vo;
} catch (Exception e) {
e.printStackTrace();
}

return null;
}
protected void onPostExecute(ValueObject result) {
listener.onRefreshFinished(result.getBitmap(),result.getSessionid());
};

}.execute();

}

public static void getVertify2(final OnRefreshVertifyCodeListener listener){
new Thread(){
public void run() {
try {
URL url = new URL("http://172.60.50.82:8080/ems/getCode.do");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("GET");
connection.setDoInput(true);
connection.connect();

final String value = connection.getHeaderField("Set-Cookie").split(";")[0];
InputStream is = connection.getInputStream();
final Bitmap bitmap = BitmapFactory.decodeStream(is);
is.close();
new Handler(Looper.getMainLooper()).post(new Runnable() {

@Override
public void run() {
listener.onRefreshFinished(bitmap,value);
}
});
} catch (Exception e) {
e.printStackTrace();
}
};
}.start();
}

public static void login(final String loginname, final String password, final String code,final String sid,
final OnLoginFinishListener listener) {
new AsyncTask<Void, Void, String>(){

@Override
protected String doInBackground(Void... params) {
try {
HttpClient client = new DefaultHttpClient();
HttpPost post = new HttpPost("http://172.60.50.82:8080/ems/login.do");
post.setHeader("Content-Type","application/x-www-form-urlencoded");
post.setHeader("Cookie",sid);
List<NameValuePair> parameters = new ArrayList<NameValuePair>();
parameters.add(new BasicNameValuePair("loginname", loginname));
parameters.add(new BasicNameValuePair("password", password));
parameters.add(new BasicNameValuePair("code", code));
HttpEntity entity = new UrlEncodedFormEntity(parameters);
post.setEntity(entity);
HttpResponse resp = client.execute(post);
String result = EntityUtils.toString(resp.getEntity());
return result;

} catch (Exception e) {
e.printStackTrace();
}
return null;
}
protected void onPostExecute(String result) {
listener.onLoginFinish(result);
};
}.execute();
}
public static void login2(final String loginname, final String password, final String code,final String sid,
final OnLoginFinishListener listener) {
new Thread(){
public void run() {
try {
URL url = new URL("http://172.60.50.82:8080/ems/login.do");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("POST");
connection.setDoInput(true);
connection.setDoOutput(true);
connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
connection.setRequestProperty("Cookie", sid);
connection.connect();
OutputStream out = connection.getOutputStream();
PrintWriter pw = new PrintWriter(out,true);
pw.write(getParams(loginname,password,code));
pw.close();
InputStream in = connection.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(in));
final String result = br.readLine();
br.close();
new Handler(Looper.getMainLooper()).post(new Runnable() {

@Override
public void run() {
listener.onLoginFinish(result);

}
});

} catch (Exception e) {
e.printStackTrace();
}
};
}.start();
}

protected static String getParams(String loginname, String password,
String code) {
Map<String , String> map = new HashMap<String, String>();
map.put("loginname", loginname);
map.put("password", password);
map.put("code", code);
StringBuilder sb = new StringBuilder();
for(Entry<String, String> entry:map.entrySet()){
sb.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
}
return sb.substring(0,sb.length()-1);
}

public static void addEmp(final Emp emp, final OnAddEmpFinishListener listener) {
new AsyncTask<Void, Void, String>(){

@Override
protected String doInBackground(Void... params) {
try {
HttpClient client = new DefaultHttpClient();
HttpPost post = new HttpPost("http://172.60.50.82:8080/ems/addEmp");
post.setHeader("Content-Type","application/x-www-form-urlencoded");
List<NameValuePair> parameters = new ArrayList<NameValuePair>();
parameters.add(new BasicNameValuePair("name", emp.getName()));
parameters.add(new BasicNameValuePair("salary",String.valueOf(emp.getSalary())));
parameters.add(new BasicNameValuePair("age", String.valueOf(emp.getAge())));
parameters.add(new BasicNameValuePair("gender", emp.getGender()));
HttpEntity entity = new UrlEncodedFormEntity(parameters);
post.setEntity(entity);
HttpResponse resp = client.execute(post);
String result = EntityUtils.toString(resp.getEntity());
return result;

} catch (Exception e) {
e.printStackTrace();
}
return null;
}
protected void onPostExecute(String result) {
listener.onAddFinish(result);
};
}.execute();

}
public static void addEmp2(final Emp emp, final OnAddEmpFinishListener listener) {

new Thread(){
public void run() {
try {
URL url = new URL("http://172.60.50.82:8080/ems/addEmp");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("POST");
connection.setDoInput(true);
connection.setDoOutput(true);
connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
connection.connect();
OutputStream out = connection.getOutputStream();
PrintWriter pw = new PrintWriter(out,true);
pw.write(getParams(emp));
pw.close();

InputStream in = connection.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(in));
final String result = br.readLine();
br.close();

new Handler(Looper.getMainLooper()).post(new Runnable() {

@Override
public void run() {
listener.onAddFinish(result);
}
});
} catch (Exception e) {
e.printStackTrace();
}
};
}.start();
}

protected static String getParams(Emp emp) {
Map<String , String> map = new HashMap<String, String>();
map.put("name", emp.getName());
map.put("salary", String.valueOf(emp.getSalary()));
map.put("age", String.valueOf(emp.getAge()));
map.put("gender",emp.getGender());
StringBuilder sb = new StringBuilder();
for(Entry<String, String> entry:map.entrySet()){
sb.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
}
return sb.substring(0,sb.length()-1);
}

public static void getAllEmps(final OnLoadEmpsFinishListener listener) {

new AsyncTask<Void, Void, List<Emp>>(){

@Override
protected List<Emp> doInBackground(Void... params) {
try {
HttpClient client = new DefaultHttpClient();
HttpGet get = new HttpGet("http://172.60.50.82:8080/ems/listEmp");
HttpResponse resp = client.execute(get);
HttpEntity entity = resp.getEntity();
String result = EntityUtils.toString(entity);
//Log.d("TAG","emp信息:"+result);
return JsonUtil.getAllEmps(result);

} catch (Exception e) {
e.printStackTrace();
}
return null;
}
protected void onPostExecute(java.util.List<Emp> result) {
listener.onLoadFinish(result);
};
}.execute();
}

public static void getAllEmps2(final OnLoadEmpsFinishListener listener){
new Thread(){
public void run() {
try {
URL url = new URL("http://172.60.50.82:8080/ems/listEmp");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setDoInput(true);
connection.setRequestMethod("GET");
connection.connect();
InputStream is = connection.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(is));
String line = null;
StringBuilder sb = new StringBuilder();
while((line=br.readLine())!=null){
sb.append(line);
}
br.close();
final List<Emp> emps = JsonUtil.getAllEmps(sb.toString());
new Handler(Looper.getMainLooper()).post(new Runnable() {

@Override
public void run() {
listener.onLoadFinish(emps);
}
});

} catch (Exception e) {
e.printStackTrace();
}
};
}.start();
}
}

4.根據監聽器的回調傳回的JSON解析結果將數據放到adapter中顯示。
@Override
protected void onResume() {
super.onResume();
refresh();
}

private void refresh() {
//真正獲取數據源json字符串
biz.getAllEmps(new OnLoadEmpsFinishListener() {

@Override
public void onLoadFinish(List<Emp> emps) {
Log.d("TAG", "員工信息："+emps.toString());
adapter.addAll(emps, true);
}
});
}
********************************************************
關於Gson解析的使用（使用Volley框架時）
1.下載谷歌官方的jar包，並導入到項目中
2.根據網絡訪問返回的字符串結果寫一個嚴格一一對應的實體類，並寫上set、get以及toString方法
3.在HttpUtil中利用Volley框架發起網絡訪問並在響應結果監聽器回調方法中利用Gson進行網絡解析
（利用Volley框架也要先在項目中導入相應的jar包）
實例代碼如下：
package com.example.weather.util;

import java.net.URLEncoder;

import android.content.Context;
import android.widget.Toast;

import com.android.volley.RequestQueue;
import com.android.volley.Response.ErrorListener;
import com.android.volley.Response.Listener;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.StringRequest;
import com.android.volley.toolbox.Volley;
import com.google.gson.Gson;
import com.example.weather.bean.WeatherBean;
import com.example.weather.listener.OnLoadWeatherFinishListener;

public class HttpUtil {

private static RequestQueue queue;

public static void getWeahters(final Context context,String city,final OnLoadWeatherFinishListener listener){
try {
if(queue==null){
queue = Volley.newRequestQueue(context);
}
String encode = URLEncoder.encode(city, "utf8");
String url="http://op.juhe.cn/onebox/weather/query?cityname="+encode+"&key=15b3860417a0875de210d562b0be2ce3";
StringRequest request = new StringRequest(url, new Listener<String>() {

@Override
public void onResponse(String arg0) {
Gson gson = new Gson();
WeatherBean bean = gson.fromJson(arg0, WeatherBean.class);
listener.onLoadFinish(bean);
}
}, new ErrorListener() {

@Override
public void onErrorResponse(VolleyError arg0) {
Toast.makeText(context, arg0.getMessage(), Toast.LENGTH_SHORT).show();
}
});

queue.add(request);
} catch (Exception e) {
e.printStackTrace();
}
}
}
4.通過監聽器的回調方法將解析結果傳回
**************************************************************
一般解析方式：
JsonObject的解析：
String str="{\"name\":\"zhangsan\“,\"age\":20}";
JSONObject obj=new JSONObject(str);
String name=obj.getString("name");
int age=obj.getInt("age");

JsonArray的解析：
String str="[10,true,\"hello\"]";
JSONArray obj=new JSONArray(str);
String name=obj.getString(2);
int age=obj.getInt(0);

JSON語法

首先看JSON的語法和結構，這樣我們才知道怎麼去解析它。JSON語法時JavaScript對象表示語法的子集。

JSON的值可以是：

數字（整數或者浮點數）

字符串（在雙引號內）

邏輯值(true 或 false)

數組(使用方括號[]包圍)

對象( 使用花括號{}包圍)

null

JSON中有且只有兩種結構：對象和數組。

1、對象：對象在js中表示爲“{}”括起來的內容，數據結構爲 {key：value,key：value,...}的鍵值對的結構，在面向對象的語言中，key爲對象的屬性，value爲對應的屬性值，所以很容易理解，取值方法爲 對象.key 獲取屬性值，這個屬性值的類型可以是 數字、字符串、數組、對象幾種。

2、數組：數組在js中是中括號“[]”括起來的內容，數據結構爲 ["java","javascript","vb",...]，取值方式和所有語言中一樣，使用索引獲取，字段值的類型可以是 數字、字符串、數組、對象幾種。

andoroid解析JSON

android sdk中爲我們提供了org.json，可以用來解析json，在android3.0又爲在android.util包JsonReader和JsonWriter來進行json的解析和生成。

使用org.json包JSONObject和JSONArray進行解析

我們知道json中就兩種結構array和object，因此就有這個兩個類進行解析。

如我們有下面幾個json字符串：

{"name":"sam","age":18,"weight":60} //json1 一個json對象
[12,13,15]                    //json2 一個數字數組
[{"name":"sam","age":18},{"name":"leo","age":19},{"name":"sky", "age":20}] //json3 json array中有object
第一個json對象json1的解析

JSONObject jsonObj = new JSONObject(json1);
String name = jsonObj.optString("name");
int age = jsonObj.optInt("age");
int weight = jsonObj.optInt("weight");
另外還有

Object opt（String name）
boolean optBoolean(String name)
double optDouble(String name)
JSONArray optJSONArray(String name)
JSONObject optJSONObject(String name)
等方法，我推薦用這些方法，這些方法在解析時，如果對應字段不存在會返回空值或者0，不會報錯。

當然如果你使用以下方法

Object get(String name)
boolean getBoolean(String name)
int getInt(String name)
等方法時，代碼不會去判斷是否存在該字段，需要你自己去判斷，否則的話會報錯。自己判斷的話使用has(String name)來判斷。

再來看解析數組，簡單的數組。第二個json2

JSONArray jsonArray = new JSONArray(json2);
for (int = 0; i < jsonArray.length();i++) {
    int age = jsonArray.optInt(i); 
}
解析複雜數組，包含對象，json3

JSONArray jsonArray = new JSONArray(json3);
for (int = 0; i < jsonArray.length();i++) {
    JSONObject jsonObject = jsonArray.optJSONObject(i);
    String name = jsonObject.optString("name");
    int age = jsonObject.optInt("age");
}
從上面可以看到數組的話解析方法和對象差不多，只是將鍵值替換爲在數組中的下標。另外也是有optXXX（int index）和getXXX（int index）方法的，opt也是安全的，即對應index無值的時候，不會報錯，返回空，推薦使用。

使用JsonReader進行解析

JsonReader的使用其實和xml解析中的pull是有一點類似的，我們來看示例。

前面的JSONObject和JSONArray創建時傳的是String，而JsonReader需要傳入的時候是Reader，網絡訪問中，我們可以直接拿輸入流傳進來，轉成Reader。我們這裏假設我們上面的String已經轉成InputStream了，分別爲jsonIs1，jsonIs2,jsonIs3。

上面的json1解析：

JsonReader reader = new JsonReader(new InputStreamReader(jsonIs1));
try {
    reader.beginObject();
    while (reader.hasNext()) {
        String keyName = reader.nextName();
        if (keyName.equals("name")) { 
            String name = reader.nextString();
        } else if (keyName.equals("age")) {
            int age = reader.nextInt();
        } else if (keyName.equals("weight")) {
            int weight = reader.nextInt();
        }
    }
    reader.endObject();
} finally {
    reader.close();
}
上面json2的解析:

JsonReader reader = new JsonReader(new InputStreamReader(jsonIs2));
try {
    List<Integer> ages = new ArrayList<Integer>();
    reader.beginArray();
    while (reader.hasNext()) {
        ages.add(reader.nextInt());
    }
    reader.endArray();
} finally {
    reader.close();
}
第三個我就不寫示例了。

看到這個的話是通過去遍歷我們的json，去取得我們的內容，我覺得在效率上面會比第一種效率高一些。具體使用的話就按照我這兩個例子可以寫出來的。
************************************************************************************************
使用GSON解析JSON

GSON是谷歌出品，很好用。同時呢還有一些其他的第三方的比如fastjson等，都和Gson差不多，傳一個string和要轉換的對象，幫你直接直接解析出來，不再需要我們自己一個字段一段字段的解析。這裏就以Gson爲例吧，因爲我只用過Gson，對其最熟悉。^_^

使用Gson，我們需要導入Gson的包，下載地址https://code.google.com/p/google-gson/downloads/list。

現在開始看看，怎麼解析上面的三個json字符串例子。

第一個對象json1

首先我們需要一個實體類

public class People{

public String name;

@SerializedName(age)
pubic int mAge;    //如果我們類中成員的名稱和json對象中的鍵名不同，可以通過註解來設置名字

public int weight;
}
然後就可以解析了

Gson gson = new Gson();
Poeple people = gson.fromJson(json1, People.class);
對於第二個json2，我們可以解析成int數組，也可以解析成Integer的List。 解析成數組：

Gson gson = new Gson();
int[] ages = gson.fromJson(json2, int[].class);
解析成List：

Gson gson = new Gson();
List<Integer> ages = gson.fromJson(json2, new TypeToken<List<Integer>>(){}.getType);
第三個同樣可以解析成List或者數組，我們就直接解析成List.

Gson gson = new Gson();
List<People> peoples = gson.fromJson(json3, new TypeToke<List<People>>(){}.getType);
從上面的代碼看到，使用Gson解析的話就非常簡單了。需要注意的是如果對應的鍵值和成員名稱不同的話可以使用註解來標記。