gson解析json示例源码,gson解析json字符串

发布时间：2022-11-24

本文目录一览：

  1. 用gson如何处理json转换Timestamp类型
  2. Android使用Gson解析网络接口返回的Json数据
  3. gson怎么解析jsonarray
  4. Java解析json数据
  5. 如何通过gson解析存储的json数组字符串

用gson如何处理json转换Timestamp类型

原代码：

private static final Gson GSON = new Gson();

新代码：

private static final Gson GSON = new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create();

改后测试了一下，竟然不起作用，奇怪！接着 debug 了一下，发现原来因为使用了 hibernate，对象中的日期类型是 timestamp 类型。上面的设置没起作用。接着又找了一下，还有对应方案如下：

String dfString = format.format(new Date(ts.getTime()));
return new JsonPrimitive(dfString);
}
public Timestamp deserialize(JsonElement json, Type t, JsonDeserializationContext jsc) throws JsonParseException {
    if (!(json instanceof JsonPrimitive)) {
        throw new JsonParseException("...");
    }
}

Android使用Gson解析网络接口返回的Json数据

Gson 挺好用的，可以把 json 串直接解析成 bean 对象，或者把对象转换成 json 串，数据解析的时候先创建 Gson 对象：

Gson mGson = new Gson();

然后再把 json 串解析成 bean 对象：

Bean bean = mGson.fromJson(json, Bean.class);

如果想把对象转成 json 串可以用 gson 的 toJson 方法：

String json = mGson.toJson();

纯手打，满意请采纳

gson怎么解析jsonarray

JSON 是一种类似于 XML 的通用数据交换格式，具有比 XML 更高的传输效率。 从结构上看，所有的数据（data）最终都可以分解成三种类型：

  1. 标量（scalar）：也就是一个单独的字符串（string）或数字（numbers），比如 "北京" 这个单独的词。
  2. 序列（sequence）：也就是若干个相关的数据按照一定顺序并列在一起，又叫做数组（array）或列表（List），比如 "北京，上海"。
  3. 映射（mapping）：也就是一个名/值对（Name/value），即数据有一个名称，还有一个与之相对应的值，这又称作散列（hash）或字典（dictionary），比如 "首都：北京"。 JSON 的规格非常简单，只用一个页面几百个字就能说清楚，而且 Douglas Crockford 声称这个规格永远不必升级，因为该规定的都规定了：
  4. 并列的数据之间用逗号（","）分隔。
  5. 映射用冒号（":"）表示。
  6. 并列数据的集合（数组）用方括号（"[]"）表示。
  7. 映射的集合（对象）用大括号（"{}"）表示。 在 Android 中可以使用 Gson 解析 JSON 数据。 首先，从 code.google.com/p/google-gson/downloads/list 下载 Gson API：
  • google-gson-1.7.1-release.zip 把 gson-1.7.jar copy 到 libs（项目根目录新建一个 libs 文件夹）中。 可以使用以下两种方法解析 JSON 数据： 通过获取 JsonReader 对象解析 JSON 数据。

Java解析json数据

一、JSON （JavaScript Object Notation）一种简单的数据格式，比 XML 更轻巧。

JSON 建构于两种结构：

  1. “名称/值”对的集合（A collection of name/value pairs）。不同的语言中，它被理解为对象（object），纪录（record），结构（struct），字典（dictionary），哈希表（hash table），有键列表（keyed list），或者关联数组（associative array）。例如：
{
  "name": "jackson",
  "age": 100
}
  1. 值的有序列表（An ordered list of values）。在大部分语言中，它被理解为数组（array）。例如：
{
  "students": [
    {"name": "jackson", "age": 100},
    {"name": "michael", "age": 51}
  ]
}

二、Java 解析 JSON 步骤

A. 服务器端将数据转换成 JSON 字符串

首先，服务器端项目要导入 JSON 的 jar 包和 JSON 所依赖的 jar 包至 builtPath 路径下（这些可以到 JSON-lib 官网下载）。 然后将数据转为 JSON 字符串，核心函数是：

public static String createJsonString(String key, Object value) {
    JSONObject jsonObject = new JSONObject();
    jsonObject.put(key, value);
    return jsonObject.toString();
}

B. 客户端将 JSON 字符串转换为相应的 JavaBean

  1. 客户端获取 JSON 字符串（因为 Android 项目中已经集成了 JSON 的 jar 包所以这里无需导入）：
