androidjson解析及简单例子(转载).

合集下载

JSON详解以及在android中的使用

JSON
讲解：李志敏
9/7/2013
概念
• JSON (JavaScript Object Notation) is a lightweight data-interchange format. It is easy for humans to read and write. It is easy for machines to parse and generate. It is based on a subset of the JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999. JSON is a text format that is completely language independent but uses conventions that are familiar to programmers of the C-family of languages, including C, C++, C#, Java, JavaScript, Perl, Python, and many others. These properties make JSON an ideal data-interchange language. 官网/
9/7/2013
在Android中使用json
JSONArray
9/7/2013
在Android中使用json
JSONArray解析丼例
在服务器上有一个js文件http://192.168.1.101/Web/news.js文件内容如下： [{ title : "国家发改委：台湾降油价和大陆没可比性", description : "国家发改委副主仸朱之鑫", image : "http://192.168.1.101/Web/img/a.jpg", comment : 163 },{ title : "国家发改委：台湾降油价和大陆没可比性", description : "国家发改委副主仸朱之鑫", image : "http://192.168.1.101/Web/img/b.jpg", comment : 0 }, { title : "国家发改委：台湾降油价和大陆没可比性", description : "国家发改委副主仸朱之鑫", image : "http://192.168.1.101/Web/img/c.jpg", comment : 0 } ]; 9/7/2013

Android中gson、jsonobject解析JSON的方法详解

Android中gson、jsonobject解析JSON的⽅法详解JSON的定义：⼀种轻量级的数据交换格式，具有良好的可读和便于快速编写的特性。

业内主流技术为其提供了完整的解决⽅案（有点类似于正则表达式，获得了当今⼤部分语⾔的⽀持），从⽽可以在不同平台间进⾏数据交换。

JSON采⽤兼容性很⾼的⽂本格式，同时也具备类似于C语⾔体系的⾏为。

JSON对象:JSON中对象(Object)以"{"开始, 以"}"结束. 对象中的每⼀个item都是⼀个key-value对, 表现为"key:value"的形式, key-value对之间使⽤逗号分隔. 如:{"name":"coolxing", "age"=24, "male":true, "address":{"street":"huiLongGuan", "city":"beijing", "country":"china"}}. JSON对象的key只能是string类型的, ⽽value可以是string, number, false, true, null, Object对象甚⾄是array数组, 也就是说可以存在嵌套的情况.JSON数组:JSON数组(array)以"["开始, 以"]"结束, 数组中的每⼀个元素可以是string, number, false, true, null, Object对象甚⾄是array数组,数组间的元素使⽤逗号分隔. 如["coolxing", 24, {"street":"huiLongGuan", "city":"beijing", "country":"china"}].1.前⾔JSON数据是android⽹络开发中常见的数据格式。

json解析例子

下面这个是自己修改别人的小例子，主要是加一些注释和讲解，这个例子主要是使用android进行json解析。

1 单数据{'singer':{'id':01,'name':'tom','gender':'男'}}2 多个数据{"singers":[3 {'id':02,'name':'tom','gender':'男'},4 {'id':03,'name':'jerry,'gender':'男'},5 {'id':04,'name':'jim,'gender':'男'},6 {'id':05,'name':'lily,'gender':'女'}]}下面的类主要是解析单个数据parseJson（）和多个数据的方法parseJsonMulti（）:查看源码打印?01 public class JsonActivity extends Activity {02 /** Called when the activity is first created. */03 private TextView tvJson;04 private Button btnJson;05 private Button btnJsonMulti;06 @Override07 public void onCreate(Bundle savedInstanceState) {08 super.onCreate(savedInstanceState);09 setContentView(yout.main);10 tvJson = (TextView) this.findViewById(Json);11 btnJson = (Button) this.findViewById(R.id.btnJson);12 btnJsonMulti = (Button) this.findViewById(R.id.btnJsonMulti);13 btnJson.setOnClickListener(new View.OnClickListener() {14 @Override15 public void onClick(View v) {16 // url17 // String strUrl = "http://10.158.166.110:8080/AndroidServer/JsonServlet";18 String strUrl = ServerPageUtil.getStrUrl(UrlsOfServer.JSON_SINGER);19 //获得返回的Json字符串20 String strResult = connServerForResult(strUrl);21 //解析Json字符串22 parseJson(strResult);23 }24 });25 btnJsonMulti.setOnClickListener(new View.OnClickListener() {26 @Override27 public void onClick(View v) {28 String strUrl = ServerPageUtil.getStrUrl(UrlsOfServer.JSON_SINGERS);29 String strResult = connServerForResult(strUrl);30 //获得多个Singer31 parseJsonMulti(strResult);32 }33 });34 }35 private String connServerForResult(String strUrl) {36 // HttpGet对象37 HttpGet httpRequest = new HttpGet(strUrl);38 String strResult = "";39 try {40 // HttpClient对象41 HttpClient httpClient = new DefaultHttpClient();42 // 获得HttpResponse对象43 HttpResponse httpResponse = httpClient.execute(httpRequest);44 if (httpResponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {45 // 取得返回的数据46 strResult = EntityUtils.toString(httpResponse.getEntity());47 }48 } catch (ClientProtocolException e) {49 tvJson.setText("protocol error");50 e.printStackTrace();51 } catch (IOException e) {52 tvJson.setText("IO error");53 e.printStackTrace();54 }55 return strResult;56 }57 // 普通Json数据解析58 private void parseJson(String strResult) {59 try {60 JSONObject jsonObj = new JSONObject(strResult).getJSONObject("singer");61 int id = jsonObj.getInt("id");62 String name = jsonObj.getString("name");63 String gender = jsonObj.getString("gender");64 tvJson.setText("ID号"+id + ", 姓名：" + name + ",性别：" + gender);65 } catch (JSONException e) {66 System.out.println("Json parse error");67 e.printStackTrace();68 }69 }70 //解析多个数据的Json71 private void parseJsonMulti(String strResult) {72 try {73 JSONArray jsonObjs = new JSONObject(strResult).getJSONArray("singers");74 String s = "";75 for(int i = 0; i < jsonObjs.length() ; i++){76 JSONObject jsonObj = ((JSONObject)jsonObjs.opt(i))77 .getJSONObject("singer");78 int id = jsonObj.getInt("id");79 String name = jsonObj.getString("name");80 String gender = jsonObj.getString("gender");81 s += "ID号"+id + ", 姓名：" + name + ",性别：" + gender+ "\n" ;82 }83 tvJson.setText(s);84 } catch (JSONException e) {85 System.out.println("Jsons parse error !");86 e.printStackTrace();87 }88 }89 }。

Android解析json数据示例代码（三种方式）

Android解析json数据⽰例代码（三种⽅式）Json数据复制代码代码如下: [{"code":"110000","sheng":"11","di":"00","xian":"00","name":"北京市","level":1}, {"code":"659004","sheng":"65","di":"90","xian":"04","name":"五家渠市","level":3}, {"code":"710000","sheng":"71","di":"00","xian":"00","name":"台湾省","level":1}, {"code":"810000","sheng":"81","di":"00","xian":"00","name":"⾹港特别⾏政区","level":1}, {"code":"820000","sheng":"82","di":"00","xian":"00","name":"澳门特别⾏政区","level":1}]三种解析⽅式android⾃带解析，Gson解析，FastJson解析1、android⾃带解析json_btn.setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View v) {String s = getString();Log.d("txt",s);List<City> list = new ArrayList<City>();try {JSONArray obj = new JSONArray(s);for(int i=0;i<obj.length();i++){JSONObject jsonobj = (JSONObject)obj.get(i);City city = new City();city.setCode(jsonobj.getString("code"));city.setSheng(jsonobj.optString("sheng"));city.setDi(jsonobj.optString("di"));city.setXian(jsonobj.optString("xian"));city.setName(jsonobj.optString("name"));city.setLevel(jsonobj.optInt("level"));Log.d("txt",city.toString());textView.append(city.toString());}} catch (JSONException e) {e.printStackTrace();}}});先获取JSON数组，在解析JsonObject。

Android 中的JSON 数据处理

