gson 解析数组

Gson使⽤⽅法详解⼀、概述 Gson是google提供的⽤来操作json数据的⼀个⾮常好⽤的类库。

其使⽤范围⾮常的⼴泛，所以⾮常有必要对其进⾏系统的学习。

json是⼀种数据格式，确切的说是⼀种⽂本数据格式。

其在⽹络通讯过程中的作⽤⾮常的明显。

⽬前⼤多数的⽹络通讯格式已经从xml替换为json格式。

其提供了序列化和反序列化的功能。

在我们进⾏⽹络开发的过程中通常会把参数封装成json格式传给后台，后台解析后的返回结果也会封装成json格式返回给调⽤者。

下⾯就针对json的⽤法做⼀下详细的描述。

ps：重要。

在查看第三⽅库的源代码或者⾃⼰封装库的时候尤其重要。

对json不熟悉是⽆法封装成基于json的⾼质量库的。

例如：Retrofit的⽹络数据转换的converter。

GsonConverterFactory.create()⼆、从⼩例⼦⼊⼿ ps：Book.java 下⾯⽤到的所有实体都是基于Book.java类的。

代码如下：package com.yw.gsonlib;import com.google.gson.annotations.SerializedName;/*** create by yangwei* on 2020-02-21 18:08*/public class Book {public Book(){}private String id;/*** 加上@SerializedName注解后服务端api返回name、bookName、Name、bn时，客户端都能够拿到正确的值给name属性。

*/@SerializedName(value = "bookName",alternate = {"Name","bn"})private String name;public Book(String id, String name) {this.id = id; = name;}public String getId() {return id;}public void setId(String id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}} 1.如何创建⼀个Gson对象/*** 创建Gson对象的两种形式*/private void createGsonObject() {//第⼀种⽅式Gson gson = new Gson();//第⼆种⽅式Gson gson1 = new GsonBuilder().create();//⽅式⼆除了可以创建⼀个Gson对象以外还可以进⾏多项配置,例如，设置⽇期的格式化// 例如： new GsonBuilder().setDateFormat("yyyy-MM-dd");}/*** 如何创建⼀个json对象*/private void createJsonObject() {JsonObject jsonObject = new JsonObject();jsonObject.addProperty("id", "1");//给jsonObject创建⼀个id属性值为1jsonObject.addProperty("bookName", "《深⼊Java虚拟机》");jsonObject.addProperty("bookPrice", 36.8);jsonObject.addProperty("bookColor", "红⾊");//打印Json字符串System.out.println(jsonObject.toString());//给JsonObject添加对象JsonObject jsonObject1 = new JsonObject();jsonObject1.addProperty("chapterId", "1");jsonObject1.addProperty("chapterName", "第⼀章");//给JsonObject添加实体对象jsonObject.add("chapter", jsonObject1);System.out.println(jsonObject.toString());} 3.数组的序列化与反序列化/*** 根据⼀个json创建⼀个数组*/private void createJsonArray() {//把数组转换为Json字符串String[] args = new String[]{"《深⼊Java虚拟机》", "《Android插件编程》", "《OpenCV全解》"}; Gson gson = new Gson();String jsonStr = gson.toJson(args);//先创建⼀个Json字符串System.out.println(jsonStr);//输出//把Json字符串转换为Json数组String[] strArray = gson.fromJson(jsonStr, String[].class);for (String s : strArray) {System.out.println(s);}} 4.List的序列化与反序列化/*** 根据⼀个json创建⼀个list*/private void createJsonToList() {//将list集合转换为json字符串List<Book> books = new ArrayList<>();books.add(new Book("1", "《深⼊Java虚拟机》"));books.add(new Book("2", "《OpenCV进阶》"));books.add(new Book("3", "《深⼊Android源代码》"));Gson gson = new Gson();String jsonListStr = gson.toJson(books);System.out.println(jsonListStr);//将json字符串转换为list集合//获取泛型的类型Type type = new TypeToken<List<Book>>() {}.getType();//使⽤gson将字符串转换为泛型集合，即List<Book>List<Book> books1 = gson.fromJson(jsonListStr, type);for (Book book : books1) {System.out.println(book.getName());}} 5.序列化与反序列化综合例⼦（基于Book对象）/*** json的序列化与反序列化* 使⽤toJson实现序列化，使⽤fromJson实现反序列化*/private void jsonSeriaReSeria() {Gson gson = new Gson();Book book = new Book("1", "《深⼊Java虚拟机》");//将book类序列化成字符串String bookStr = gson.toJson(book);//将bookStr反序列化成为Book类Book b = gson.fromJson(bookStr, Book.class);System.out.println(b.getName());} 6.如何为属性做兼容性处理（重命名、预设名称等）/*** 如何给json属性重命名* 假设我们有这样⼀个需求：由于接⼝改版，从服务端返回的api中的book字段的name属性，变为了bookName。

java中常见的json解析⽅法、库以及性能对⽐常见的json解析有原⽣的JSONObject和JSONArray⽅法，⾕歌的GSON库，阿⾥的fastjson，还有jackson，json-lib。

Gson（项⽬地址：FastJson（项⽬地址：Jackson（项⽬地址：Json-lib（项⽬地址：不好的地⽅确实是依赖于很多第三⽅包，包括commons-beanutils.jar，commons-collections-3.2.jar，commons-lang-2.6.jar，commons-logging-1.1.1.jar，ezmorph-1.0.6.jar，对于复杂类型的转换，json-lib对于json转换成bean还有缺陷，⽐如⼀个类⾥⾯会出现另⼀个类的list或者map集合，json-lib从json到bean的转换就会出现问题。

json-lib在功能和性能上⾯都不能满⾜现在互联⽹化的需求。

1、java⽅法解析JSONObject解析json对象JSONArray解析json数组例如json字符串为：{"personData": [{"age": 12,"name": "nate","schoolInfo": [{"School_name": "清华"},{"School_name": "北⼤"}],"url": "/uploadImages/2014/345/36/E8C039MU0180.jpg"},{"age": 24,"name": "jack",···}],"result": 1}分析这段json数据，第⼀层是⼀个花括号括号，即jsonObect对象，然后这个对象⾥⾯有⼀个personData的JSONArray数组，以及⼀个result属性第⼆层personData的JSONArray数组，它⾥⾯除了属性之外，还有⼀个schoolInfo的JSONArray数组第三次是schoolInfo的JSONArray数组⾥⾯的JSONObject对象解析：public class Httpjson extends Thread {private String url;private Context context;private ListView listView;private JsonAdapter adapter;private Handler handler;public Httpjson(String url, ListView listView, JsonAdapter adapter, Handler handler) {super();this.url = url;this.listView = listView;this.adapter = adapter;this.handler = handler;}@Overridepublic void run() {URL httpUrl;try {httpUrl = new URL(url);···}/*** 从⽹络中获取JSON字符串，然后解析* @param json* @return*/private List<Person> jsonParse(String json) {try {List<Person> personlist = new ArrayList<Person>();JSONObject jsonObject = new JSONObject(json);int result = jsonObject.getInt("result");if (result == 1) {JSONArray jsonArray = jsonObject.getJSONArray("personData");for (int i = 0; i < jsonArray.length(); i++) {Person person = new Person();JSONObject personData = jsonArray.getJSONObject(i);int age = personData.getInt("age");String url = personData.getString("url");String name = personData.getString("name");···JSONArray schoolInfoArray = personData.getJSONArray("schoolInfo");···}···}return personlist;} else {Toast.makeText(context, "erro", Toast.LENGTH_SHORT).show();}} catch (JSONException e) {e.printStackTrace();Log.e("JsonParseActivity", "json解析出现了问题");}return null;}}2、gson解析（1）简介GSON是Google提供的⽤来在Java对象和JSON数据之间进⾏映射的Java类库。

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数据⽰例代码（三种⽅式）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。

kotlin gson解析Kotlin Gson解析：让数据解析更加简单高效在移动应用开发中，数据解析是一个非常重要的环节。

数据解析的质量直接影响着应用的性能和用户体验。

而在Android开发中，Gson是一个非常流行的数据解析库。

它可以将JSON数据转换为Java或Kotlin对象，使得数据解析变得更加简单高效。

本文将介绍如何使用Kotlin Gson解析数据。

一、Gson简介Gson是Google开发的一个Java和Kotlin的JSON解析库。

它可以将JSON数据转换为Java或Kotlin对象，也可以将Java或Kotlin对象转换为JSON数据。

Gson具有以下特点：1. 简单易用：Gson提供了简单易用的API，使得数据解析变得更加简单高效。

2. 高效性能：Gson使用了一些优化技术，使得数据解析的性能更加高效。

3. 支持复杂数据类型：Gson支持解析复杂的数据类型，如嵌套的JSON对象和数组。

4. 支持自定义序列化和反序列化：Gson支持自定义序列化和反序列化，可以满足不同的需求。

二、Kotlin Gson解析1. 添加依赖在使用Kotlin Gson解析之前，需要先添加Gson的依赖。

在build.gradle文件中添加以下依赖：```dependencies {implementation 'com.google.code.gson:gson:2.8.6'}```2. 创建数据模型在进行数据解析之前，需要先创建数据模型。

数据模型是一个普通的Kotlin类，用于存储JSON数据。

例如，我们要解析以下JSON 数据：```{"name": "Tom","age": 18,"address": {"city": "Beijing","street": "Chaoyang Road" },"hobbies": ["reading","swimming","traveling"]}```我们可以创建以下数据模型：```data class Person(val name: String,val age: Int,val address: Address,val hobbies: List<String>)data class Address(val city: String,val street: String)```3. 解析JSON数据在创建好数据模型之后，就可以使用Gson解析JSON数据了。

JSON三种数据解析方法引言JSON数据现在是我们开发中用的最多的，百分之八十的数据都是通过JSON方式进行传输，那么想要学好JSON解析就要了解什么是JSON数据，怎么快速解析它从而提升开发效率。

什么是JSON数据？•先看下面，这里有一段JSON数据，我们根据这段数进行讲解：{"paramz": {"feeds": [{"id": 299076,"oid": 288340,"category": "article","data": {"subject": "荔枝新闻3.0：不止是阅读","summary": "江苏广电旗下资讯类手机应用“荔枝新闻”于近期推出全新升级换代的3.0版。

","cover":"/Attachs/Article/288340/3e8e2c397c70469f8845fad73aa38165 _padmini.JPG","pic": "","format": "txt","changed": "2015-09-22 16:01:41"}}],"PageIndex": 1,"PageSize": 20,"TotalCount": 53521,"TotalPage": 2677}}•其实JSON数据就是一段字符串而已，只不过有不同意义的分隔符将其分割开来而已，我们看上面的符号，里面有[] ,{}等符号，其中•1 []中括号代表的是一个数组；•2 {}大括号代表的是一个对象•3 双引号“”表示的是属性值•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数组中对应的元素数据。

json数组的解析⼀直以来，经常会遇到json数据从前端或者我经常从⽹站上爬取的数据中会有json数据的存在，这样如果想要获取json数据就需要对json 数据进⾏解析在开发过程中，经常需要和别的系统交换数据，数据交换的格式有XML、JSON等，JSON作为⼀个轻量级的数据格式⽐xml效率要⾼，XML需要很多的标签，这⽆疑占据了⽹络流量，JSON在这⽅⾯则做的很好，下⾯先看下JSON的格式，JSON可以有两种格式，⼀种是对象格式的，另⼀种是数组对象，{"name":"JSON","address":"北京市西城区","age":25}//JSON的对象格式的字符串[{"name":"JSON","address":"北京市西城区","age":25}]//数据对象格式从上⾯的两种格式可以看出对象格式和数组对象格式唯⼀的不同则是在对象格式的基础上加上了[]，再来看具体的结构，可以看出都是以键值对的形式出现的，中间以英⽂状态下的逗号（,）分隔。

在前端和后端进⾏数据传输的时候这种格式也是很受欢迎的，后端返回json格式的字符串，前台使⽤js中的JSON.parse()⽅法把JSON字符串解析为json对象，然后进⾏遍历，供前端使⽤。

下⾯我⽤的是java语⾔解析json数据的解析数据前需要引⼊⼀个包可以到这⾥下载相应的jar包public class JsonToObject {/**解析json字符串最外⾯是[]的情况* [{"rating":["9.6","50"],"rank":1},{"rating":["9.6","50"],"rank":2}]* @throws Exception*/public List<Map<String, String>> toMapOne(String jsonString)throws Exception{//第⼀步是将最外⾯⼀层的数组解析去掉，得到所有的json串JSONArray jsons = JSONArray.fromObject(jsonString);List<Map<String, String>> nodes = new ArrayList<Map<String, String>>();//循环遍历所有的json⼦串for (Object o : jsons){JSONObject jsonNode = JSONObject.fromObject(o);Map<String, String> treeNodes = new HashMap<String, String>();String rating = "";JSONArray ratingArray = JSONArray.fromObject(jsonNode.getString("rating").trim());for(Object ob : ratingArray) {rating += ob.toString()+",";}treeNodes.put("rating",rating);treeNodes.put("rank",jsonNode.getString("rank").trim());nodes.add(treeNodes);}return nodes;}/**解析json字符串最外⾯是{}的情况* {"data":[{"directors":["普特鹏·普罗萨卡·那·萨克那卡林","华森·波克彭"],"rate":"8.3"},{"directors":["⼤卫·芬奇"],"rate":"8.7"}]}* @throws Exception*/public List<Map<String, String>> toMapTwo(String jsonString)throws Exception{//⾸先将jsonString字符串转化为jsonObjectJSONObject jsonNode = JSONObject.fromObject(jsonString);//然后获取json中data的值JSONArray jsonArray = JSONArray.fromObject(jsonNode.getString("data"));List<Map<String, String>> nodes = new ArrayList<Map<String, String>>();//遍历data⾥边的值for (Object object : jsonArray) {JSONObject jsonNode2 = JSONObject.fromObject(object);Map<String, String> treeNodes = new HashMap<String, String>();treeNodes.put("directors",jsonNode2.getString("directors"));treeNodes.put("rate",jsonNode2.getString("rate").trim());nodes.add(treeNodes);}return nodes;}public static void main(String[] args) throws Exception {String jsonString = "[{\"rating\":[\"9.6\",\"50\"],\"rank\":1},{\"rating\":[\"9.6\",\"50\"],\"rank\":2}]";String jsonString2 = "{\"data\":[{\"directors\":[\"普特鹏·普罗萨卡·那·萨克那卡林\",\"华森·波克彭\"],\"rate\":\"8.3\"},{\"directors\":[\"⼤卫·芬奇\"],\"rate\":\"8.7\"}]}"; JsonToObject jo = new JsonToObject();List<Map<String, String>> listMap = jo.toMapOne(jsonString);List<Map<String, String>> listMap2 = jo.toMapTwo(jsonString2);//上⾯获取到了json的数据并且封装到list集合中去，并且list//⾥⾯封装的是map集合for (Map<String, String> map : listMap) {String rating = map.get("rating");String rank = map.get("rank");System.out.println("rating: "+rating);System.out.println("rank: "+rank);}for (Map<String, String> map : listMap2) {String directors = map.get("directors");String rate = map.get("rate");System.out.println("directors: "+directors);System.out.println("rate: "+rate);}}} 运⾏的结果：对于toMapOne⾥的函数调试的变量值情况：。

GSON方式生成和解析json数据客户端与服务器进行数据交互时，常常需要将数据在服务器端将数据转化成字符串并在客户端对json数据进行解析生成对象。

但是用jsonObject和jsonArray解析相对麻烦。

利用Gson 和阿里的fastjson可以很方便的将下面四种常用的数据转换成json字符串，并能够将其解析成原数据对象。

类型一：JavaBean类型二：List<JavaBean>类型三:List<String>类型四:List<Map<String,Object>>一.Gson将上面的四种数据对象转换成json字符串的方法都是一样的Gson gson = new Gson();String jsonString = gson.toJson(obj);二.Gson将json字符串转化成JavaBean对象1.类型一：JavaBeanPerson person = new Person("香港","刘德华",1001);Gson gson = new Gson();//这里将javabean转化成json字符串String jsonString = gson.toJson(person);System.out.println(jsonString);//这里将json字符串转化成javabean对象,person = gson.fromJson(jsonString,Person.class);2.类型二：List<JavaBean>将json字符串转化成List<JavaBean>对象Person person1 = new Person("香港","刘德华",1001);Person person2 = new Person("韩国","宋慧乔",1002);List<Person> persons = new ArrayList<Person>();persons.add(person1);persons.add(person2);Gson gson = new Gson();//这里将lsit<javabean>转化成json字符串String jsonString = gson.toJson(persons);//解析json字符串List<Person> persons2 = gson.fromJson(jsonString, newTypeToken<List<Person>>(){}.getType());3.类型三:List<String>将json字符串转化成List<String>对象List<String> list = new ArrayList<String>();list.add("gson1");list.add("gson2");list.add("gson3");Gson gson = new Gson();String jsonString = gson.toJson(list);System.out.println("json字符串:"+jsonString);//解析json字符串List<String> list2 = gson.fromJson(jsonString, new TypeToken<List<String>>(){}.getType()); 4.类型四:List<Map<String,Object>>将json字符串转化成List<Map<String,Object>>对象Map<String,Object> map = new HashMap<String,Object>();map.put("key1", "value1");map.put("key2", "value2");Map<String,Object> map2 = new HashMap<String,Object>();map2.put("key1", 1);map2.put("key2", 2);List<Map<String,Object>> list = new ArrayList<Map<String,Object>>();list.add(map);list.add(map2);Gson gson = new Gson();String jsonString = gson.toJson(list);System.out.println("json字符串:"+jsonString);//解析json字符串List<Map<String,Object>> list2 = gson.fromJson(jsonString, newTypeToken<List<Map<String,Object>>>(){}.getType());--------------------------------------------------------------------------------------------------------------------------------本程序服务器端通过Gson生成json字符串数据，客户端用Gson将从服务器端接收的json 字符串分别转换为<Person>,List<Person>,List<String>,List<Map<String,Object>>4种类型，程序思路和过程跟前篇android Intent传递object , list<object>,list<Map<String,Object>> 相同，唯一区别就是：生成json用Gson方式，解析json用Gson方式。

gson解析数组
Gson解析数组是使用Gson库解析JSON数组的一种方法。

JSON是一种文本格式，它允许Java应用程序以可读的文本方式存储和传输数据。

Gson是Google提供的用于Java中将JSON与Java对象间转换的库。

Gson解析数组可以节省大量时间和工作量，因为它减少了手动解析JSON所需要的步骤。

Gson解析数组有三个步骤：创建Gson实例，准备JSON源，调用Gson实例的parse方法来解析JSON。

第一步是创建一个Gson实例，这是一种构造方法，用于创建一个Gson 实例，如下所示：
Gson gson = new Gson();
第二步是准备JSON源，也就是JSON数组。

JSON数组是一个多个JSON对象的集合。

它的格式如下：
[{...}, {...}, ...]
第三步是将JSON数组传递给Gson实例的parse方法，以进行解析。

该方法所需的参数是一个字符串，该字符串可以是本地文件，网络，或者存储在String变量中的JSON数组。

解析后，返回结果是一个JsonArray对象。

您可以使用JsonArray实例包含的方法访问每个对象，然后逐一解析每个JSON对象，以获取需要的数据。

总之，Gson解析数组可以省去手动解析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:男。

利用Jackson 进行JSON 数据处理和解析利用Jackson进行JSON数据处理和解析JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，常用于前后端数据传输以及存储。

在Java开发中，Jackson是一款强大的JSON处理工具，它提供了方便的API和功能，可以对JSON数据进行处理和解析。

本文将介绍如何利用Jackson进行JSON数据处理和解析。

一、引入Jackson库首先，我们需要在项目中引入Jackson库。

可以通过Maven或者Gradle等方式添加以下依赖：```<dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-databind</artifactId><version>2.12.0</version></dependency>```二、JSON序列化Jackson提供了将Java对象转换为JSON字符串的功能，也称为JSON序列化。

我们可以通过以下步骤进行JSON序列化：1. 创建一个Java对象，该对象包含要序列化的数据。

例如，我们创建一个名为Person的类：```javapublic class Person {private String name;private int age;// getter和setter方法}```2. 在代码中导入Jackson库相关的包：```javaimport com.fasterxml.jackson.core.JsonProcessingException;import com.fasterxml.jackson.databind.ObjectMapper;```3. 创建ObjectMapper对象，它是Jackson库的核心类，负责执行序列化操作：```javaObjectMapper objectMapper = new ObjectMapper();```4. 将Java对象转换为JSON字符串：```javaPerson person = new Person("John", 25);String json = objectMapper.writeValueAsString(person);System.out.println(json); // 输出JSON字符串```三、JSON反序列化除了JSON序列化，Jackson还提供了将JSON字符串转换回Java对象的功能，也称为JSON反序列化。

本文由我司收集整编，推荐下载，如有疑问，请与我司联系用Gson 解析Json，数组里嵌套数组的实体类怎么写？2016/12/16 10 “collectionsCount”:”0”,“content”:”全球购三星（SAMSUNG）905S3G13.3 英寸轻薄笔记本电脑三星专属四核4G128Gssd 集显”,“unit”:”台”,“goodsId”:”27”,“username”:”就是这么任性”,“title”:”笔记本电脑”,“price”:”3000”,“userId”:”31”,“commentCount”:”6”,“photoList”:[{ “goodsUrl”:”192.168.0.127:8080/Nail/goods/3ee0bb65-5595-413e-8d39-3e86c0bcc3b5.png”}, { “goodsUrl”:”192.168.0.127:8080/Nail/goods/849894fb-c727- 47b6-b6bc-d7f72eba81c4.png”}, { “goodsUrl”:”192.168.0.127:8080/Nail/goods/86f68804-ef70-42ca-aeb9-75fd50c5ce34.png”} ], “userheadurl”:”192.168.0.127:8080/Nail/head/dd9393f9-d715- 4b82-b41b-998e5517c852.jpg”,“agreecount”:”1”} ] } 后台传来了一串数据，想用GSON 但不知道bean 该怎么写有哪位大佬能教教小弟吗我太菜了AndroidStudio安装GsonFormat 插件，新建一个类ctrl+N 或者command+N 点击GsonFormat 将数据粘贴进去，点击确定，自动生成GsonFormat 插件File--Setting--plugins--搜索GsonFormat 搜不到会有链接,点击自动下载,再把插件安装,实体类下面快捷键要看你是不是默认的,studio 默认快捷键是alt+insert,insert 不能是0 的那个insert,点击GsonFormat,把数据copy 进去,自动生成,取数据是xxx.getxxx,获取的是一级数组,数组里面如果还有数组继续获取,否则直接获取到对象. AndroidStudio 安装GsonFormat 插件，新建一个类ctrl+N 或者command+N 点击GsonFormat 将数据粘贴进去，点击确定，自动生成找到你说的那个插件了很方便我是刚转用AS 的还有很多东西不懂GsonFormat 插件File--Setting--plugins--搜索GsonFormat 搜不到会有链接,点击自动下载,再把插件安装,实体类下面快捷键要看你是不是默认的,studio 默认快捷键是alt+insert,insert 不能是0 的那个insert,点击GsonFormat,把数据copy 进去,自动生成,取数据是xxx.getxxx,获取的是一级数组,数组里面如果还有数组继续获取,否则直接获取到对象. 原来还有这么方便的插件啊之前都是用eclipse 也是最近转AStips:感谢大家的阅读，本文由我司收集整编。

基于JAVA中的四种JSON解析⽅式详解我们在⽇常开发中少不了和JSON数据打交道，那么我们来看看JAVA中常⽤的JSON解析⽅式。

1、JSON官⽅2、GSON3、FastJSON4、jacksonJSON操作涉及到的类：public class Student {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;}public Student(int id, String name, int age) {super();this.id = id; = name;this.age = age;}public Student() {super();}@Overridepublic String toString() {return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";}}public class Grade {private int id;private String name;private ArrayList<Student> stus;public Grade(int id, String name, ArrayList<Student> stus) {super();this.id = id; = name;this.stus = stus;}public Grade() {super();}@Overridepublic String toString() {return "Grade [id=" + id + ", name=" + name + ", stus=" + stus + "]";}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 ArrayList<Student> getStus() {return stus;}public void setStus(ArrayList<Student> stus) {this.stus = stus;}}JSON官⽅的解析最具有通⽤性，但是有点⼩⿇烦。

json数组的两种解析⽅式 1package com.example.z111505;23import java.io.IOException;4import java.io.InputStream;56import org.json.JSONArray;7import org.json.JSONException;8import org.json.JSONObject;910import android.os.Bundle;11import android.support.v7.app.ActionBarActivity;12import android.util.Log;13import android.widget.TextView;14import android.widget.Toast;151617public class MainActivity extends ActionBarActivity {1819 TextView text;20 @Override21protected void onCreate(Bundle savedInstanceState) {22super.onCreate(savedInstanceState);23 setContentView(yout.activity_main);24 text=(TextView) findViewById(R.id.mytxt);25//26//將⽂件转化为流27//InputStream inputStream=getResources().openRawResource(R.raw.j111502);28////input：输⼊流29//byte[] ppp;30//try {31// ppp = new byte[inputStream.available()];32// inputStream.read(ppp);33// String ttt=new String(ppp);34//35// inputStream.close();36// text.setText(ttt);37////2. String ttt 取出value38//39// JSONObject jsonObject = new JSONObject(ttt);40// String ggg=jsonObject.getString("ttt");41// String gg2=jsonObject.getString("hhhh");42// Toast.makeText(MainActivity.this, ggg, 1).show();43//// Toast.makeText(MainActivity.this, gg2, 1).show();44////-----解析json数组45//46//47//} catch (IOException e) {48//// TODO Auto-generated catch block49// e.printStackTrace();50//} catch (JSONException e) {51//// TODO Auto-generated catch block52// e.printStackTrace();53//}54//55//56//====解析json数组57 InputStream inputStream=getResources().openRawResource(R.raw.j111503);58//把raw⽂件下的j111503⽂件下的所有内容变成输⼊流59try {60//inputStream.available() 流的可利⽤长度61byte pp[]=new byte[inputStream.available()];62//根据流的可利⽤长度转化为字节数组63 inputStream.read(pp);64//将流⾥的数据读到pp字节数组⾥6566 inputStream.close();67// 流中的资源使⽤完关闭留68 String tt=new String(pp);69//将byte字节数组转成字符串70//如果是乱码则String tt=new String(pp,"utf-8");或者gbk71//如果实现不了将json⽂件中的分号改为英⽂的逗号72 Log.e("aaaa", tt);73 JSONArray array=new JSONArray(tt);74//将字符串转成json数组75for(int i=0;i<array.length();i++){7677 String b0=array.getString(i);78//从数组⾥取出数组79 Log.e("aaaa", b0);80 }81 } catch (IOException e) {82// TODO Auto-generated catch block83 e.printStackTrace();84 } catch (JSONException e) {85// TODO Auto-generated catch block86 e.printStackTrace();87 }88 }899091 }补充步骤：解析带中括号的{}第⼀步：将⽂件转化为输⼊流，并将输⼊流存储到字节数组⾥关闭流InputStream inputStream=getResources().openRawResource(R.raw.j111502);byte[] ppp=new byte[inputStream.available]//根据流的可利⽤长度转化为字节数组inputStream.read(pp);//将流⾥的数据读到pp字节数组⾥inputStream.close();第⼆步：将字节数组转化为字符串，String ttt=new String(ppp);第三步：⽤jsonobject的⽅式取出字符，并显⽰JSONObject jsonObject = new JSONObject(ttt);String ggg=jsonObject.getString("ttt");String gg2=jsonObject.getString("hhhh");Toast.makeText(MainActivity.this, ggg, 1).show(); Toast.makeText(MainActivity.this, gg2, 1).show(); 第⼆种解析解析数组[]前⼏个步骤都⼀样只有最后⼀个步骤不⼀样第三步：将得到的数据保存到jsonarray⾥⾯，⽤循环的⽅式读取出来JSONArray array=new JSONArray(tt);//将字符串转成json数组for(int i=0;i<array.length();i++){String b0=array.getString(i);//从数组⾥取出数组Log.e("aaaa", b0);}ps：在Android⽅⾯是⼀个新⼿这是为了给我⾃⼰做⼀个笔记，如果有错误的话请各位⼤神指出谢谢。

Gson解析服务端返回的多种类型的JSON作者：秦川小将地址：/mjb00000/article/details/79297677声明：本文是秦川小将原创投稿，转发等请联系原作者授权。

遇到几种Json类型，使用Gson通过自定义解析器解析一下几种类型的返回数据。

返回Json中data为空{"data": "","code": 1,"message": "请求失败"}返回Json中data值为null{"data": null,"code": 1,"message": "请求失败"}返回Json中data为对象类型{"data": {"name": "秦川小将","phone": "182******08"},"code": 0,"message": "请求成功"}返回Json中的data为集合类型{"data": [{"name": "张三","phone": "182******08"}, {"name": "李四","phone": "182******08"}],"code": 0,"message": "请求成功"}返回Json中的data的值为字符串，解析时需要去除转义字符拿到具体的对象{"data": "{\"id\":2981,\"title\":\"除夕活动启动页\",\"content\":\"\",\"url\":\"/Activity/MonsterN ian20180215\"}","code": 0,"message": "请求成功"}返回Json中的data的值为字符串，解析时需要去除转义字符拿到具体的集合对象{"data": "[{\"id\":2981,\"title\":\"除夕活动启动页\",\"content\":\"\",\"url\":\"/Activity/MonsterN ian20180215\"},{\"id\":2849,\"title\":\"默认启动页\",\"content\":\"\",\"url\":\"\"}]","code": 0,"message": "请求成功"}为了防止重复写除data值以外的属性，这里定义一个基础类。

Gson使⽤总结⾼级⽤法MDGson基本⽤法参考：Gson提供了fromJson() 和toJson() 两个直接⽤于解析和⽣成的⽅法，前者实现反序列化，后者实现了序列化。

//基本数据类型的解析int i = gson.fromJson("100", int.class); //100boolean b = gson.fromJson("true", boolean.class); // trueString str = gson.fromJson("包青天", String.class); // 包青天//基本数据类型的⽣成String jsonNumber = gson.toJson(100); // 100String jsonBoolean = gson.toJson(true); // trueString jsonString = gson.toJson("包青天"); // 包青天System.out.println(i + " " + b + " " + str + " " + jsonNumber + " " + jsonBoolean + " " + jsonString);//100 true 包青天 100 true "包青天"POJO类的⽣成与解析class User {//省略构造函数、toString⽅法等public String name;public int age;}//⽣成JSONUser user = new User("包青天",24);String jsonObject = gson.toJson(user); // {"name":"包青天","age":24}//解析JSON：String jsonString = "{\"name\":\"包青天\",\"age\":24}";User user = gson.fromJson(jsonString, User.class);属性重命名 @SerializedName从上⾯POJO的⽣成与解析可以看出，JSON串中的 key 和JavaBean中的 field 是完全⼀致的，但有时候也会出现⼀些不和谐的情况，如：期望的json格式：{"name":"包青天","age":24,"emailAddress":"ikidou@"}实际的json格式：{"name":"包青天","age":24,"email_address":"ikidou@"}这对于使⽤PHP作为后台开发语⾔时很常见的情况，php和js在命名时⼀般采⽤下划线风格，⽽Java中⼀般采⽤的驼峰法，让后台的哥们改吧，前端和后台都不爽，但要⾃⼰使⽤下划线风格时我会感到不适应，怎么办？难到没有两全齐美的⽅法么？我们知道Gson在序列化和反序列化时需要使⽤反射，说到反射就不得不想到注解。

在Go语⾔程序中使⽤gojson来解析JSON格式⽂件gojson是快速解析json数据的⼀个golang包，你使⽤它可以快速的查找json内的数据安装go get /widuu/gojson使⽤简介结构复制代码代码如下:type Js struct {data interface{}}(1) func Json(data) *Js data为string类型,初始化Js结构，解析json并且return Js.data复制代码代码如下:json := `{"from":"en","to":"zh"}`c1 := gojson.Json(json) //&{map[from:en to:zh]}(2) func (*Js) Get() *js 获取简单json中的某个值，递归查找，return Js.data复制代码代码如下:json := `{"from":"en","to":"zh","trans_result":{"src":"today","dst":"\u4eca\u5929"},"result":["src","today","dst","\u4eca\u5929"]}` c2 := gojson.Json(json).Get("trans_result").Get("dst")fmt.Println(c2) //&{今天}c2 := gojson.Json(json).Get("from")fmt.Println(c2) //&{en}(3) func (*Js)Tostring()string 将单个数据转化成string类型,因为string类型转其它类型都⽐较好转就让数据返回string复制代码代码如下:c2 := gojson.Json(json).Get("from").Tostring()fmt.Println(c2) //en(4) func (j *Js) Getpath(args ...string) *Js 通过输⼊string的多个参数来获取某个值，json数据⼀定要是递归的复制代码代码如下:c4 := gojson.Json(json).Getpath("trans_result", "src").Tostring()fmt.Println(c4) //today(5) func (j *Js) Arrayindex(i int) string 获取Json数据中数组结构的值，根据输⼊的num来返回对应的值，仅限于处理{“result”: [“src”,”today”,”dst”,”\u4eca\u5929″]}中[]内的值复制代码代码如下:json := `{"from":"en","to":"zh","trans_result":{"src":"today","dst":"\u4eca\u5929"},"result":["src","today","dst","\u4eca\u5929"]}` c7 := gojson.Json(json).Get("result").Arrayindex(1)fmt.Println(c7) //src(6) func (j *Js) Getkey(key string, i int) *Js 这个函数是针对数据中有重复数据，取值，使⽤js.data必须是[]interface{}类型，这个是百度翻译时候返回的js可能会⽤到复制代码代码如下:json1 := `{"from":"en","to":"zh","trans_result":[{"src":"today","dst":"\u4eca\u5929"},{"src":"tomorrow","dst":"\u660e\u5929"}]}` c8 := gojson.Json(json1).Get("trans_result").Getkey("src", 1).Tostring()fmt.Println(c8) //则返回trans_result第⼀组中的src today(7) func (j *Js) ToArray() (k, d []string)将json数据转换成key []string{} value []string{} ⼀⼀对应的数组，只能使⽤到⼆级不能到多级复制代码代码如下:c9k, c9v := gojson.Json(json1).Get("trans_result").ToArray()fmt.Println(c9k, c9v) //[src dst src dst] [today 今天 tomorrow 明天]c3k, c3v := gojson.Json(json).Getindex(1).ToArray()fmt.Println(c3k, c3v) // [from] [en](8) func (j *Js) Getindex(i int) *Js 根据i返回json内的数据，可以逐级查找复制代码代码如下:json1 := `{"from":"en","to":"zh","trans_result":[{"src":"today","dst":"\u4eca\u5929"},{"src":"tomorrow","dst":"\u660e\u5929"}]}` c10 := gojson.Json(json1).Getindex(3).Getindex(1).Getindex(1).Get("src").Tostring()fmt.Println(c10) //today(9) func (j *Js) StringtoArray() []string 将{“result”:[“src”,”today”,”dst”,”\u4eca\u5929″]}数据json中的result对应的数据，返回成[]string的slice复制代码代码如下:c11 := gojson.Json(json).Get("result").StringtoArray()fmt.Println(c11) //[src today dst 今天](10) func (j *Js) Type() 打印测试⽤，打印数据类型复制代码代码如下:gojson.Json(json).Get("result").Type() //[]interface {}。

使用GSON和泛型解析约定格式的JSON串（转）{"success":true,"data":##}success：代表是否访问成功data:后面跟着所需信息.基本相同的JSON结构，所以想定义一种通用模型对应到此结构。

但是，data中的数据类型不一致。

如第一种是简单对象，第二种是对象中嵌套数组，第三种是List。

针对data数据类型不一致的情况，使用泛型来解import java.io.Serializable;import ng.reflect.ParameterizedType;import ng.reflect.Type;import com.google.gson.Gson;public class CommonJson<T> implements Serializable {/** **/private static final long serialVersionUID = -3440061414071692254L;/** * 是否成功*/private Boolean success;/** * 数据*/private T data;public Boolean getSuccess() {return success;}public void setSuccess(Boolean success) {this.success = success;}public T getData() {return data;}public void setData(T data) {this.data = data;}}GSON对于泛型的支持不足，为了使GSON对于泛型进行解析，JSON解析与组装代码如下：public static CommonJson fromJson(String json, Class clazz) {Gson gson = new Gson();Type objectType = type(CommonJson.class, clazz);return gson.fromJson(json, objectType);}public String toJson(Class<T> clazz) {Gson gson = new Gson();Type objectType = type(CommonJson.class, clazz);return gson.toJson(this, objectType);}static ParameterizedType type(final Class raw, final Type... args) {return new ParameterizedType() {public Type getRawType() {return raw;}public Type[] getActualTypeArguments() {return args;}public Type getOwnerType() {return null;}};}以上两段代码可以满足第一种和第二种JSON的解析，对于第三种，data是List类型的，无法得到List<>的class，所以，针对第三种格式，实现代码如下：import java.io.Serializable;import ng.reflect.ParameterizedType;import ng.reflect.Type;import java.util.List;import com.google.gson.Gson;public class CommonJson4List<T> implements Serializable {/** **/private static final long serialVersionUID = -369558847578246550L;/** * 是否成功*/private Boolean success;/** * 数据*/private List<T> data;public Boolean getSuccess() {return success;}public void setSuccess(Boolean success) {this.success = success;}public List<T> getData() {return data;}public void setData(List<T> data) {this.data = data;}public static CommonJson4List fromJson(String json, Class clazz) {Gson gson = new Gson();Type objectType = type(CommonJson4List.class, clazz);return gson.fromJson(json, objectType);}public String toJson(Class<T> clazz) {做出评价，}}执行结果如下：{"success":true,"data":{"averageStarLevel":4.7,"remarkCount":10}}true4.7{"success":true,"data":{"page":10,"pageCount":29,"list":[{"starLevel":4,"remarkCotnent":"评价方未及时做出评价，系统默认满意！","remarkTime":"2013-02-27 07:21:48","explainContent":"","postMemberId" 5929b**6{"success":true,"data":[{"starLevel":4,"remarkCotnent":"评价方未及时做出评价，系统默认满意！","remarkTime":"2013-02-27 07:21:48","explainContent":"","postMemberId":"y**f","tpLogoURL":"http://i04.c y**fPs：文中说到Gson对泛型的支持不足，其实是不正确的，Gson对泛型做了以下支持：public static CommonJson4List fromJson(String json, Class clazz) {Gson gson = new Gson();Type objectType = new TypeToken<CommonJson4List<clazz>>() {}.getType();return gson.fromJson(json, objectType);}只需将获取类型的泛型类作为TypeToken的泛型参数构造一个匿名的子类，就可以通过getType方法获取一个parameterized类型，结果与type方法一致。