下载文档原格式
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⽹络开发中常见的数据格式。
下面这个是自己修改别人的小例子，主要是加一些注释和讲解，这个例子主要是使用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数据⽰例代码（三种⽅式）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（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数据解析（数据传输）上篇随笔详细介绍了三种解析服务器端传过来的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）解析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的简单⽅法⾸先先讲⼀个⽐较简单点的例⼦(最简单的我就不讲啦，⽹上很多)，帮助新⼿理解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解析摘要：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解析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种解析技术详解）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解析一．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数据的两种⽅法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解析的原理。
一、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数组）封装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 库来进行 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`属性。
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. }。