Android 中的JSON 数据处理Android 中的 JSON 数据处理在 Android 开发中，我们经常需要与服务器进行数据交互，而大多数情况下服务器返回的数据格式都是使用 JSON（JavaScript Object Notation）来表示。

因此，了解和掌握如何在 Android 中处理 JSON 数据是非常重要的。

本文将介绍 Android 中的 JSON 数据处理，包括解析 JSON 数据、构建 JSON 数据、以及处理 JSON 中的数组和对象等。

1. 解析 JSON 数据在 Android 中，可以使用 JSONObject 和 JSONArray 来解析 JSON 数据。

JSONObject 是一个键值对的集合，而 JSONArray 是一个有序的值的集合。

以下是一个解析 JSON 数据的示例代码：```javatry {String jsonString = "{ \"name\":\"John\", \"age\":30, \"city\":\"New York\" }";JSONObject jsonObject = new JSONObject(jsonString);String name = jsonObject.getString("name");int age = jsonObject.getInt("age");String city = jsonObject.getString("city");Log.d("JSON", "Name: " + name);Log.d("JSON", "Age: " + age);Log.d("JSON", "City: " + city);} catch (JSONException e) {e.printStackTrace();}```2. 构建 JSON 数据在 Android 中，可以使用 JSONObject 和 JSONArray 来构建 JSON 数据。

AndroidJSON数据解析（数据传输）

AndroidJSON数据解析（数据传输）上篇随笔详细介绍了三种解析服务器端传过来的xml数据格式，⽽对于服务器端来说，返回给客户端的数据格式⼀般分为html、xml和json这三种格式，那么本篇随笔将讲解⼀下json这个知识点，包括如何通过json-lib和gson这两个json解析库来对解析我们的json数据，以及如何在我们的Android客户端解析来⾃服务器端的json数据，并更新到UI当中。

⼀、什么是jsonjson(Javascript Object Notation)是⼀种轻量级的数据交换格式，相⽐于xml这种数据交换格式来说，因为解析xml⽐较的复杂，⽽且需要编写⼤段的代码，所以客户端和服务器的数据交换格式往往通过json来进⾏交换。

尤其是对于web开发来说，json数据格式在客户端直接可以通过javascript来进⾏解析。

json⼀共有两种数据结构，⼀种是以 (key/value)对形式存在的⽆序的jsonObject对象，⼀个对象以“{”（左花括号）开始，“}”（右花括号）结束。

每个“名称”后跟⼀个“:”（冒号）；“‘名称/值’ 对”之间使⽤“,”（逗号）分隔。

例如：{"name": "xiaoluo"}，这就是⼀个最简单的json对象，对于这种数据格式，key值必须要是string类型，⽽对于value，则可以是string、number、object、array等数据类型：另⼀种数据格式就是有序的value的集合，这种形式被称为是jsonArray，数组是值（value）的有序集合。

⼀个数组以“[”（左中括号）开始，“]”（右中括号）结束。

值之间使⽤“,”（逗号）分隔。

⼆、解析json数据格式这⾥将使⽤两种json的解析库来对我们的json数据格式进⾏解析以及⽣成我们的json数据格式。

使⽤json-lib来进⾏解析，我们需要引⼊第三⽅的包，因为json-lib分为了两个版本，⼀个版本是针对于jdk1.3的，⼀个版本是针对于jdk1.5的，这⾥我们下载jdk1.5的这个json-lib包，其中还需要引⼊其他的⼏个jar包：下载好这⼏个jar包后，加⼊到classpath中即可。

android解析网络数据（JSON）

android解析⽹络数据（JSON）解析json数据，获取你需要的信息⾸先在manifest中添加允许访问⽹络的权限信息<uses-permission android:name="android.permission.INTERNET"/>Mainpackage com.chuanxidemo.shaoxin.demo08;import android.os.Bundle;import android.support.annotation.Nullable;import android.support.v7.app.AppCompatActivity;import android.util.Log;import android.view.View;import android.widget.Button;import android.widget.TextView;import org.json.JSONArray;import org.json.JSONException;import org.json.JSONObject;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader;import .HttpURLConnection;import .MalformedURLException;import .URL;/*** Created by shaoxin on 2017/2/25.*/public class Main extends AppCompatActivity {private TextView txt;private Button btn2;private BufferedReader bufferedReader;private StringBuffer stringBuffer;@Overrideprotected void onCreate(@Nullable Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(yout.main);stringBuffer = new StringBuffer();txt = (TextView) findViewById(R.id.txt);btn2 = (Button) findViewById(R.id.btn2);btn2.setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View v) {new Thread(){@Overridepublic void run() {//使⽤线程的⽬的是防⽌该过程在主线程中运⾏super.run();getData();parseJsonData(getData());}}.start();//解析}});}private void parseJsonData (String string){//try\{jsonp9+?\((.+?)\)\}catch\(e\)\{\}try {//解析的过程就是在逐层剥开代码的过程JSONObject jsonObject = new JSONObject(string);//每⼀层都是⼀个Object对象Log.v("msg",jsonObject.get("try").toString());Log.i("msg", "parseJsonData: "+jsonObject.getString("timestamp"));jsonObject.getJSONObject("data");JSONArray jsonArray = jsonObject.getJSONArray("tvQipuId");//对象中的数组Log.i("msg", "parseJsonData: "+jsonArray.get(0).toString());} catch (JSONException e) {e.printStackTrace();}}private String getData() {try {URL url = new URL("/jp/avlist/202861101/1/?callback=jsonp9");//json地址 HttpURLConnection connection = (HttpURLConnection) url.openConnection();connection.setRequestMethod("GET");//使⽤get⽅法接收InputStream inputStream = connection.getInputStream();//得到⼀个输⼊流bufferedReader = new BufferedReader(new InputStreamReader(inputStream, "UTf-8"));String sread = null;while ((sread = bufferedReader.readLine()) != null) {stringBuffer.append(sread);stringBuffer.append("\r\n");}// Log.i("msg", "onClick: " + stringBuffer.toString());} catch (MalformedURLException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}return stringBuffer.toString();}}main.xml<?xml version="1.0" encoding="utf-8"?><LinearLayout xmlns:android="/apk/res/android"android:layout_width="match_parent"android:layout_height="match_parent"android:orientation="vertical"><TextViewandroid:id="@+id/txt"android:layout_width="wrap_content"android:layout_height="wrap_content"/><Buttonandroid:id="@+id/btn2"android:layout_width="wrap_content"android:layout_height="wrap_content"android:text="获取数据"/></LinearLayout>。

Android利用Gson解析嵌套多层的Json的简单方法

Android利⽤Gson解析嵌套多层的Json的简单⽅法⾸先先讲⼀个⽐较简单点的例⼦(最简单的我就不讲啦，⽹上很多)，帮助新⼿理解Gson的使⽤⽅法：⽐如我们要解析⼀个下⾯这种的Json：String json = {"a":"100","b":[{"b1":"b_value1","b2":"b_value2"},{"b1":"b_value1","b2":"b_value2"}]，"c":{"c1":"c_value1","c2":"c_value2"}}⾸先我们需要定义⼀个序列化的Bean，这⾥采⽤内部类的形式，看起来会⽐较清晰⼀些：public class JsonBean {public String a;public List<B> b;public C c;public static class B {public String b1;public String b2;}public static class C {public String c1;public String c2;}}很多时候⼤家都是不知道这个Bean是该怎么定义，这⾥⾯需要注意⼏点：1、内部嵌套的类必须是static的，要不然解析会出错；2、类⾥⾯的属性名必须跟Json字段⾥⾯的Key是⼀模⼀样的；3、内部嵌套的⽤[]括起来的部分是⼀个List，所以定义为 public List<B> b，⽽只⽤{}嵌套的就定义为 public C c，具体的⼤家对照Json字符串看看就明⽩了，不明⽩的我们可以互相交流，本⼈也是开发新⼿！Gson gson = new Gson();ng.reflect.Type type = new TypeToken<JsonBean>() {}.getType();JsonBean jsonBean = gson.fromJson(json, type);然后想拿数据就很简单啦，直接在jsonBean⾥⾯取就可以了！如果需要解析的Json嵌套了很多层，同样可以可以定义⼀个嵌套很多层内部类的Bean，需要细⼼的对照Json字段来定义哦。

Android技能-创建Json文本及Json解析

Android技能-创建Json文本及Json解析摘要：Json数据在安卓开发过程中是非常常见的，在请求服务器端数据的时候，服务器端返回的无非就是三种类型：HTML，XML，JSON。

所以学习JSON对安卓程序员来说是非常重要的。

什么是JSONJSON：JavaScript Object Notation。

顾名思义，JSON数据是源自于JavaScript，学习过JavaScript(以下简称JS)的人都知道，我们在JS脚本里面创建对象时，都是以键值对的形式编写的。

例如，我们在JS里面创建一个Json 对象时是这么定义的：var person = {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"};很容易看出，属性之间是通过逗号分隔开，键与值之间是通过双引号分隔开，而JSON数据也是如此。

JSON的数据类型json一共有两种数据结构。

JsonObject一种是以 (key/value)对形式存在的无序的jsonObject对象。

对象使用大括号括起来，属性之间使用逗号分隔开。

例如：{"name": "jack"}，这就是一个最简单的json对象，对于这种数据格式，key值必须要是string类型，而对于value，则可以是string、number、object、array等数据类型。

JsonArray另一种数据格式就是有序的value的集合，这种形式被称为是JsonArray。

数组是值的有序集合，值与值之间使用逗号分隔开，集合用中括号括起来。

创建JSON文本例如我们要创建以下类型的Jjson数据：{"person":{"name":"zhangsan", "phone":["123", "456"],"address":"guangdong"}}使用JSONOject和JSONArray创建/*** 使用JsonObject和JsonArray创建JSON对象*/public void makeJson() {try {JSONObject object = new JSONObject();JSONObject person = new JSONObject();//名字person.put("name", "zhangsan");//电话JSONArray phone = new JSONArray();phone.put("123").put("456");person.put("phone", phone);//地址person.put("address", "guangdong");object.put("person", person);Log.i("JSON_LOG", object.toString());} catch (JSONException e) {e.printStackTrace();}}输出结果使用JsonStringer创建/*** 通过JsonStringer创建JSON对象*/public void makeJsonStringer() {try {JSONStringer jsonText = new JSONStringer();// 首先是{，对象开始。

Android学习之解析Json

在线学习好工作/Android学习之解析Json解析Json有了请求，自然会有响应，那我们该如何解析服务端响应返回给我们的Json 数据呢？了解什么是JsonJSON（JavaScript object notation）是一种轻量级的数据交换格式。

它是基于ECMAscript的一个子集。

JSON采用完全独立于语言的文本格式，但是也是用的类似于c语言家族的习惯（包括c、c++、c#、java、javascript、perl、Python等）。

这些特性是JSON成为理想的数据交换语言。

易于人阅读和编写，同时也易于机器解析和生成（一般用于提升网络传输速率）。

JSON的语法规则JSON是JavaScript对象表示语法的子集。

1) 数据在键值对中。

2) 数据由逗号分隔3) 花括号保存对象4) 方括号保存数组JSON的值可以是？1) 数字（整数或浮点数）2) 字符串（在双引号中）3) 逻辑值（true或false）4) 数组（在方括号中）5) 对象（在花括号中）6) null代码演示，如何解析JSON格式数据？1) 使用之前演示HttpGet和HttpPost时，已经写好的可以得到从服务器返回的JSON格式的字符串的代码。