public class HttpUtil {
    public static String getJsonContent(String urlStr) {
        try {
            URL url = new URL(urlStr);
            HttpURLConnection httpConn = (HttpURLConnection) url.openConnection();
            httpConn.setConnectTimeout(3000);
            httpConn.setDoInput(true);
            httpConn.setRequestMethod("GET");
            int respCode = httpConn.getResponseCode();
            if (respCode == 200) {
                return ConvertStream2Json(httpConn.getInputStream());
            }
        } catch (MalformedURLException | IOException e) {
            e.printStackTrace();
        }
        return "";
    }
    private static String ConvertStream2Json(InputStream inputStream) {
        String jsonStr = "";
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int len = 0;
        try {
            while ((len = inputStream.read(buffer, 0, buffer.length)) != -1) {
                out.write(buffer, 0, len);
            }
            jsonStr = new String(out.toByteArray());
        } catch (IOException e) {
            e.printStackTrace();
        }
        return jsonStr;
    }
}
  1. 获取 JavaBean：
public static Person getPerson(String jsonStr) {
    Person person = new Person();
    try {
        JSONObject jsonObj = new JSONObject(jsonStr);
        JSONObject personObj = jsonObj.getJSONObject("person");
        person.setId(personObj.getInt("id"));
        person.setName(personObj.getString("name"));
        person.setAddress(personObj.getString("address"));
    } catch (JSONException e) {
        e.printStackTrace();
    }
    return person;
}
public static List<Person> getPersons(String jsonStr) {
    List<Person> list = new ArrayList<>();
    JSONObject jsonObj;
    try {
        jsonObj = new JSONObject(jsonStr);
        JSONArray personList = jsonObj.getJSONArray("persons");
        for (int i = 0; i < personList.length(); i++) {
            JSONObject jsonItem = personList.getJSONObject(i);
            Person person = new Person();
            person.setId(jsonItem.getInt("id"));
            person.setName(jsonItem.getString("name"));
            person.setAddress(jsonItem.getString("address"));
            list.add(person);
        }
    } catch (JSONException e) {
        e.printStackTrace();
    }
    return list;
}

如何通过gson解析存储的json数组字符串

引入 gson-1.4.jar（挺蛋疼的，不想自己研究这玩意，寻思网上直接找现成的 Demo，结果没有我想要的东西）。 Gson 中重要的几个核心类：

  • Gson
  • JsonParser
  • JsonObject
  • JsonArray 下面演示这两个类之间的转换过程：
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
public class GsonTest {
    public static void main(String[] args) {
        Map<String, Object> map = new HashMap<>();
        map.put("name", "nam1");
        map.put("age", "12");
        List<Object> list = new ArrayList<>();
        list.add("name");
        list.add("123");
        list.add(map);
        // json 格式的字符串
        String str = "[{'name':'kevin','age':25},{'name':'cissy','age':24}]";
        // 创建一个 Gson 对象
        Gson gson = new Gson();
        // 把 Java 对象转换成 Json 字符串
        String jsonStr = gson.toJson(map);
        System.out.println(jsonStr);
        // 把集合对象转换成 Json 字符串
        jsonStr = gson.toJson(list);
        System.out.println(jsonStr);
        // 创建一个 JsonParser
        JsonParser parser = new JsonParser();
        // 通过 JsonParser 对象可以把 json 格式的字符串解析成一个 JsonElement 对象
        JsonElement el = parser.parse(str);
        // 把 JsonElement 对象转换成 JsonObject
        JsonObject jsonObj = null;
        if (el.isJsonObject()) {
            jsonObj = el.getAsJsonObject();
        }
        // 把 JsonElement 对象转换成 JsonArray
        JsonArray jsonArray = null;
        if (el.isJsonArray()) {
            jsonArray = el.getAsJsonArray();
        }
        // 遍历 JsonArray 对象
        MyField field = null;
        Iterator<JsonElement> it = jsonArray.iterator();
        while (it.hasNext()) {
            JsonElement e = it.next();
            // JsonElement 转换为 JavaBean 对象
            field = gson.fromJson(e, MyField.class);
            System.out.println(field.getName() + " === " + field.getAge());
        }
    }
}
class MyField {
    private String name;
    private Integer age;
    public MyField() {}
    public MyField(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
}
推荐文章