android 将json文件 安卓手机如何打开.jsonl文件

前面我们已经掌握了xml格式数据的解析方式，那么接下来我们学习下如何解析json格式的数据。比起xml，json的主要优势在于它体积更小，在网络上传输的时候可以更省流量。但缺点在于，它的语义性差，看起来不如xml直观。

开始之前，先在自己的电脑apache-tomcat-6.0.39\webapps\ROOT路径目录下新建一个get_data.json的文件，然后编辑这个文件，并加入如下json格式的内容：

[{"id":"5","version":"5.5","name":"angelababy"},
 {"id":"6","version":"7.0","name":"clash of clans"},
 {"id":"7","version":"3.5","name":"hey day"}]

这时候在浏览器访问的结果如下：

这样就把json格式的数据准备好了，下面我们在Android程序中解析这些数据吧。

使用JSONObject解析json格式的数据

解析json格式的数据有很多种方式，可以使用官方提供的JSONObject，也可以用谷歌的开源库GSON。
还有一些第三方的开源库，比如Jackson，FastSON等。目前只讲解JSONObject和GSON。
修改MainActivity中的代码，如下所示:

1. packagecom.jack.networktest;
2. importjava.io.BufferedReader;
3. importjava.io.IOException;
4. importjava.io.InputStream;
5. importjava.io.InputStreamReader;
6. importjava.io.StringReader;
7. importjava.net.HttpURLConnection;
8. importjava.net.MalformedURLException;
9. importjava.net.URL;
10. 
11. importjavax.xml.parsers.SAXParserFactory;
12. 
13. importorg.apache.http.HttpEntity;
14. importorg.apache.http.HttpHost;
15. importorg.apache.http.HttpRequest;
16. importorg.apache.http.HttpResponse;
17. importorg.apache.http.client.ClientProtocolException;
18. importorg.apache.http.client.HttpClient;
19. importorg.apache.http.client.ResponseHandler;
20. importorg.apache.http.client.methods.HttpGet;
21. importorg.apache.http.client.methods.HttpUriRequest;
22. importorg.apache.http.conn.ClientConnectionManager;
23. importorg.apache.http.impl.client.DefaultHttpClient;
24. importorg.apache.http.params.HttpParams;
25. importorg.apache.http.protocol.HttpContext;
26. importorg.apache.http.util.EntityUtils;
27. importorg.json.JSONArray;
28. importorg.json.JSONObject;
29. importorg.xml.sax.InputSource;
30. importorg.xml.sax.XMLReader;
31. importorg.xmlpull.v1.XmlPullParser;
32. importorg.xmlpull.v1.XmlPullParserFactory;
33. 
34. importandroid.annotation.SuppressLint;
35. importandroid.app.Activity;
36. importandroid.os.Bundle;
37. importandroid.os.Handler;
38. importandroid.os.Message;
39. importandroid.util.Log;
40. importandroid.view.Menu;
41. importandroid.view.View;
42. importandroid.view.View.OnClickListener;
43. importandroid.widget.Button;
44. importandroid.widget.TextView;
45. 
46. publicclassMainActivityextendsActivityimplementsOnClickListener{

47. 
48. publicstaticfinalintSHOW_RESPONSE=0;
49. privateButtonsendRequest=null;
50. privateTextViewresponseText=null;
51. 
52. privateHandlerhandler=newHandler(){

53. 
54. @Override
55. publicvoidhandleMessage(Messagemsg){

56. //TODOAuto-generatedmethodstub
57. super.handleMessage(msg);
58. switch(msg.what){

59. caseSHOW_RESPONSE:
60. Stringresponse=(String)msg.obj;
61. //在这里进行UI操作，将结果显示到界面上
62. responseText.setText(response);
63. break;
64. default:
65. break;
66. }
67. 
68. }
69. 
70. };
71. 
72. 
73. @Override
74. protectedvoidonCreate(BundlesavedInstanceState){

75. super.onCreate(savedInstanceState);
76. setContentView(R.layout.activity_main);
77. sendRequest=(Button)findViewById(R.id.send_request);
78. responseText=(TextView)findViewById(R.id.response_text);
79. sendRequest.setOnClickListener(this);
80. 
81. }
82. 
83. @Override
84. publicbooleanonCreateOptionsMenu(Menumenu){

85. //Inflatethemenu;thisaddsitemstotheactionbarifitispresent.
86. getMenuInflater().inflate(R.menu.main,menu);
87. returntrue;
88. }
89. 
90. @Override
91. publicvoidonClick(Viewv){

92. //TODOAuto-generatedmethodstub
93. if(v.getId()==R.id.send_request){

94. //sendRequestWithHttpURLConnection();
95. sendRequestWithHttpClient();
96. }
97. 
98. }
99. 
100. 
101. privatevoidsendRequestWithHttpURLConnection(){

102. //开启线程来发起网络请求
103. newThread(newRunnable(){

104. 
105. @Override
106. publicvoidrun(){

107. //TODOAuto-generatedmethodstub
108. HttpURLConnectionconnection=null;
109. 
110. try{

111. URLurl=newURL("http://www.baidu.com");
112. connection=(HttpURLConnection)url.openConnection();
113. connection.setRequestMethod("GET");
114. connection.setConnectTimeout(8000);
115. connection.setReadTimeout(8000);
116. InputStreamin=connection.getInputStream();
117. //下面对获取到的输入流进行读取
118. BufferedReaderreader=newBufferedReader(newInputStreamReader(in));
119. StringBuilderresponse=newStringBuilder();
120. Stringline;
121. while((line=reader.readLine())!=null){

122. response.append(line);
123. }
124. Messagemessage=newMessage();
125. message.what=SHOW_RESPONSE;
126. //将服务器返回的结果存放到Message中
127. message.obj=response.toString();
128. handler.sendMessage(message);
129. 
130. 
131. }catch(MalformedURLExceptione){

132. //TODOAuto-generatedcatchblock
133. e.printStackTrace();
134. }catch(Exceptione){

135. e.printStackTrace();
136. }finally{

137. if(connection!=null){

138. connection.disconnect();
139. }
140. }
141. }
142. 
143. }).start();
144. 
145. 
146. }
147. 
148. 
149. privatevoidsendRequestWithHttpClient(){

150. newThread(newRunnable(){

151. 
152. @Override
153. publicvoidrun(){

154. //TODOAuto-generatedmethodstub
155. try{

156. HttpClienthttpClient=newDefaultHttpClient();
157. //HttpGethttpGet=newHttpGet("http://www.baidu.com");
158. //指定访问的服务器地址是电脑本机，10.0.2.2对模拟器来说就是电脑本机的ip地址
159. //8080为端口号
160. //HttpGethttpGet=newHttpGet("http://10.0.2.2:8080/get_data.xml");
161. HttpGethttpGet=newHttpGet("http://10.0.2.2:8080/get_data.json");
162. HttpResponsehttpResponse=httpClient.execute(httpGet);
163. if(httpResponse.getStatusLine().getStatusCode()==200){

164. //请求和响应都成功了
165. HttpEntityentity=httpResponse.getEntity();
166. Stringresponse=EntityUtils.toString(entity,"utf-8");
167. //调用parseXMLWithPull方法解析服务器返回的数据
168. //parseXMLWithPull(response);
169. 
170. //调用parseXMLWithSAX方法解析服务器返回的数据
171. parseXMLWithSAX(response);
172. 
173. //调用parseJSONWithJSONObject方法解析服务器返回的数据
174. parseJSONWithJSONObject(response);
175. 
176. 
177. 
178. Messagemessage=newMessage();
179. message.what=SHOW_RESPONSE;
180. //将服务器返回的结果存放到Message中
181. message.obj=response.toString();
182. handler.sendMessage(message);
183. }
184. }catch(Exceptione){

185. e.printStackTrace();
186. }
187. }
188. 
189. }).start();
190. 
191. }
192. 
193. //使用Pull解析xml
194. privatevoidparseXMLWithPull(StringxmlData){

195. //Log.d("MainActivity","parseXMLWithPull(StringxmlData)");
196. try{

197. //获取到XmlPullParserFactory的实例，并借助这个实例得到XmlPullParser对象
198. XmlPullParserFactoryfactory=XmlPullParserFactory.newInstance();
199. XmlPullParserxmlPullParser=factory.newPullParser();
200. //调用XmlPullParser的setInput方法将服务器返回的xml数据设置进去开始解析
201. xmlPullParser.setInput(newStringReader(xmlData));
202. //通过getEventType()方法得到当前解析事件
203. inteventType=xmlPullParser.getEventType();
204. Stringid="";
205. Stringname="";
206. Stringversion="";
207. while(eventType!=XmlPullParser.END_DOCUMENT){

208. //通过getName()方法得到当前节点的名字，如果发现节点名等于id、name、或version
209. //就调用nextText()方法来获取结点具体的内容，每当解析完一个app结点就将获取到的内容打印出来
210. StringnodeName=xmlPullParser.getName();
211. //Log.d("MainActivity",""+eventType+"nodeName="+nodeName);
212. switch(eventType){

213. //开始解析某个节点
214. caseXmlPullParser.START_TAG:{

215. if("id".equals(nodeName)){

216. id=xmlPullParser.nextText();
217. }elseif("name".equals(nodeName)){

218. name=xmlPullParser.nextText();
219. }elseif("version".equals(nodeName)){

220. version=xmlPullParser.nextText();
221. }
222. break;
223. }
224. caseXmlPullParser.END_TAG:{

225. if("app".equals(nodeName)){

226. Log.d("MainActivity","idis"+id);
227. Log.d("MainActivity","nameis"+name);
228. Log.d("MainActivity","versionis"+version);
229. }
230. break;
231. }
232. default:
233. break;
234. }
235. //调用next()方法获取到下一个解析事件
236. eventType=xmlPullParser.next();
237. }
238. }catch(Exceptione){

239. e.printStackTrace();
240. }
241. }
242. 
243. 
244. //进行SAX解析的函数
245. privatevoidparseXMLWithSAX(StringxmlData){

246. /*
247. *parseXMLWithSAX方法中先创建一个SAXParserFactory的对象，然后再获取到
248. *XMLReader对象，接着将我们编写的ContentHandler的实例设置到XMLReader中，
249. *最后调用parse()方法开始执行解析。
250. **/
251. try{

252. SAXParserFactoryfactory=SAXParserFactory.newInstance();
253. XMLReaderxmlReader=factory.newSAXParser().getXMLReader();
254. ContentHandlerhandler=newContentHandler();
255. //将ContentHandler的实例设置到XMLReader中
256. xmlReader.setContentHandler(handler);
257. //开始执行解析
258. xmlReader.parse(newInputSource(newStringReader(xmlData)));
259. 
260. }catch(Exceptione){

261. e.printStackTrace();
262. }
263. }
264. 
265. 
266. 
267. //使用JSONObject解析json格式的数据
268. privatevoidparseJSONWithJSONObject(StringjsonData){

269. /*
270. *首先把http请求的地址改成http://localhost:8080/get_data.json，然后在得到服务器返回
271. *的数据后调用parseJSONWithJSONObject()方法来解析数据。由于我们在服务器中定义的是一个json数组，
272. *因此解析的时候首先是将服务器返回的数据传入到一个JSONArray对象中。然后循环遍历这个JSONArray，从
273. *中取出的每一个元素都是一个JSONObject对象，每个JSONObject对象中又包含了id,name和version这些
274. *数据。接下来只需要调用getString()方法将这些数据取出，并打印出来即可。
275. **/
276. try{

277. JSONArrayjsonArray=newJSONArray(jsonData);
278. for(inti=0;i<jsonArray.length();i++){

279. JSONObjectjsonObject=jsonArray.getJSONObject(i);
280. Stringid=jsonObject.getString("id");
281. Stringname=jsonObject.getString("name");
282. Stringversion=jsonObject.getString("version");
283. Log.d("MainActivity","idis"+id);
284. Log.d("MainActivity","nameis"+name);
285. Log.d("MainActivity","versionis"+version);
286. }
287. }catch(Exceptione){

288. e.printStackTrace();
289. }
290. }
291. 
292. 
293. 
294. 
295. 
296. 
297. 
298. }