调用parseData()方法，传递参数result。

如下图：得到的需要解析的JSON数据如下图所示：2) 根据分析JSON数据的格式，这里可以看出JSON格式解析到最里层，得到的是一组一组的对象，对象里面包含name和sex属性。

所以，在这里构造出一个对应该对象的实体类，并提供对外访问的getter和setter方法。

3) 这里我们重写tostring()方法，通过调用此方法，可以打印出该对象的name 值和sex值，这样做是为了待会儿打印出对象的属性值，展示效果。

4) 由于得到的最里层的member对象的集合，这里采用list包装。

由于这里提供的这段JSON格式的数据最外层是对象包装，所以可以采用sun 公司原生提供的JSONObject类，传入对象格式的JSON数据构造一个JOSNObject 的对象。

浅谈Android项目----JSON解析（4种解析技术详解）

浅谈Android项⽬----JSON解析（4种解析技术详解）json简介1.概念:json全称是javaScript object Notation，是⼀种并轻量级的数据交换格式。

2.特点：1.本质就是具有特定格式的字符串2.json完全独⽴于编程语⾔3.json⽐xml数据传输的有效性要⾼出很多Android系统也原⽣的提供了JSON解析的API，但是它的速度很慢，⽽且没有提供简介⽅便的接⼝来提⾼开发者的效率和降低出错的可能。

因此，通常情况下，我们都会选择其他优秀的JSON解析实现，⽤以替代系统的API，⽬前JSON解析的开源实现主要包括⼀下三种：GsonJackJsonFastJsonJSON对象：JSON数组：先简单的来介绍⼀下原⽣的JSON解析API：他的特点是很⿇烦，对于复杂的json数据解析很容易出错使⽤:解析JSON对象的API：JsonObjectJSONObject(String json)；将Json字符串解析成Json对象；getXxx(String name) ；根据name在json对象中得到相应的value值;private String ObjectanalysisTest(String string) {try {JSONObject jsonObject = new JSONObject(string);String name = jsonObject.getString("name");int age = jsonObject.optInt("age");String sex = jsonObject.optString("sex");return "name：" + name + " age：" + age + " sex：" + sex;} catch (JSONException e) {e.printStackTrace();}return null;}解析Json数组的API：JSONArrayJSONArray(String json)；将json字符串解析成json数组；int length()；得到json数组中元素的个数；getXxx(String name) ；根据name得到json数组中对应的元素数据。

Android 中的json解析

Android 中的json解析一．Json的两种结构对象：对象在js中表示为“{}”括起来的内容，数据结构为{key：value,key：value,...}的键值对的结构，在面向对象的语言中，key为对象的属性，value为对应的属性值，所以很容易理解，取值方法为对象.key数组：数组在js中是中括号“[]”括起来的内容，数据结构为["java","javascript","vb",...]二．使用org.json包JSONObject和JSONArray进行解析1. json1： <code>{"name":"sam","age":18,"weight":60}一个json对象2.json2:[12,13,15] //json2 一个数字数组3.json3[{"name":"sam","age":18},{"name":"leo","age":19},{"name":"sky", "age":20}第一个json对象json1的解析JSONObject jsonObj = new JSONObject(json1);String name = jsonObj.optString("name");int age = jsonObj.optInt("age");int weight = jsonObj.optInt("weight");第二个json对象json2的解析jsonArray = new JSONArray(json2);for(int= 0; i < jsonArray.length();i++) {int age = jsonArray.optInt(i);}第三个json对象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");另外还有:Object opt（String name）boolean optBoolean(String name)double optDouble(String name)JSONArray optJSONArray(String name)JSONObject optJSONObject(String name)这些方法在解析时，如果对应字段不存在会返回空值或者0，不会报错。

Android中使用Gson解析JSON数据的两种方法

Android中使⽤Gson解析JSON数据的两种⽅法Json是⼀种类似于XML的通⽤数据交换格式,具有⽐XML更⾼的传输效率.从结构上看，所有的数据（data）最终都可以分解成三种类型：第⼀种类型是标量（scalar），也就是⼀个单独的字符串（string）或数字（numbers），⽐如"北京"这个单独的词。

第⼆种类型是序列（sequence），也就是若⼲个相关的数据按照⼀定顺序并列在⼀起，⼜叫做数组（array）或列表（List），⽐如"北京，上海"。

第三种类型是映射（mapping），也就是⼀个名/值对（Name/value），即数据有⼀个名称，还有⼀个与之相对应的值，这⼜称作散列（hash）或字典（dictionary），⽐如"⾸都：北京"。

Json的规格⾮常简单，只⽤⼀个页⾯⼏百个字就能说清楚，⽽且Douglas Crockford声称这个规格永远不必升级，因为该规定的都规定了。

1）并列的数据之间⽤逗号（"，"）分隔。

2）映射⽤冒号（"："）表⽰。

3）并列数据的集合（数组）⽤⽅括号("[]")表⽰。

4）映射的集合（对象）⽤⼤括号（"{}"）表⽰。

