Android利用Gson实现对象和Json数据的相互转换

AndroidStudio插件GsonFormat之Json快速转换JavaBean教程安装⽅法⼀：1.Android studio File->Settings..->Plugins–>Browse repositores..搜索GsonFormat2.安装插件,重启android studio⽅法⼆：1.下载GsonFormat.jar ;2.Android studio File->Settings..->Plugins –>install plugin from disk..导⼊下载GsonFormat.jar3.重启android studio使⽤⽅法在实体类中使⽤Generate的快捷键.快捷键:图中选中的部分简单的实体类图中简单的 json 格式{"name": "王五","gender": "man","age": 15,"height": "140cm",}⽣成结果：package zhangxueyuan.myapplication; /*** Created by xueyuan on 2015/6/15. */public class Bean {/*** height : 140cm* age : 15* name : 王五* gender : man*/private String height;private int age;private String name;private String gender;public void setHeight(String height) { this.height = height;}public void setAge(int age) {this.age = age;}public void setName(String name) { = name;}public void setGender(String gender) {this.gender = gender;}public String getHeight() {return height;}public int getAge() {return age;}public String getName() {return name;}public String getGender() {return gender;}}发现不需要继承JSONModle.补充知识：Android json与bean之间格式化我就废话不多说了，直接看代码吧！public void onSuccessArray(int statusCode, JSONArray response) {BalanceEntity balanceEntity=new Gson().fromJson(response.toString(), BalanceEntity.class);以上这篇AndroidStudio插件GsonFormat之Json快速转换JavaBean教程就是⼩编分享给⼤家的全部内容了，希望能给⼤家⼀个参考，也希望⼤家多多⽀持。

JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，采用完全独立于语言的文本格式，为Web应用开发提供了一种理想的数据交换格式。

在上一篇博文《Android学习笔记44：JSON数据解析》中，我们使用基本的JSON API完成了在服务器端创建JSON数据，以及在Android客户端对JSON数据进行解析。

其实，要创建和解析JSON数据，也可以使用GSON来完成。

GSON是Google提供的用来在Java 对象和JSON数据之间进行映射的Java类库。

使用GSON，可以很容易的将一串JSON数据转换为一个Java对象，或是将一个Java对象转换为相应的JSON数据。

1.GSON的两个重要方法在GSON的API中，提供了两个重要的方法：toJson()和fromJson()方法。

其中，toJson()方法用来实现将Java对象转换为相应的JSON数据，fromJson()方法则用来实现将JSON数据转换为相应的Java对象。

1.1 toJson()方法toJson()方法用于将Java对象转换为相应的JSON数据，主要有以下几种形式：（1）String toJson(JsonElement jsonElement);（2）String toJson(Object src);（3）String toJson(Object src, Type typeOfSrc);其中，方法（1）用于将JsonElement对象（可以是JsonObject、JsonArray等）转换成JSON数据；方法（2）用于将指定的Object对象序列化成相应的JSON数据；方法（3）用于将指定的Object对象（可以包括泛型类型）序列化成相应的JSON数据。

1.2 fromJson()方法fromJson()方法用于将JSON数据转换为相应的Java对象，主要有以下几种形式：（1）<T> T fromJson(JsonElement json, Class<T> classOfT);（2）<T> T fromJson(JsonElement json, Type typeOfT);（3）<T> T fromJson(JsonReader reader, Type typeOfT);（4）<T> T fromJson(Reader reader, Class<T> classOfT);（5）<T> T fromJson(Reader reader, Type typeOfT);（6）<T> T fromJson(String json, Class<T> classOfT);（7）<T> T fromJson(String json, Type typeOfT);以上的方法用于将不同形式的JSON数据解析成Java对象。

gson配置混淆规则在进行gson配置混淆规则之前，首先需要了解gson是什么以及为什么需要进行混淆。

Gson是Google提供的用于Java对象和JSON数据之间互相转换的Java库。

它可以将Java对象转换为JSON字符串，也可以将JSON字符串转换为Java对象。

由于在Android开发中，JSON数据的使用非常普遍，因此gson被广泛应用于对象的序列化和反序列化过程。

然而，在正式发布应用程序之前，我们需要对应用程序进行混淆以提高代码的安全性，并且减小应用程序的大小。

在进行gson配置混淆规则之前，我们需要确保在项目的build.gradle文件中已经添加了gson 库的依赖，例如：```dependencies {implementation 'com.google.code.gson:gson:2.8.8'}```接下来，我们需要在混淆文件(proguard-rules.pro)中添加gson的混淆规则。

混淆规则告诉混淆器不要混淆关于gson库的代码和类名。

以下是一些常见的gson混淆规则示例：```-keep class com.google.gson.** { *; }-keepclassmembers,allowobfuscation class * {@com.google.gson.annotations.SerializedName <fields>;}-keepattributes *Annotation*,Signature```上述混淆规则的作用分别是：1. 保持com.google.gson包中所有的类和方法不被混淆。

2. 保持带有@SerializedName注解的字段不被混淆。

3. 保持所有带有注解的属性不被移除。

使用上述规则，可以确保gson库的代码和类名在混淆过程中不会被修改或移除，从而保证了gson库正常运行和正确解析JSON数据的能力。

gsonconverterfactory 原理-回复GsonConverterFactory是Retrofit库中的一个转换器工厂，用于将网络请求的数据转换为Java对象或将Java对象转换为网络请求的数据。

它基于Google开源的Gson库，提供了灵活而强大的JSON解析和生成功能。

GsonConverterFactory的原理可以从以下几个方面来讨论：1. Gson库介绍2. Retrofit库介绍3. GsonConverterFactory的实现原理1. Gson库介绍Gson是Google开源的Java库，用于处理JSON数据的序列化和反序列化。

它可以将Java对象转换为JSON格式的字符串，也可以将JSON 格式的字符串转换为Java对象。

Gson库提供了丰富的API，使开发者可以灵活地处理不同的JSON数据格式和结构。

2. Retrofit库介绍Retrofit是一个针对Android和Java的RESTful网络请求库。

它基于OkHttp库，并结合了注解和反射机制，提供了一种简化网络请求的方式。

Retrofit的核心思想是将网络请求的URL、参数、请求方式等信息抽象成接口，并使用注解的方式来描述网络请求的相关信息。

Retrofit库中的Converter接口定义了转换器的规范，Converter.Factory是一个转换器工厂接口，用于创建不同类型的转换器实例。

GsonConverterFactory就是Converter.Factory的一个具体实现，用于创建基于Gson库的转换器实例。

3. GsonConverterFactory的实现原理GsonConverterFactory实现了Converter.Factory接口，并且提供了一个create方法，用于创建GsonConverter转换器实例。

在该方法的实现中，会创建一个Gson对象，并将其与GsonRequestBodyConverter 和GsonResponseBodyConverter关联起来。

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中即可。

使⽤Gson将字符串转换成JsonObject和JsonArray ⽬录Gson将字符串转JsonObject和JsonArray以下均利⽤Gson来处理JSONObject与JSON互转引⼊ jar , 此处引⼊ com.alibaba.fastjson 版本的jar包建⽴测试类对象转换Gson将字符串转JsonObject和JsonArray以下均利⽤Gson来处理1.将bean转换成Json字符串：public static String beanToJSONString(Object bean) {return new Gson().toJson(bean);}2.将Json字符串转换成对象：public static Object JSONToObject(String json,Class beanClass) {Gson gson = new Gson();Object res = gson.fromJson(json, beanClass);return res;}注：转换后的对象使⽤前进⾏强转：例如bean bean1 = (bean)FormatUtil.JSONToObject(json, bean.class);3.将Json字符串转换成JsonObject对象：JsonObject returnData = new JsonParser().parse(jsonstr).getAsJsonObject();4.将JsonArray类型的Json字符串解析成对象⽅法Gson gson = new Gson();JsonParser parser = new JsonParser();JsonArray Jarray = parser.parse(jstring).getAsJsonArray();ArrayList<channelSearchEnum> lcs = new ArrayList<channelSearchEnum>();for(JsonElement obj : Jarray ){channelSearchEnum cse = gson.fromJson( obj , channelSearchEnum.class);lcs.add(cse);}或者String json = "[{\"username\":\"test\"},{\"username\":\"test2\"}]";System.out.println(new JsonParser().parse(json).getAsJsonArray().get(0).getAsJsonObject().get("username").getAsString());5.获取JsonObject中指定key值对应的JsonArray对象：String json= "{\"pids\":[\"1\",\"2\",\"3\"]}";System.out.println(new JsonParser().parse(json).getAsJsonObject().getAsJsonArray("pids").get(0).getAsString()); JSONObject与JSON互转使⽤⽬的⽬前数据交互⼤多以 JSON 字符串为信息传输，主要格式有{"age":"22","name":"李四"}[{"age":"21","name":"张三"}]最常见的应⽤场景是前后端对接，第三⽅平台⽂档对接，下⾯展⽰转换使⽤。

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数据了。

gson的用法Gson是一个Google开发的用于Java和Android应用的Java库，可以将Java对象转换为JSON格式的字符串，并将JSON格式的字符串转换为Java对象。

Gson可以帮助开发人员在Java和Android应用中轻松地解析和生成JSON格式的数据。

本文将介绍Gson的用法和常用方法。

1. 导入Gson库首先，我们需要在我们的项目中导入Gson库。

如果使用Gradle，可以在build.gradle文件中添加以下依赖项：```groovydependencies {implementation 'com.google.code.gson:gson:2.8.6'}```如果使用Maven，可以在pom.xml文件中添加以下依赖项：2. 将Java对象转换为JSON格式的字符串Gson可以将Java对象转换为JSON格式的字符串。

以下是将Java对象转换为JSON字符串的示例代码：```javapublic class Person {private String name;private int age;private String gender;// getters and setters}Person person = new Person();person.setName("Alice");person.setAge(20);person.setGender("Female");Gson gson = new Gson();String json = gson.toJson(person);System.out.println(json);```输出结果可能类似于：```json{"name": "Alice","age": 20,"gender": "Female"}```在这个例子中，我们创建了一个Person对象，并使用Gson将它转换为一个JSON格式的字符串。

android jsonobject转map的方法在Android中，可以使用Gson库将JSONObject对象转换为Map对象。

以下是一个示例代码：```javaimport com.google.gson.Gson;import com.google.gson.reflect.TypeToken;import org.json.JSONObject;import ng.reflect.Type;import java.util.Map;public class JsonUtils {public static Map<String, Object>jsonObjectToMap(JSONObject jsonObject) {Gson gson = new Gson();Type type = new TypeToken<Map<String, Object>>() {}.getType();Map<String, Object> map =gson.fromJson(jsonObject.toString(), type);return map;}}```使用时，你只需传入一个JSONObject对象，然后调用`jsonObjectToMap()`方法即可将其转换为Map对象：```javaJSONObject jsonObject = new JSONObject(jsonString);Map<String, Object> map =JsonUtils.jsonObjectToMap(jsonObject);```请注意，这里使用了Gson库来进行JSON和Map的转换，因此需要在你的项目中引入Gson库的依赖。

你可以在项目的`build.gradle`文件中添加以下代码来引入Gson库：```implementation 'com.google.code.gson:gson:2.8.6'```。

gson 例子Gson 示例Gson（Google 的 JSON 库）是一个用于将 Java 对象转换成 JSON 字符串，或将 JSON 字符串转换成 Java 对象的库。

它能够帮助开发人员在 Java 对象和 JSON 数据之间进行简单而灵活的转换。

下面是一个使用 Gson 库的示例：假设我们有一个名为 User 的 Java 类，具有以下属性：```javapublic class User {private String name;private int age;private String profession;// 构造函数、getter 和 setter 方法省略}```我们想要将一个 User 对象转换成 JSON 字符串：```javaUser user = new User("John Doe", 25, "Software Engineer");Gson gson = new Gson();String json = gson.toJson(user);```上述代码中，我们首先创建了一个 User 对象，然后创建了一个 Gson 对象。

接下来，我们使用 `toJson()` 方法将 User 对象转换成 JSON 字符串，并将其赋值给变量 `json`。

现在，我们可以打印输出 `json`，即可看到 User 对象被转换成了 JSON 字符串：```{"name":"John Doe","age":25,"profession":"Software Engineer"}```与此相反，如果我们有一个 JSON 字符串，希望将其转换成一个 User 对象：```javaString json = "{\"name\":\"John Doe\",\"age\":25,\"profession\":\"SoftwareEngineer\"}";Gson gson = new Gson();User user = gson.fromJson(json, User.class);```上述代码中，我们首先创建了一个字符串 `json`，其中包含了用 JSON 表示的User 对象。

JSON与对象的相互转换json是⼀种轻量级的数据格式，（本质为字符串）低版本可以使⽤json2.js插件来解决。

下载地址：https:///douglascrockford/JSON-js JSON语法：数据在名称/值对中、数据由逗号分隔、花括号保存对象、⽅括号保存数组'{"name":"⼩明","age":18}''["name":"⼩明","age",18]'把JSON格式转成对象：JSON.parse()注意：JSON格式必须为标准的JSON格式key值必须是双引号（单引号会报错）value如果是字符串也要加双引号let json = '[{"name":"⼩明","age":18},{"name":"⼩花","age":16}]';json = JSON.parse(json);console.log(json);把对象转成标准json：JSON.stringify()let obj = {name:'⼩明','age':18,a:function(){},b:true};console.log(JSON.stringify(obj));//{"name":"⼩明","age":18,"b":true}注：转不了undefined和函数（即使转了也不会显⽰）eval()：能够把字符串尽量转成js运⾏的代码⼩技巧 - > 在使⽤eval传化json的时候，json⽤字符串括号包⼀下 eval('('+json+')')eval是不安全的（可能会注⼊不必要的东西），通过new Function('','return'+json)();可以解决该问题 let json = "{'name':'蜘蛛侠'}";// console.log(JSON.parse(json));// console.log(eval('('+ json +')'));// console.log(new Function('a,b','return a+b')(1,2));console.log(new Function('','return'+json)());。

利用 Gson 进行JSON 数据处理和解析利用 Gson 进行 JSON 数据处理和解析在现代软件开发中，处理和解析 JSON 数据是一项重要的任务。

JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，广泛应用于前后端数据传输、API 接口设计等领域。

为了简化开发过程，我们可以使用 Gson 这个强大的库来进行 JSON 数据的处理和解析。

1. 引言Gson 是 Google 提供的一个开源 Java 库，用于将 JSON 字符串转换为 Java 对象，以及将 Java 对象转换为 JSON 字符串。

它提供了简洁方便的 API，可以轻松地实现 JSON 数据的处理和解析。

在继续深入之前，我们需要先了解 Gson 以及它的一些基本用法。

2. Gson 的基本用法首先，我们需要在项目中引入 Gson 库。

可以通过在项目的build.gradle 文件中添加以下依赖来实现：```groovydependencies {implementation 'com.google.code.gson:gson:2.8.6'}```引入 Gson 之后，我们可以使用它的核心类 Gson 来进行 JSON 的处理和解析。

下面是一些常用的方法：- 将 JSON 字符串转换为 Java 对象：```javaString jsonStr = "{\"name\":\"John\", \"age\":30, \"city\":\"New York\"}";Gson gson = new Gson();Person person = gson.fromJson(jsonStr, Person.class);```- 将 Java 对象转换为 JSON 字符串：```javaPerson person = new Person("John", 30, "New York");Gson gson = new Gson();String jsonStr = gson.toJson(person);```这些方法实际上是将 JSON 的键值对映射到对应的 Java 对象的属性上，或者将 Java 对象的属性转换为 JSON 的键值对。

使用Gson将Java对象转换为JSONGson是一个开源的Java库，可以用来将Java对象转换为JSON格式的字符串，以及将JSON字符串转换回Java对象。

首先，需要在项目中引入Gson库。

可以通过Maven或Gradle将其作为依赖项添加到项目中，或者在项目设置中手动添加Gson库的JAR文件。

转换Java对象为JSON：```javaGson gson = new Gson(;```接下来，可以通过调用Gson对象的toJson方法将Java对象转换为JSON字符串。

```javaMyObject myObject = new MyObject("value1", "value2");String jsonString = gson.toJson(myObject);```其中，MyObject是一个自定义的Java类，有两个属性：value1和value2、toJson方法将该对象转换为如下格式的JSON字符串：```json{"value1":"value1", "value2":"value2"}```转换JSON为Java对象：将JSON字符串转换为Java对象同样简单。

需要调用Gson对象的fromJson方法，并传递JSON字符串和目标Java类作为参数。

```javaString jsonString = "{\"value1\":\"value1\",\"value2\":\"value2\"}";MyObject myObject = gson.fromJson(jsonString,MyObject.class);```这将生成一个MyObject对象，其中value1和value2属性的值分别为"value1"和"value2"。

android 标准json用法JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，常用于在不同平台之间传递和存储数据。

在Android开发中，使用标准的JSON用法可以实现数据的序列化和反序列化，方便数据的传输和处理。

Android提供了许多库和类来处理JSON数据，其中最常用的是`JSONObject`和`JSONArray`类。

`JSONObject`用于表示一个JSON对象，而`JSONArray`用于表示一个JSON数组。

要使用标准的JSON用法，首先需要导入相关的库或类。

在Android开发中，通常会使用GSON或Jackson这样的第三方库来处理JSON数据。

这些库可以通过Gradle或Maven的依赖管理工具进行导入。

一般来说，使用标准的JSON用法包括以下几个步骤：1. 创建JSON对象或数组：通过`JSONObject`或`JSONArray`类的构造函数创建一个空的JSON对象或数组。

2. 添加数据：使用`put`方法向JSON对象中添加键值对，或使用`add`方法向JSON数组中添加元素。

3. 序列化：将JSON对象或数组转化为字符串，以便在网络传输或存储时使用。

可以使用`toString`方法将JSON对象或数组转化为字符串。

4. 反序列化：将从网络或存储中获取的JSON字符串转化为JSON对象或数组。

可以使用`JSONObject`或`JSONArray`类的静态方法`parse`或`fromObject`来进行反序列化。

5. 获取数据：通过键或索引来获取JSON对象或数组中的数据。

可以使用`opt`方法获取可选的数据，并提供一个默认值。

除了以上步骤，还可以使用其他的JSON处理方法，如解析嵌套JSON数据、处理日期和时间等。

总之，标准的JSON用法在Android开发中非常常用，它可以方便地处理和传输数据。

通过合理使用相关的库和类，可以轻松地实现JSON数据的序列化和反序列化操作，提高开发效率。

使用gson将复杂的对象转换为json的过程是软件开发中一种有趣而有用的技术。

代表Google的JSON的Gson是一个Java库，可用于将Java对象转换为他们的JSON代表。

在本篇文章中，我们将探讨Gson如何完成这项任务的基本原则。

必须理解序列化的概念。

序列化（Serialization）是将一个对象转换成一个字节流的过程，以便存储对象或传送到内存，数据库，或文件。

在gson中，序列化是指将一个复杂的Java对象转换成其JSON表示的过程。

Gson通过利用Java的反射API来实现这一点，它允许程序在运行时检查和修改类的结构和行为。

当Gson被指示将一个复杂的对象序列化时，它利用反射来分析对象的结构并提取其字段及其值。

Gson然后构造一个JSON对象，以反射原Java对象的结构，每个字段在JSON对象中作为密钥值对表示。

在序列化过程中，gson还考虑到任何可能适用于Java对象的自定义说明或命名惯例。

如果Java对象中的一个字段已经使用 gson 的＠序列化Name 注释附加了特定名称， Gson 在构建 JSON 对象中对应的密钥时将会使用指定名称。

除了基本字段外，gson还能够序列化更复杂的类型，如列表，阵列，以及嵌套对象。

当gson遇到一个属于收藏类型的字段时，它递归序列地将收藏中的每个元素进行序列化，并构造一个JSON阵列来代表整个收藏。

同样，当gson遇到一个属于对象类型的字段时，它会递归序列化嵌入物，并构造一个JSON对象来代表嵌入物的结构。

Gson序列化过程的一个关键方面是支持处理循环引用。

当复杂数据结构中的两个或两个以上对象相互参照时，就会出现循环引用，形成循环。

Gson通过维持一个已经序列化的物体的登记册，能够检测和处理循环引用。

当gson遇到一个已经序列化的对象时，它只是包括了对之前序列化对象的引用，而不是试图再次序列化对象。

这保证了gson能够处理复杂的对象图，而不会被卡在一个无限循环中。

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的值。