现在重新运行下程序，点击send request按钮，结果如下所示：

使用GSON

谷歌提供的GSON开源库可以让解析JSON数据的工作简单到不敢想象的地步。要使用GSON必须要在项目中添加一个GSON的jar包。首先需要将GSON的资源压缩包下载下来，下载地址是：htt://code.google.com/p/google-gson/downloads/list
然后把下载下来的gson-x.x.x.jar包拷贝到NetworkTest项目的libs目录下，GSON库就自动添加到项目了。
GSON的强大之处，在于可以将一段json格式的字符串自动映射成一个对象，从而不需要我们再动手去编写代码进行解析了。比如说一段json格式的数据如下所示：
{"name":"tom","age":"20"}
那么我们就可以定义一个Person类，并加入name和age这两个字段，然后只需简单地调用如下代码就可以将json数据自动解析成一个Person对象了：
Gson gson=new Gson();
Person person=gson.fromJson(jsonData,Person.class);
如果需要解析的是一段json数组会稍微麻烦点，我们需要借助TypeToken将期望解析的数据类型传入到fromJson()方法，如下所示：
List<Person> people=gson.fromJson(jsonData,new TypeToken<List<Person>>(){}.getType());
好了，基本的用法就是这样了，下面我们来试试，首先新增一个App类，并加入id，name和version这三个字段，如下所示：