在Android中可以使⽤Gson解析JSON数据⾸先，从 /p/google-gson/downloads/list下载GsonAPI：google-gson-1.7.1-release.zip把gson-1.7.jar copy到libs(项⽬根⽬录新建⼀个libs⽂件夹)中。

可以使⽤以下两种⽅法解析JSON数据：通过获取JsonReader对象解析JSON数据：复制代码代码如下:String jsonData = "[{\"username\":\"arthinking\",\"userId\":001},{\"username\":\"Jason\",\"userId\":002}]";try{JsonReader reader = new JsonReader(new StringReader(jsonData));reader.beginArray();while(reader.hasNext()){reader.beginObject();while(reader.hasNext()){String tagName = reader.nextName();if(tagName.equals("username")){System.out.println(reader.nextString());}else if(tagName.equals("userId")){System.out.println(reader.nextString());}}reader.endObject();}reader.endArray();}catch(Exception e){e.printStackTrace();}通过把JSON数据映射成⼀个对象，使⽤Gson对象的fromJson()⽅法获取⼀个对象数组进⾏操作：创建JSON数据对应的⼀个POJO对象User.java：复制代码代码如下:public class User {private String username ;private int userId ;public String getUsername() {return username;}public void setUsername(String username) {ername = username;}public int getUserId() {return userId;}public void setUserId(int userId) {erId = userId;}}使⽤Gson对象获取User对象数据进⾏相应的操作：复制代码代码如下:Type listType = new TypeToken<LinkedList<User>>(){}.getType();Gson gson = new Gson();LinkedList<User> users = gson.fromJson(jsonData, listType);for (Iterator iterator = users.iterator(); iterator.hasNext();) {User user = (User) iterator.next();System.out.println(user.getUsername());System.out.println(user.getUserId());}如果要处理的JSON字符串只包含⼀个JSON对象，则可以直接使⽤fromJson获取⼀个User对象：复制代码代码如下:String jsonData = "{\"username\":\"arthinking\",\"userId\":001}";Gson gson = new Gson();User user = gson.fromJson(jsonData, User.class);System.out.println(user.getUsername());System.out.println(user.getUserId());。

android中常用的json,xml,gson解析的原理

android中常用的json,xml,gson解析的原理在Android应用程序开发中，我们常常需要处理各种数据格式，其中JSON和XML是最常用的两种。

另外，随着数据处理的复杂度增加，我们还需要使用一些工具库如GSON来解析和生成这些数据格式。

本文将详细介绍Android中常用的JSON、XML、GSON解析的原理。

一、JSON解析原理JSON（JavaScriptObjectNotation）是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。

在Android中，我们通常使用各种库来解析JSON数据，其中最常见的是org.json和Gson。

.json解析原理org.json是一个轻量级的JSON解析库，它提供了简单易用的API来解析和生成JSON数据。

在Android中，我们可以通过以下步骤使用org.json库解析JSON数据：（1）引入org.json库。

（2）创建JSONObject或JSONArray对象，并使用API将JSON数据转换为该对象。

（3）使用API获取JSONObject或JSONArray中的数据。

org.json解析速度快，且提供了丰富的API来操作JSON数据，但是需要注意的是，org.json库只支持到JSON2019版本为止的JSON语法。

2.Gson解析原理Gson是Google开发的一个Java库，用于将Java对象转换为JSON格式的数据，以及将JSON数据转换回Java对象。

在Android中，我们通常使用Gson库来解析JSON数据。

Gson库提供了简单易用的API，可以方便地将Java对象转换为JSON格式的数据，同时也可以将JSON数据转换为Java对象。

Gson解析JSON数据的基本步骤如下：（1）引入Gson库。

（2）创建Gson对象。

（3）使用Gson对象的fromJson方法将JSON数据转换为Java对象。

（4）使用Gson对象的toJson方法将Java对象转换为JSON数据。

Android-解析JSON数据（JSON对象JSON数组）

Android-解析JSON数据（JSON对象JSON数组）在上⼀篇博客中，，讲解到Android真实开发中更多的是去解析JSON数据（JSON对象/JSON数组）封装JSON的数据是在服务器端进⾏封装了，Android更多的⼯作是解析（JSON对象/JSON数组），所以Android开发JSON数据的解析⾮常重要JSON数据，是存储在⽂件⾥⾯：/data/data/liudeli.mynetwork01/files/pottingJSON1{"name":"李四","age":99,"hobby":"爱好是练习截拳道"}/data/data/liudeli.mynetwork01/files/pottingJSON2{"student":{"name":"李四","age":99,"hobby":"爱好是练习截拳道"}}/data/data/liudeli.mynetwork01/files/pottingJSON3{"student":{"name":"李四","age":99,"hobby":"爱好是练习截拳道","dog":{"name":"阿黄","age":77,"sex":"母"}}}/data/data/liudeli.mynetwork01/files/pottingJSONArray1[{"name":"君君","age":89,"sex":"男"},{"name":"⼩君","age":99,"sex":"⼥"},{"name":"⼤君","age":88,"sex":"男"}]/data/data/liudeli.mynetwork01/files/pottingJSONArray2{"person":[{"name":"君君","age":89,"sex":"男"},{"name":"⼩君","age":99,"sex":"⼥"},{"name":"⼤君","age":88,"sex":"男"}]}为什么要使⽤jsonObject.optString，不使⽤jsonObject.getString因为jsonObject.optString获取null不会报错看着JSON数据，⼀步⼀步的解析就好了，当明⽩JSON数据格式后，解析是⾮常容易的：AnalyzeJSONActivity.javapackage liudeli.mynetwork01;import android.app.Activity;import android.os.Bundle;import android.text.TextUtils;import android.util.Log;import android.view.View;import org.json.JSONArray;import org.json.JSONObject;import java.io.InputStream;public class AnalyzeJSONActivity extends Activity {private final String TAG = AnalyzeJSONActivity.class.getSimpleName();@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(yout.activity_analyze_json);}/*** 解析JSON对象* {* "name":"李四",* "age":99,* "hobby":"爱好是练习截拳道"* }* @param view*/public void analyzeJSON1(View view) {String result = readFile("pottingJSON1");// Log.d(TAG, "result:" + result);try{JSONObject jsonObject = new JSONObject(result);/*** 为什么要使⽤jsonObject.optString，不使⽤jsonObject.getString* 因为jsonObject.optString获取null不会报错*/String name = jsonObject.optString("name", null);int age = jsonObject.optInt("age", 0);String hobby = jsonObject.optString("hobby", null);// ⽇志打印结果：Log.d(TAG, "analyzeJSON1解析的结果：name:" + name + " age:" + age + " hobby:" + hobby);} catch (Exception e) {e.printStackTrace();}}/*** 解析JSON对象-带Key* {* "student":{* "name":"李四",* "age":99,* "hobby":"爱好是练习截拳道"* }* }* @param view*/public void analyzeJSON2(View view) {String result = readFile("pottingJSON2");// Log.d(TAG, "result:" + result);try{// 整个最⼤的JSON对象JSONObject jsonObjectALL = new JSONObject(result);/*** 为什么要使⽤jsonObject.optString，不使⽤jsonObject.getString* 因为jsonObject.optString获取null不会报错*/String student = jsonObjectALL.optString("student", null);if (!TextUtils.isEmpty(student)) {JSONObject jsonObject = new JSONObject(student);String name = jsonObject.optString("name", null);int age = jsonObject.optInt("age", 0);String hobby = jsonObject.optString("hobby", null);// ⽇志打印结果：Log.d(TAG, "analyzeJSON2解析的结果：name:" + name + " age:" + age + " hobby:" + hobby); }} catch (Exception e) {e.printStackTrace();}}/*** 解析JSON对象-嵌套对象* {* "student":{* "name":"李四",* "age":99,* "hobby":"爱好是练习截拳道",* "dog":{* "name":"阿黄",* "age":77,* "sex":"母"* }* }* }* @param view*/public void analyzeJSON3(View view) {String result = readFile("pottingJSON3");// Log.d(TAG, "result:" + result);try{// 整个最⼤的JSON对象JSONObject jsonObjectALL = new JSONObject(result);/*** 为什么要使⽤jsonObject.optString，不使⽤jsonObject.getString* 因为jsonObject.optString获取null不会报错*/String student = jsonObjectALL.optString("student", null);if (!TextUtils.isEmpty(student)) {JSONObject jsonObject = new JSONObject(student);String name = jsonObject.optString("name", null);int age = jsonObject.optInt("age", 0);String hobby = jsonObject.optString("hobby", null);// 以下是dog JSON 对象相关的解析String dogStr = jsonObject.optString("dog", null);// 定义dog的JSON对象JSONObject dogJSONObject = new JSONObject(dogStr);String dogName = dogJSONObject.optString("name", null);int dogAge = dogJSONObject.optInt("age", 0);String dogSex = dogJSONObject.optString("sex", null);// ⽇志打印结果：Log.d(TAG, "analyzeJSON3解析的结果：name:" + name + " age:" + age + " hobby:" + hobby + "\n"+ "dogName:" + dogName + " dogAge:" + dogAge + " dogSex:" + dogSex);}} catch (Exception e) {e.printStackTrace();}}/*** 解析JSON数组* [* {* "name":"君君",* "age":89,* "sex":"男"* },* {* "name":"⼩君",* "age":99,* "sex":"⼥"* },* {* "name":"⼤君",* "age":88,* "sex":"男"* }* ]* @param view*/public void analyzeJSONArray1(View view) {String result = readFile("pottingJSONArray1");// Log.d(TAG, "result:" + result);try{// 整个最⼤的JSON数组JSONArray jsonArray = new JSONArray(result);Log.d(TAG, "analyzeJSONArray1 jsonArray:" + jsonArray);// [{"name":"君君","age":89,"sex":"男"},{"name":"⼩君","age":99,"sex":"⼥"},{"name":"⼤君","age":88,"sex":"男"}] for (int i = 0; i < jsonArray.length(); i++) {// JSON数组⾥⾯的具体-JSON对象JSONObject jsonObject = jsonArray.getJSONObject(i);String name = jsonObject.optString("name", null);int age = jsonObject.optInt("age", 0);String sex = jsonObject.optString("sex", null);// ⽇志打印结果：Log.d(TAG, "analyzeJSONArray1 解析的结果：name" + name + " age:" + age + " sex:" + sex);}} catch (Exception e) {e.printStackTrace();}}/*** 解析JSON数组-带Key* {* "person":[* {* "name":"君君",* "age":89,* "sex":"男"* },* {* "name":"⼩君",* "age":99,* "sex":"⼥"* },* {* "name":"⼤君",* "age":88,* "sex":"男"* }* ]* }* @param view*/public void analyzeJSONArray2(View view) {String result = readFile("pottingJSONArray2");// Log.d(TAG, "result:" + result);try{/*** JSON数组在⽜逼，⼀旦有了 key person 这样的标记，就必须先是个 JSON对象* 最外层的JSON对象，最⼤的哪个 { ... }*/JSONObject jsonObjectALL = new JSONObject(result);// 通过标识(person)，获取JSON数组JSONArray jsonArray = jsonObjectALL.getJSONArray("person");Log.d(TAG, "analyzeJSONArray1 jsonArray:" + jsonArray);// [{"name":"君君","age":89,"sex":"男"},{"name":"⼩君","age":99,"sex":"⼥"},{"name":"⼤君","age":88,"sex":"男"}] for (int i = 0; i < jsonArray.length(); i++) {// JSON数组⾥⾯的具体-JSON对象JSONObject jsonObject = jsonArray.getJSONObject(i);String name = jsonObject.optString("name", null);int age = jsonObject.optInt("age", 0);String sex = jsonObject.optString("sex", null);// ⽇志打印结果：Log.d(TAG, "analyzeJSONArray2 解析的结果：name" + name + " age:" + age + " sex:" + sex);}} catch (Exception e) {e.printStackTrace();}}/*** 读取⽂件⾥⾯的字符串* @param fileName* @return*/private String readFile(String fileName) {String result = null;try {InputStream inputStream = openFileInput(fileName);byte[] bytes = new byte[inputStream.available()];inputStream.read(bytes);result = new String(bytes);inputStream.close();} catch (Exception e) {e.printStackTrace();}return result;}/*** 定义⼀个Bean*//*class Student {private String name;private int age;private String hobby;public Student(String name, int age, String hobby) { = name;this.age = age;this.hobby = hobby;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +", hobby='" + hobby + '\'' +'}';}}*/}activity_analyze_json.xml<?xml version="1.0" encoding="utf-8"?><LinearLayoutxmlns:android="/apk/res/android"xmlns:tools="/tools"android:layout_width="match_parent"android:layout_height="match_parent"android:orientation="vertical"tools:context=".MainActivity"><LinearLayoutandroid:layout_width="match_parent"android:layout_height="wrap_content"><Buttonandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="解析JSON对象"android:onClick="analyzeJSON1"android:layout_weight="1"/><Buttonandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="解析JSON对象-带Key"android:onClick="analyzeJSON2"android:layout_weight="1"/><Buttonandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="解析JSON对象-嵌套对象"android:onClick="analyzeJSON3"android:layout_weight="1"/></LinearLayout><LinearLayoutandroid:layout_width="match_parent"android:layout_height="wrap_content"><Buttonandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="解析JSON数组"android:onClick="analyzeJSONArray1"android:layout_weight="1"/><Buttonandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="解析JSON数组-带Key"android:onClick="analyzeJSONArray2"android:layout_weight="1"/></LinearLayout></LinearLayout>所有解析JSON的Log打印：analyzeJSON112-23 21:46:44.127 8204-8204/liudeli.mynetwork01 D/AnalyzeJSONActivity: analyzeJSON1解析的结果：name:李四 age:99 hobby:爱好是练习截拳道analyzeJSON212-23 21:46:59.161 8204-8204/liudeli.mynetwork01 D/AnalyzeJSONActivity: analyzeJSON2解析的结果：name:李四 age:99 hobby:爱好是练习截拳道analyzeJSON312-23 21:47:12.240 8204-8204/liudeli.mynetwork01 D/AnalyzeJSONActivity: analyzeJSON3解析的结果：name:李四 age:99 hobby:爱好是练习截拳道dogName:阿黄 dogAge:77 dogSex:母analyzeJSONArray112-23 21:47:35.108 8204-8204/liudeli.mynetwork01 D/AnalyzeJSONActivity: analyzeJSONArray1 解析的结果：name君君 age:89 sex:男12-23 21:47:35.108 8204-8204/liudeli.mynetwork01 D/AnalyzeJSONActivity: analyzeJSONArray1 解析的结果：name⼩君 age:99 sex:⼥12-23 21:47:35.108 8204-8204/liudeli.mynetwork01 D/AnalyzeJSONActivity: analyzeJSONArray1 解析的结果：name⼤君 age:88 sex:男analyzeJSONArray212-23 21:47:55.457 8204-8204/liudeli.mynetwork01 D/AnalyzeJSONActivity: analyzeJSONArray2 解析的结果：name君君 age:89 sex:男12-23 21:47:55.457 8204-8204/liudeli.mynetwork01 D/AnalyzeJSONActivity: analyzeJSONArray2 解析的结果：name⼩君 age:99 sex:⼥12-23 21:47:55.457 8204-8204/liudeli.mynetwork01 D/AnalyzeJSONActivity: analyzeJSONArray2 解析的结果：name⼤君 age:88 sex:男。

android 手写gson解析

android 手写gson解析在 Android 开发中，可以使用 Gson 库来进行 JSON 数据的解析。

Gson 是一个流行的 Java 库，用于将 JSON 字符串转换为 Java 对象，以及将 Java 对象转换为 JSON 字符串。

要使用 Gson 进行手写解析，你可以按照以下步骤进行操作：1.添加 Gson 库：首先，你需要将 Gson 库添加到你的 Android 项目中。

你可以在项目的构建文件（例如 Gradle）中添加 Gson 的依赖。

2.创建 JSON 字符串：将要解析的 JSON 数据作为字符串进行表示。

3.创建 Java 对象：根据 JSON 字符串的结构，创建相应的 Java 对象。

4.使用 Gson 解析 JSON：使用 Gson 的`fromJson`方法将 JSON 字符串解析为 Java 对象。

5.访问解析后的数据：一旦解析完成，你可以通过访问 Java 对象的属性来获取解析后的数据。

以下是一个简单的示例，演示了如何使用Gson 进行手写解析JSON 数据：```javaimport com.google.gson.Gson;public class GsonParsingExample {public static void main(String[] args) {// 假设有一个 JSON 字符串String jsonString = "{\"id\": 1, \"name\": \"John\", \"age\": 25}";// 创建一个 Java 对象来匹配 JSON 结构Person person = new Person();// 使用 Gson 解析 JSON 字符串Gson gson = new Gson();person = gson.fromJson(jsonString, Person.class);// 访问解析后的数据int id = person.getId();String name = person.getName();int age = person.getAge();// 输出解析后的数据System.out.println("ID: " + id);System.out.println("Name: " + name); System.out.println("Age: " + age); }// 定义一个匹配 JSON 结构的 Java 对象static class Person {private int id;private String name;private int age;// 获取器和设置器public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}}}```在上述示例中，我们创建了一个名为`Person`的 Java 对象，它具有`id`、`name`和`age`属性。

Android 解析后台返回为Json数据的简单例子

�下如容内辑编�的么什者或本事记
用�psj.2xedni 个一建新后然,psj.xedni 到找下 TOOR\sppabew 下录目装安 tacmoT 在们我
:下如录目程工 .omeDnosJ 程工 diordnA 个一建新
;tcejbONOSJ.nosj.gro tropmi ;noitpecxENOSJ.nosj.gro tropmi ;PTTH.locotorp.ptth.ehcapa.gro tropmi ;smaraPpttHcisaB.smarap.ptth.ehcapa.gro tropmi ;tneilCpttHtluafeD.tneilc.lpmi.ptth.ehcapa.gro tropmi ;teGpttH.sdohtem.tneilc.ptth.ehcapa.gro tropmi ;esnopseRpttH.ptth.ehcapa.gro tropmi ;ytitnEpttH.ptth.ehcapa.gro tropmi ;noitpecxEgnidocnEdetroppusnU.oi.avaj tropmi ;redaeRmaertStupnI.oi.avaj tropmi ;noitpecxEOI.oi.avaj tropmi ;omednosj.rotut.moc egakcap
段手析解的富丰有拥样同 LMX 和 NOSJ.2 同相本基性读可据数的 LMX 和 NOSJ.1 LMX sV NOSJ gro.nosJ – 。为行的系体言语
小积体的据数�讲来 LMX 于对相 NOSJ.3
便方加更互交的 tpircSavaJ 与 NOSJ.4
差较 LMX 比性述描的据数对 NOSJ.5
"diordna/ser/kpa/moc.diordna.samehcs//:ptth"=diordna:snlmx tsefinam<

[Android开发] Json解析工具类,一个类搞定Json的解析

[Android开发] Json解析工具类，一个类搞定Json的解析一、简介利用递归的方式反射解析到bean里面二、详细代码1、Json格式例如服务器指定规定json格式为:{"code": "……" , // 返回代号，预留字段，默认返回null"type":"ERROR", // 返回类型，表示操作是成功或失败"desc":"……", // 返回描述，描述性文字，主要保存用于弹窗显示的文字"action":"SHOW", //返回操作，该操作值提供给终端使用，用于决定当前收到返回后的操作"data": "……" // 返回数据，根据请求上传的参数，返回对应的数据，或返回null}对应的数据在data里面，data里面的key对应一个bean，例如一个列表数据:{"desc":"查询成功","data":{"diseaseList":[{"xmlName":"精神病评估","xmlId":"1066","category":"symptom"},{"xmlName":"对学习困难和认知延迟的评估","xmlId":"884","category":"symptom"},{"xmlName":"疲乏的评估","xmlId":"571","category":"symptom"},{"xmlName":"痴呆的评估","xmlId":"242","category":"symptom"},{"xmlName":"非故意性体重减轻评估","xmlId":"548","category":"symptom"}]},"action":null,"code":"","type":"SUCCESS"}2、定义数据Bean类上面的list的bean定义为DiseaseList.Javapublic class DiseaseList {/*** xmlName : 分裂情感性障碍* xmlId : 1199* category : disease*/private String xmlName; //症状名字private String xmlId; //症状名字private String category; //分类的英文名private String letter = ""; //字母，转为拼音后在这里添加public String getXmlName() {return xmlName;}public void setXmlName(String xmlName) {this.xmlName = xmlName;}public String getXmlId() {return xmlId;}public void setXmlId(String xmlId) {this.xmlId = xmlId;}public String getCategory() {return category;}public void setCategory(String category) { this.category = category;}public String getLetter() {return letter;}public void setLetter(String letter) {this.letter = letter;}}3、定义根key的bean类Response.java:/*** json返回的首key的内容类**/public class Response {//下面四个是固定写在第一层的private String code;private String type;private String desc;private String action;//Object 可以存放listprivate HashMap<String,Object> datas = new HashMap<String,Object>(); //存放对象(一般是list)，根据String这个id来取//存放data里面的基本类型private HashMap<String,Object> dataValue = new HashMap<>();public Response() {code = type = desc = action /*= version = token = applyAuthenticateId*/ = "";}public final static String TOKEN = "token";public final static String VERSION = "version";public final static String PORTRAIT = "portrait";public final static String USERID = "userId";public final static String APPL YAUTHENTICA TEID = "applyAuthenticateId";public final static String ISDOCTOR = "isDoctor";public final static String ISEXPERT = "isExpert";public final static String WAY = "way";public final static String DOWNLOAD = "download";/*** 存值到hashmap里面* @param key* @param value*/public void put(String key, Object value) {datas.put(key, value);}/*** 获取key对应的对象* @param key key* @param <T> 返回的对象* @return hashMap的key对应的值*/public <T> T get(String key){if(datas.containsKey(key)){return (T)datas.get(key);}return null;}/*** 反射执行，添加到hashMap,data里面的基本类型数据* @param key* @param value*/public void addDataValue(String key, Object value){dataValue.put(key,value);}/*** 获取data里面的基本类型数据* @param key* @param <T>* @return*/public <T> T getDataV alue(String key){if(dataValue.containsKey(key)){return (T)dataValue.get(key);}return null;}public String getCode() {return code;}public void setCode(String code) {if(null != code && !"".equals(code.trim()))this.code = code;}public String getDesc() {return desc;}public void setDesc(String desc) {if(!TextUtils.isEmpty(desc))this.desc = desc;}}4、定义反射类枚举json解析时候根据key在这里获取到对应的类实例DA TA.java:/*** json解析的时候的类*/public enum DATA {//疾病列表DISEASELIST("diseaseList",DiseaseList.class);private final String mId;private final Class cls;public Class getClzss() {return cls;}DA TA(String id, Class clzss) {mId = id;cls = clzss;}/*** 根据json的key获取类* @param id* @return*/public static DA TA fromId(String id) {DATA[] values = values();int cc = values.length;for (int i = 0; i < cc; i++) {if (values[i].mId.equals(id)) {return values[i];}}return null;}@Overridepublic String toString() {return mId;}}5、Json解析工具类对应的注释已经写到代码里面了JsonResolveUtils.java/*** json解析工具类*/public class JsonResolveUtils {private static final String SET = "set";private static final String PUT = "put";/*** 开始解析json 字符串，解析为Response类bean形式** @param response json字符串* @param cls Response类class* @param <T> 泛型，这里传递了Response* @return*/public static <T> T parseJsonToResponse(String response, Class<T> cls) {if (null != response) {try {// 构建JSONObject 实例JSONObject json = new JSONObject(response);// JSONObject 解析成具体Bean实例T entity = toResponse(json, cls);return entity;} catch (JSONException e) {e.printStackTrace();} catch (InstantiationException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();} catch (Exception e) {e.printStackTrace();}}return null;}/*** JSONObject解析成Response Bean实例** @param json json对象* @param cls 转换的对象，这里是Response* @param <T> 转换的对象，这里是Response* @return 返回Response对象* @throws IllegalAccessException* @throws InstantiationException*/public static <T> T toResponse(JSONObject json, Class<T> cls) throws IllegalAccessException, InstantiationException {//声明一个Response实例T instance = null;if (null != json) {// 获取根keyIterator<String> iterator = json.keys();//构建个实例Response Beaninstance = cls.newInstance();//开始遍历根keywhile (iterator.hasNext()) {try {String key = iterator.next(); //获取keyObject value = json.get(key); //获取key对应的值//值不为空if (null != value) {if (!key.equals("data")) {//不是data数据，直接为Response的Bean属性赋值setter(instance, key, value);} else { // 解析data数据if (value instanceof JSONObject) {//data 数据是JSONObject 开始解析json对象数据parseJsonBean((JSONObject) value, instance);} else if (value instanceof JSONArray) {//data 数据是JSONArray 开始解析json数组数据toBeanArray((JSONArray) value, instance);} else {//若都不是，直接为ResponseBean属性赋值setter(instance, key, value);}}}} catch (Exception e) {e.printStackTrace();}} // while(~)}return instance;}/*** 解析单个JSON数据** @param json json* @param instance Bean实例* @param <T>*/public static <T> void parseJsonBean(JSONObject json, T instance) {//json不为空if (null != json) {//获取json的key iteratorIterator<String> iterator = json.keys();while (iterator.hasNext()) {//获取键值对String key = iterator.next();Object value = null;try {//获取值value = json.get(key);//value不为空if (null != value) {// value 为json对象则把json解析成具体的实例Beanif (value instanceof JSONObject) {// 获取对应的实例Bean ClassDATA clzss = DA TA.fromId(key);//不为空if (null != clzss) {//把json解析成该实例BeanObject entity = toBean((JSONObject) value, clzss.getClzss());//把当前Bean类缓存在上级Bean属性里putter(instance, entity.getClass(), key, entity);}} else if (value instanceof JSONArray) { //value 为json 数据对象，则把jsonarray解析成ArrayList<Bean>// 获取对应的实例Bean ClassDATA clzss = DA TA.fromId(key);if (null != clzss) {//把json解析成ArrayList<Bean>Object entity = parseBeanArray((JSONArray) value, clzss.getClzss());//把当前ArrayList<Bean>缓存在上级Bean属性里putter(instance, entity.getClass(), key, entity);}} else {//都是不是，直接为上级Bean属性赋值if (instance instanceof Response) {//dada下面的标准类型的值设置进Respone的dataStringsetDataString(instance,key, value.toString());} else {putter(instance, value.getClass(), key, value);}}}} catch (Exception e) {e.printStackTrace();}}}}/*** 设置Response的dataString** @param obj* @param key* @param value* @param <T>*/private static <T> void setDataString(Object obj, String key, String value) {//值不为空if (null == value)return;try {//获取addDataString方法,参数1 为方法名，2为类型Method method = obj.getClass().getMethod("addDataValue", String.class, Object.class);//调用set方法赋值method.invoke(obj, key, value);} catch (Exception e) {e.printStackTrace();}}/*** 解析JSON成具体实例Bean** @param json json数据* @param cls 要解析成为的实例* @param <T> 返回实例* @return* @throws IllegalAccessException* @throws InstantiationException*/public static <T> T toBean(JSONObject json, Class<T> cls) throws IllegalAccessException, InstantiationException {//声明实例引用T instance = null;//json不为空if (null != json) {//获取json key 的迭代器；Iterator<String> iterator = json.keys();//构建实例Beaninstance = cls.newInstance();//遍历json keywhile (iterator.hasNext()) {//获取键值对String key = iterator.next();Object value = null;try {value = json.get(key);//value不为空if (null != value) {// value 为json对象则把json解析成具体的实例Beanif (value instanceof JSONObject) {// 获取对应的实例Bean ClassDATA clzss = DA TA.fromId(key);if (null != clzss) {//把json解析成该实例BeanObject entity = toBean((JSONObject) value, clzss.getClzss());//把当前Bean类缓存在上级Bean属性里putter(instance, entity.getClass(), key, entity);}} else if (value instanceof JSONArray) { //value 为json数组对象，则把jsonarray解析成ArrayList<Bean>// 获取对应的实例Bean ClassDATA clzss = DA TA.fromId(key);if (ull != clzss) {//把json解析成ArrayList<Bean>Object entity = parseBeanArray((JSONArray) value, clzss.getClzss());//把当前ArrayList<Bean>缓存在上级Bean属性里putter(instance, entity.getClass(), key, entity);}} else {//都是不是，直接为上级Bean属性赋值setter(instance, key, value);}}} catch (Exception e) {e.printStackTrace();}}}return instance;}/*** 解析json里面的json数组,例如专家列表** @param jsonarr* @param cls* @param <T>* @return*/public static <T> ArrayList<Object> parseBeanArray(JSONArray jsonarr, Class<T> cls) {//声明集合List引用ArrayList<Object> beanArray = null;//声明实例引用T instance = null; // if areaif (null != jsonarr && jsonarr.length() > 0) {beanArray = new ArrayList<Object>();int count = jsonarr.length();Object value = null;for (int index = 0; index < count; index++) {try {value = jsonarr.get(index);if (value instanceof String) {beanArray.add(value);continue;} else {//构造实例Beaninstance = cls.newInstance();// value 为json对象则把json解析成具体的实例Beanif (value instanceof JSONObject) {parseJsonBean((JSONObject) value, instance);} else if (value instanceof JSONArray) {//value 为json 数组对象，则解析jsonarraytoBeanArray((JSONArray) value, instance);}//解析完成后将Bean添加到ListbeanArray.add(instance);}} catch (Exception e) {e.printStackTrace();}}}return beanArray;}/*** 解析data的key 的json数组** @param jsonarr json数据* @param instance Response实例* @param <T>* @return*/public static <T> T toBeanArray(JSONArray jsonarr, T instance) {if (null != jsonarr && jsonarr.length() > 0) {int count = jsonarr.length();Object value = null;for (int index = 0; index < count; index++) {try {value = jsonarr.get(index);if (value instanceof JSONObject) {parseJsonBean((JSONObject) value, instance);} else if (value instanceof JSONArray) {toBeanArray((JSONArray) value, instance);}} catch (JSONException e) {e.printStackTrace();}}}return instance;}/*** 调用obj类的get参数menber方法** @param obj* @param member* @param <T>* @return*/public static <T> T getter(Object obj, String member) {try {Method method = obj.getClass().getMethod("get" + updateFirst(member));return (T) method.invoke(obj);} catch (Exception e) {return null;}}/*** 反射的方法获取** @param obj* @param member* @param <T>* @return*/public static <T> T getterIgnoreCase(Object obj, String member) {try {Method method = obj.getClass().getMethod("get" + member);return (T) method.invoke(obj);} catch (Exception e) {return null;}}/*** 为obj实例的属性赋值** @param obj 目标实例* @param clzss set方法形参类型* @param value 属性值*/public static void putter(Object obj, Class<?> clzss, Object... value) {//值不为空if (null == value)return;try {//获取key对应的set方法,参数1 为方法名，2为类型Method method = obj.getClass().getMethod(SET + updateFirst((String) value[0]), clzss);//调用set方法赋值method.invoke(obj, value[1]);} catch (Exception e) {//若obj没有对应的set方法try {//获取obj的put方法Method method = obj.getClass().getMethod(PUT, value[0].getClass(), Object.class);//把属性值put入map里缓存method.invoke(obj, value);//System.out.println(obj.getClass()+ "调用"+value[0].toString()+" "+((ArrayList)value[1])ze());} catch (Exception ex) {ex.printStackTrace();}}}/*** 反射执行** @param obj* @param member* @param value*/public static void setter(Object obj, String member, Object value) {if (null == value)return;try {Method method = obj.getClass().getMethod(SET + updateFirst(member), value.getClass());method.invoke(obj, value);} catch (Exception e) {e.printStackTrace();}}/*** 首字符大写** @param member* @return*/public static String updateFirst(String member) {String first = member.substring(0, 1).toUpperCase();String suffex = member.substring(1, member.length());return new StringBuilder().append(first).append(suffex).toString();}}三、使用例如第一个数据获取到list数据//解析为responseResponse response = JsonResolveUtils.parseJsonToResponse(json,Response.class);从response里面获取list数据List<DiseaseList> list = new ArrayList<>();//获取完成开始解析为list beanResponse response = JsonResolveUtils.parseJsonToResponse(json,Response.class);ArrayList cache = null;cache = response.get(DA TA.DISEASELIST.toString());if(cache != ll && !cache.isEmpty()){//添加到listlist.addAll(cache);Log.e("tpnet",list.size()+"个数据");}else{//获取数据失败操作}四、使用注意解析的时候是根据返回的格式进行解析的，如果有数字类型的数据。

android实现json数据的解析和把数据转换成json格式的字符串

android实现json数据的解析和把数据转换成json格式的字符串利⽤android sdk⾥⾯的JSONObject和JSONArray把集合或者普通数据，转换成json格式的字符串JSONObject和JSONArray解析json格式的字符串为集合或者⼀般数据package com.hck.test;import java.util.ArrayList;import java.util.List;import org.json.JSONArray;import org.json.JSONException;import org.json.JSONObject;import android.app.Activity;import android.os.Bundle;import android.util.Log;import android.view.View;import android.view.View.OnClickListener;import android.widget.Button;import android.widget.TextView;import android.widget.Toast;public class MainActivity extends Activity implements OnClickListener {private Button button1, button2, button3, button4; //4个按钮private TextView textView; //显⽰处理结果的textviewprivate List<UserBean> userBeans; //保存数据的集合private JSONObject object; //JSONObject对象，处理⼀个⼀个的对象private JSONObject object2;private JSONArray jsonArray;//JSONObject对象，处理⼀个⼀个集合或者数组private String jsonString; //保存带集合的json字符串private String jsonString2;//不带集合的json字符串@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(yout.main);initView(); //初始化控件initDate(); //初始化数据setListener(); //绑定监事件}private void initView() {button1 = (Button) findViewById(R.id.bt1);button2 = (Button) findViewById(R.id.bt2);button3 = (Button) findViewById(R.id.bt3);button4 = (Button) findViewById(R.id.bt4);textView = (TextView) findViewById(R.id.text);}/*** 初始化2个⽤户对象*/private void initDate() {userBeans = new ArrayList<UserBean>();UserBean userBean = new UserBean();userBean.setUserId(1);userBean.setUserName("hck");userBeans.add(userBean);UserBean userBean2 = new UserBean();userBean2.setUserId(2);userBean2.setUserName("蝌蚪");userBeans.add(userBean2);}private void setListener() {button1.setOnClickListener(this);button2.setOnClickListener(this);button3.setOnClickListener(this);button4.setOnClickListener(this);}private void changeArrayDateToJson() { //把⼀个集合转换成json格式的字符串jsonArray=null;object=null;jsonArray = new JSONArray();object=new JSONObject();for (int i = 0; i < userBeans.size(); i++) { //遍历上⾯初始化的集合数据，把数据加⼊JSONObject⾥⾯object2 = new JSONObject();//⼀个user对象，使⽤⼀个JSONObject对象来装try {object2.put("userId", userBeans.get(i).getUserId()); //从集合取出数据，放⼊JSONObject⾥⾯ JSONObject对象和map差不多⽤法,以键和值形式存储数据 object2.put("userName", userBeans.get(i).getUserName());jsonArray.put(object2); //把JSONObject对象装⼊jsonArray数组⾥⾯} catch (JSONException e) {e.printStackTrace();}}try {object.put("userDate", jsonArray); //再把JSONArray数据加⼊JSONObject对象⾥⾯(数组也是对象)//object.put("time", "2013-11-14"); //这⾥还可以加⼊数据，这样json型字符串，就既有集合，⼜有普通数据} catch (JSONException e) {e.printStackTrace();}jsonString=null;jsonString = object.toString(); //把JSONObject转换成json格式的字符串textView.setText(jsonString);Log.i("hck", "转换成json字符串: " + jsonString);}private void changeNotArrayDateToJson() {object=null;object=new JSONObject();try {object.put("userId", "1"); //把数据加⼊JSONObject对象即可，"userid"相当于map⾥⾯的key,1即为value的值。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

JSON 的定义:
一种轻量级的数据交换格式,具有良好的可读和便于快速编写的特性。

业内主流技术为其提供了完整的解决方案(有点类似于正则表达式 ,获得了当今大部分语言的支持,从而可以在不同平台间进行数据交换。

JSON 采用兼容性很高的文本格式,同时也具备类似于 C 语言体系的行为。

–
JSON Vs XML
1.JSON 和 XML 的数据可读性基本相同
2.JSON 和 XML 同样拥有丰富的解析手段
3.JSON 相对于 XML 来讲,数据的体积小
4.JSON 与 JavaScript 的交互更加方便
5.JSON 对数据的描述性比 XML 较差
6.JSON 的速度要远远快于 XML
android2.3提供的 json 解析类
android 的 json 解析部分都在包 org.json 下,主要有以下几个类:
JSONObject :可以看作是一个 json 对象 , 这是系统中有关 JSON 定义的基本单元, 其包含一对儿 (Key/Value数值。

它对外部 (External:应用 toString(方法输出的数值调用的响应体现为一个标准的字符串(例如:{"JSON": "Hello, World"},最外被大括号包裹,其中的 Key 和 Value 被冒号 ":"分隔。

其对于内部 (Internal行为的操作格式略微,例如:初始化一个 JSONObject 实例,引用内部的 put(方法添加数值:new JSONObject(.put("JSON", "Hello, World!", 在 Key 和 Value 之间是以逗号 "," 分隔。

Value 的类型包括:Boolean 、 JSONArray 、 JSONObject 、 Number 、 String 或者默认值 JSONObject.NULL object 。

JSONStringer :json 文本构建类 ,根据官方的解释,这个类可以帮助快速和便捷的创建 JSON text。

其最大的优点在于可以减少由于格式的错误导致程序异常, 引用这个类可以自动严格按照 JSON 语法规则 (syntax rules 创建 JSON
text 。

每个 JSONStringer 实体只能对应创建一个 JSON text。

其最大的优点在于可以减少由于格式的错误导致程序异常, 引用这个类可以自动严格按照 JSON 语法规则(syntax rules创建 JSON text。

每个 JSONStringer 实体只能对应创建一个JSON text。

JSONArray :它代表一组有序的数值。

将其转换为 String 输出 (toString所表现的形式是用方括号包裹, 数值以逗号”,” 分隔 (例如:[value1,value2,value3], 大家可以亲自利用简短的代码更加直观的了解其格式。

这个类的内部同样具有查询行为, get(和 opt(两种方法都可以通过 index 索引返回指定的数值, put(方法用来添加或者替换数值。

同样这个类的 value 类型可以包括:Boolean 、 JSONArray 、JSONObject 、 Number 、 String 或者默认值 JSONObject.NULL object 。

JSONTokener :json 解析类
JSONException :json 中用到的异常
JSONObject, JSONArray来构建 json 文本
getType 和 optType api的使用
getType 可以将要获取的键的值转换为指定的类型,如果无法转换或没有值则抛出 JSONException
optType 也是将要获取的键的值转换为指定的类型, 无法转换或没有值时返回用户提供或这默认提供的值
除了上面的两个类,还可以使用 JSONStringer 来构建 json 文本
json 文本解析类 JSONTokener
按照 RFC4627规范将 json 文本解析为相应的对象。

对于将 json 文本解析为对象,只需要用到该类的两个 api :构造函数public Object nextValue(;
其它的 api 基本就是用来查看 json 文本中的文本的
15. // 返回当前读取位置到第一次遇到字符串中(如"0089"任意字符之间的字符串，同时该字符是 trimmed 的。

（此处就是第一次遇到了 8 9） 16.
jsonParser.nextTo("0089"; //me" : "yuanzhifei 17. 18. // 读取位置撤销一个 19. jsonParser.back(; 20. jsonParser.next(; //i 21. 22. // 读取位置前进到指定字符串处（包括字符串） 23. jsonParser.skipPast("address"; 24. jsonParser.next(8; //" : { "c 25. 26. // 读取位置前进到执行字符处（不包括字符） 27. jsonParser.skipTo('m'; 28. jsonParser.next(8; //married" 29. } catch (JSONException ex { 30. // 异常处理代码 31. }。