1. packagecom.jack.networktest;
2. 
3. publicclassApp{

4. 
5. privateStringid;
6. privateStringname;
7. privateStringversion;
8. publicStringgetId(){

9. returnid;
10. }
11. publicvoidsetId(Stringid){

12. this.id=id;
13. }
14. publicStringgetName(){

15. returnname;
16. }
17. publicvoidsetName(Stringname){

18. this.name=name;
19. }
20. publicStringgetVersion(){

21. returnversion;
22. }
23. publicvoidsetVersion(Stringversion){

24. this.version=version;
25. }
26. 
27. 
28. }

然后修改MainActivity中的代码，如下所示：

1. packagecom.jack.networktest;
2. importjava.io.BufferedReader;
3. importjava.io.IOException;
4. importjava.io.InputStream;
5. importjava.io.InputStreamReader;
6. importjava.io.StringReader;
7. importjava.net.HttpURLConnection;
8. importjava.net.MalformedURLException;
9. importjava.net.URL;
10. importjava.util.List;
11. 
12. importjavax.xml.parsers.SAXParserFactory;
13. 
14. importorg.apache.http.HttpEntity;
15. importorg.apache.http.HttpHost;
16. importorg.apache.http.HttpRequest;
17. importorg.apache.http.HttpResponse;
18. importorg.apache.http.client.ClientProtocolException;
19. importorg.apache.http.client.HttpClient;
20. importorg.apache.http.client.ResponseHandler;
21. importorg.apache.http.client.methods.HttpGet;
22. importorg.apache.http.client.methods.HttpUriRequest;
23. importorg.apache.http.conn.ClientConnectionManager;
24. importorg.apache.http.impl.client.DefaultHttpClient;
25. importorg.apache.http.params.HttpParams;
26. importorg.apache.http.protocol.HttpContext;
27. importorg.apache.http.util.EntityUtils;
28. importorg.json.JSONArray;
29. importorg.json.JSONObject;
30. importorg.xml.sax.InputSource;
31. importorg.xml.sax.XMLReader;
32. importorg.xmlpull.v1.XmlPullParser;
33. importorg.xmlpull.v1.XmlPullParserFactory;
34. 
35. importcom.google.gson.Gson;
36. importcom.google.gson.reflect.TypeToken;
37. 
38. importandroid.annotation.SuppressLint;
39. importandroid.app.Activity;
40. importandroid.os.Bundle;
41. importandroid.os.Handler;
42. importandroid.os.Message;
43. importandroid.util.Log;
44. importandroid.view.Menu;
45. importandroid.view.View;
46. importandroid.view.View.OnClickListener;
47. importandroid.widget.Button;
48. importandroid.widget.TextView;
49. 
50. publicclassMainActivityextendsActivityimplementsOnClickListener{

51. 
52. publicstaticfinalintSHOW_RESPONSE=0;
53. privateButtonsendRequest=null;
54. privateTextViewresponseText=null;
55. 
56. privateHandlerhandler=newHandler(){

57. 
58. @Override
59. publicvoidhandleMessage(Messagemsg){

60. //TODOAuto-generatedmethodstub
61. super.handleMessage(msg);
62. switch(msg.what){

63. caseSHOW_RESPONSE:
64. Stringresponse=(String)msg.obj;
65. //在这里进行UI操作，将结果显示到界面上
66. responseText.setText(response);
67. break;
68. default:
69. break;
70. }
71. 
72. }
73. 
74. };
75. 
76. 
77. @Override
78. protectedvoidonCreate(BundlesavedInstanceState){

79. super.onCreate(savedInstanceState);
80. setContentView(R.layout.activity_main);
81. sendRequest=(Button)findViewById(R.id.send_request);
82. responseText=(TextView)findViewById(R.id.response_text);
83. sendRequest.setOnClickListener(this);
84. 
85. }
86. 
87. @Override
88. publicbooleanonCreateOptionsMenu(Menumenu){

89. //Inflatethemenu;thisaddsitemstotheactionbarifitispresent.
90. getMenuInflater().inflate(R.menu.main,menu);
91. returntrue;
92. }
93. 
94. @Override
95. publicvoidonClick(Viewv){

96. //TODOAuto-generatedmethodstub
97. if(v.getId()==R.id.send_request){

98. //sendRequestWithHttpURLConnection();
99. sendRequestWithHttpClient();
100. }
101. 
102. }
103. 
104. 
105. privatevoidsendRequestWithHttpURLConnection(){

106. //开启线程来发起网络请求
107. newThread(newRunnable(){

108. 
109. @Override
110. publicvoidrun(){

111. //TODOAuto-generatedmethodstub
112. HttpURLConnectionconnection=null;
113. 
114. try{

115. URLurl=newURL("http://www.baidu.com");
116. connection=(HttpURLConnection)url.openConnection();
117. connection.setRequestMethod("GET");
118. connection.setConnectTimeout(8000);
119. connection.setReadTimeout(8000);
120. InputStreamin=connection.getInputStream();
121. //下面对获取到的输入流进行读取
122. BufferedReaderreader=newBufferedReader(newInputStreamReader(in));
123. StringBuilderresponse=newStringBuilder();
124. Stringline;
125. while((line=reader.readLine())!=null){

126. response.append(line);
127. }
128. Messagemessage=newMessage();
129. message.what=SHOW_RESPONSE;
130. //将服务器返回的结果存放到Message中
131. message.obj=response.toString();
132. handler.sendMessage(message);
133. 
134. 
135. }catch(MalformedURLExceptione){

136. //TODOAuto-generatedcatchblock
137. e.printStackTrace();
138. }catch(Exceptione){

139. e.printStackTrace();
140. }finally{

141. if(connection!=null){

142. connection.disconnect();
143. }
144. }
145. }
146. 
147. }).start();
148. 
149. 
150. }
151. 
152. 
153. privatevoidsendRequestWithHttpClient(){

154. newThread(newRunnable(){

155. 
156. @Override
157. publicvoidrun(){

158. //TODOAuto-generatedmethodstub
159. try{

160. HttpClienthttpClient=newDefaultHttpClient();
161. //HttpGethttpGet=newHttpGet("http://www.baidu.com");
162. //指定访问的服务器地址是电脑本机，10.0.2.2对模拟器来说就是电脑本机的ip地址
163. //8080为端口号
164. //HttpGethttpGet=newHttpGet("http://10.0.2.2:8080/get_data.xml");
165. HttpGethttpGet=newHttpGet("http://10.0.2.2:8080/get_data.json");
166. HttpResponsehttpResponse=httpClient.execute(httpGet);
167. if(httpResponse.getStatusLine().getStatusCode()==200){

168. //请求和响应都成功了
169. HttpEntityentity=httpResponse.getEntity();
170. Stringresponse=EntityUtils.toString(entity,"utf-8");
171. //调用parseXMLWithPull方法解析服务器返回的数据
172. //parseXMLWithPull(response);
173. 
174. //调用parseXMLWithSAX方法解析服务器返回的数据
175. //parseXMLWithSAX(response);
176. 
177. //调用parseJSONWithJSONObject方法解析服务器返回的数据
178. //parseJSONWithJSONObject(response);
179. 
180. 
181. 
182. //调用parseJSONWithGSON方法解析服务器返回的数据
183. parseJSONWithGSON(response);
184. 
185. Messagemessage=newMessage();
186. message.what=SHOW_RESPONSE;
187. //将服务器返回的结果存放到Message中
188. message.obj=response.toString();
189. handler.sendMessage(message);
190. }
191. }catch(Exceptione){

192. e.printStackTrace();
193. }
194. }
195. 
196. }).start();
197. 
198. }
199. 
200. //使用Pull解析xml
201. privatevoidparseXMLWithPull(StringxmlData){

202. //Log.d("MainActivity","parseXMLWithPull(StringxmlData)");
203. try{

204. //获取到XmlPullParserFactory的实例，并借助这个实例得到XmlPullParser对象
205. XmlPullParserFactoryfactory=XmlPullParserFactory.newInstance();
206. XmlPullParserxmlPullParser=factory.newPullParser();
207. //调用XmlPullParser的setInput方法将服务器返回的xml数据设置进去开始解析
208. xmlPullParser.setInput(newStringReader(xmlData));
209. //通过getEventType()方法得到当前解析事件
210. inteventType=xmlPullParser.getEventType();
211. Stringid="";
212. Stringname="";
213. Stringversion="";
214. while(eventType!=XmlPullParser.END_DOCUMENT){

215. //通过getName()方法得到当前节点的名字，如果发现节点名等于id、name、或version
216. //就调用nextText()方法来获取结点具体的内容，每当解析完一个app结点就将获取到的内容打印出来
217. StringnodeName=xmlPullParser.getName();
218. //Log.d("MainActivity",""+eventType+"nodeName="+nodeName);
219. switch(eventType){

220. //开始解析某个节点
221. caseXmlPullParser.START_TAG:{

222. if("id".equals(nodeName)){

223. id=xmlPullParser.nextText();
224. }elseif("name".equals(nodeName)){

225. name=xmlPullParser.nextText();
226. }elseif("version".equals(nodeName)){

227. version=xmlPullParser.nextText();
228. }
229. break;
230. }
231. caseXmlPullParser.END_TAG:{

232. if("app".equals(nodeName)){

233. Log.d("MainActivity","idis"+id);
234. Log.d("MainActivity","nameis"+name);
235. Log.d("MainActivity","versionis"+version);
236. }
237. break;
238. }
239. default:
240. break;
241. }
242. //调用next()方法获取到下一个解析事件
243. eventType=xmlPullParser.next();
244. }
245. }catch(Exceptione){

246. e.printStackTrace();
247. }
248. }
249. 
250. 
251. //进行SAX解析的函数
252. privatevoidparseXMLWithSAX(StringxmlData){

253. /*
254. *parseXMLWithSAX方法中先创建一个SAXParserFactory的对象，然后再获取到
255. *XMLReader对象，接着将我们编写的ContentHandler的实例设置到XMLReader中，
256. *最后调用parse()方法开始执行解析。
257. **/
258. try{

259. SAXParserFactoryfactory=SAXParserFactory.newInstance();
260. XMLReaderxmlReader=factory.newSAXParser().getXMLReader();
261. ContentHandlerhandler=newContentHandler();
262. //将ContentHandler的实例设置到XMLReader中
263. xmlReader.setContentHandler(handler);
264. //开始执行解析
265. xmlReader.parse(newInputSource(newStringReader(xmlData)));
266. 
267. }catch(Exceptione){

268. e.printStackTrace();
269. }
270. }
271. 
272. 
273. 
274. //使用JSONObject解析json格式的数据
275. privatevoidparseJSONWithJSONObject(StringjsonData){

276. /*
277. *首先把http请求的地址改成http://localhost:8080/get_data.json，然后在得到服务器返回
278. *的数据后调用parseJSONWithJSONObject()方法来解析数据。由于我们在服务器中定义的是一个json数组，
279. *因此解析的时候首先是将服务器返回的数据传入到一个JSONArray对象中。然后循环遍历这个JSONArray，从
280. *中取出的每一个元素都是一个JSONObject对象，每个JSONObject对象中又包含了id,name和version这些
281. *数据。接下来只需要调用getString()方法将这些数据取出，并打印出来即可。
282. **/
283. try{

284. JSONArrayjsonArray=newJSONArray(jsonData);
285. for(inti=0;i<jsonArray.length();i++){

286. JSONObjectjsonObject=jsonArray.getJSONObject(i);
287. Stringid=jsonObject.getString("id");
288. Stringname=jsonObject.getString("name");
289. Stringversion=jsonObject.getString("version");
290. Log.d("MainActivity","idis"+id);
291. Log.d("MainActivity","nameis"+name);
292. Log.d("MainActivity","versionis"+version);
293. }
294. }catch(Exceptione){

295. e.printStackTrace();
296. }
297. }
298. 
299. 
300. 
301. //使用JSONWithGSON(StringjsonData)方法解析json格式的数据
302. privatevoidparseJSONWithGSON(StringjsonData){

303. Gsongson=newGson();
304. List<App>appList=gson.fromJson(jsonData,new
305. TypeToken<List<App>>(){}.getType());
306. for(Appapp:appList){

307. Log.d("MainActivity","idis"+app.getId());
308. Log.d("MainActivity","nameis"+app.getName());
309. Log.d("MainActivity","versionis"+app.getVersion());
310. }
311. }
312. 
313. 
314. 
315. }

运行程序，结果如下所示：

析，相信对json格式的数据应该不再陌生了。