如何在Java中将jsonString转换为JSONObject

JSON 主页链接了各种 Java JSON 序列化程序和反序列化程序。

在撰写本文时，有以下 22 个：

• JSON-java 中。
• JSONUtil。
• jsonp。
• json-lib 中。
• 字符串树。
• SOJO的。
• json-taglib 中。
• Flexjson的。
• 阿尔戈。
• jsonij 中。
• fastjson 中。
• mjson 中。
• jjson 中。
• json-simple。
• json-io。
• 谷歌-gson。
• FOSS Nova JSON的。
• 玉米转换器。
• 阿帕奇 johnzon。
• 根森。
• cookjson 中。
• progbase。

...但当然，列表可以更改。

使用 org.json 库：

try {
     JSONObject jsonObject = new JSONObject("{\"phonetype\":\"N95\",\"cat\":\"WP\"}");
}catch (JSONException err){
     Log.d("Error", err.toString());
}

您可以使用 .详：google-gson

对象示例

class BagOfPrimitives {
  private int value1 = 1;
  private String value2 = "abc";
  private transient int value3 = 3;
  BagOfPrimitives() {
    // no-args constructor
  }
}

（序列化）

BagOfPrimitives obj = new BagOfPrimitives();
Gson gson = new Gson();
String json = gson.toJson(obj); 
==> json is {"value1":1,"value2":"abc"}

请注意，不能使用循环引用序列化对象，因为这将导致无限递归。

（反序列化）

BagOfPrimitives obj2 = gson.fromJson(json, BagOfPrimitives.class);  
==> obj2 is just like obj

Gson 的另一个例子：

Gson简单易学，实现起来，你需要知道的是以下两种方法：

-> toJson（） – 将 java 对象转换为 JSON 格式

-> fromJson（） – 将 JSON 转换为 java 对象

import com.google.gson.Gson;

public class TestObjectToJson {
  private int data1 = 100;
  private String data2 = "hello";

  public static void main(String[] args) {
      TestObjectToJson obj = new TestObjectToJson();
      Gson gson = new Gson();

      //convert java object to JSON format
      String json = gson.toJson(obj);

      System.out.println(json);
  }

}

输出

{"data1":100,"data2":"hello"}

资源：

Google Gson 项目主页

Gson 用户指南

例

我喜欢为此使用 google-gson，正是因为我不需要直接使用 JSONObject。

在这种情况下，我将有一个类，它将对应于JSON对象的属性

class Phone {
 public String phonetype;
 public String cat;
}


...
String jsonString = "{\"phonetype\":\"N95\",\"cat\":\"WP\"}";
Gson gson = new Gson();
Phone fooFromJson = gson.fromJson(jsonString, Phone.class);
...

但是，我认为您的问题更像是，如何从 JSON 字符串中获得实际的 JSONObject 对象。

我正在查看 google-json api，但找不到任何像 org.json 的 api，如果您非常需要使用准系统 JSONObject，这可能是您想要使用的。

http://www.json.org/javadoc/org/json/JSONObject.html

使用 org.json.JSONObject（另一个完全不同的 API） 如果你想做类似的事情......

JSONObject jsonObject = new JSONObject("{\"phonetype\":\"N95\",\"cat\":\"WP\"}");
System.out.println(jsonObject.getString("phonetype"));

我认为google-gson的美妙之处在于你不需要处理JSONObject。你只需抓取 json，将要反序列化的类传递进去，你的类属性就会与 JSON 匹配，但话又说回来，每个人都有自己的要求，也许你负担不起在反序列化端拥有预映射类的奢侈，因为 JSON 生成端的事情可能太动态了。在这种情况下，只需使用 json.org。

如果您使用的是 http://json-lib.sourceforge.net （net.sf.json.JSONObject）

这很简单：

String myJsonString;
JSONObject json = JSONObject.fromObject(myJsonString);

或

JSONObject json = JSONSerializer.toJSON(myJsonString);

然后使用 OR/and 获取值，依此类推。json.getString(param)json.getInt(param)

将字符串转换为 json，并且 sting 类似于 json。{“phonetype”：“N95”，“cat”：“WP”}

String Data=response.getEntity().getText().toString(); // reading the string value 
JSONObject json = (JSONObject) new JSONParser().parse(Data);
String x=(String) json.get("phonetype");
System.out.println("Check Data"+x);
String y=(String) json.get("cat");
System.out.println("Check Data"+y);

用于将 json 单个对象设置为列表 即

"locations":{

}

在List<Location>

用

ObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);

jackson.mapper-asl-1.9.7.jar

必须导入 org.json

JSONObject jsonObj = null;
        try {
            jsonObj = new JSONObject("{\"phonetype\":\"N95\",\"cat\":\"WP\"}");
        } catch (JSONException e) {
            e.printStackTrace();
        }

对于仍在寻找答案的人：

JSONParser parser = new JSONParser();
JSONObject json = (JSONObject) parser.parse(stringToParse);

最好使用 lib 以更简单的方式进行。只需执行非常简单的方法，如下所示：org.json

JSONObject obj = new JSONObject();
obj.put("phonetype", "N95");
obj.put("cat", "WP");

现在是各自字符串的转换形式。如果您有名称/值对，则会出现这种情况。objJSONObject

对于字符串，您可以直接传递给 的构造函数。如果它是有效的，那么没问题，否则它会抛出异常。JSONObjectjson String

Java 7 解决方案

import javax.json.*;

...

String TEXT;
JsonObject body = Json.createReader(new StringReader(TEXT)).readObject()

;

要转换为 您只需要将实例传递给 的构造函数。StringJSONObjectStringJSONObject

例如：

JSONObject jsonObj = new JSONObject("your string");

使用 fasterxml 的 JsonNode 进行泛型 Json 解析。它在内部为所有输入创建一个键值映射。

例：

private void test(@RequestBody JsonNode node)

input 字符串 ：

{"a":"b","c":"d"}

请注意，反序列化接口的 GSON 将导致如下所示的异常。

"java.lang.RuntimeException: Unable to invoke no-args constructor for interface XXX. Register an InstanceCreator with Gson for this type may fix this problem."

反序列化时;GSON 不知道必须为该接口指定哪个对象。

这在这里以某种方式得到解决。

但是，FlexJSON本身就具有这种解决方案。在序列化时间时，它将类名添加为 JSON 的一部分，如下所示。

{
    "HTTPStatus": "OK",
    "class": "com.XXX.YYY.HTTPViewResponse",
    "code": null,
    "outputContext": {
        "class": "com.XXX.YYY.ZZZ.OutputSuccessContext",
        "eligible": true
    }
}

所以 JSON 会有些累赘;但你不需要GSON中需要的写入。InstanceCreator

无需使用任何外部库。

你可以用这个类代替:)（处理偶数列表、嵌套列表和json）

public class Utility {

    public static Map<String, Object> jsonToMap(Object json) throws JSONException {

        if(json instanceof JSONObject)
            return _jsonToMap_((JSONObject)json) ;

        else if (json instanceof String)
        {
            JSONObject jsonObject = new JSONObject((String)json) ;
            return _jsonToMap_(jsonObject) ;
        }
        return null ;
    }


   private static Map<String, Object> _jsonToMap_(JSONObject json) throws JSONException {
        Map<String, Object> retMap = new HashMap<String, Object>();

        if(json != JSONObject.NULL) {
            retMap = toMap(json);
        }
        return retMap;
    }


    private static Map<String, Object> toMap(JSONObject object) throws JSONException {
        Map<String, Object> map = new HashMap<String, Object>();

        Iterator<String> keysItr = object.keys();
        while(keysItr.hasNext()) {
            String key = keysItr.next();
            Object value = object.get(key);

            if(value instanceof JSONArray) {
                value = toList((JSONArray) value);
            }

            else if(value instanceof JSONObject) {
                value = toMap((JSONObject) value);
            }
            map.put(key, value);
        }
        return map;
    }


    public static List<Object> toList(JSONArray array) throws JSONException {
        List<Object> list = new ArrayList<Object>();
        for(int i = 0; i < array.length(); i++) {
            Object value = array.get(i);
            if(value instanceof JSONArray) {
                value = toList((JSONArray) value);
            }

            else if(value instanceof JSONObject) {
                value = toMap((JSONObject) value);
            }
            list.add(value);
        }
        return list;
    }
}

---

要将JSON字符串转换为hashmap，请使用以下命令：

HashMap<String, Object> hashMap = new HashMap<>(Utility.jsonToMap(

字符串转换为 JSON，与：Jacksoncom.fasterxml.jackson.databind

假设您的 json-string 表示为：jsonString = {“phonetype”：“N95”，“cat”：“WP”}

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
/**
 * Simple code exmpl
 */
ObjectMapper mapper = new ObjectMapper();
JsonNode node = mapper.readTree(jsonString);
String phoneType = node.get("phonetype").asText();
String cat = node.get("cat").asText();

使用 org.json

如果你有一个包含JSON格式文本的字符串，那么你可以通过以下步骤获取JSON对象：

String jsonString = "{\"phonetype\":\"N95\",\"cat\":\"WP\"}";
JSONObject jsonObj = null;
    try {
        jsonObj = new JSONObject(jsonString);
    } catch (JSONException e) {
        e.printStackTrace();
    }

现在访问 phonetype

Sysout.out.println(jsonObject.getString("phonetype"));

Codehaus Jackson - 自 2012 年以来，我一直在 RESTful Web 服务和 JUnit 测试中使用这个很棒的 API。使用他们的 API，您可以：

（1） 将 JSON 字符串转换为 Java Bean

public static String beanToJSONString(Object myJavaBean) throws Exception {
    ObjectMapper jacksonObjMapper = new ObjectMapper();
    return jacksonObjMapper.writeValueAsString(myJavaBean);
}

（2） 将JSON字符串转换为JSON对象（JsonNode）

public static JsonNode stringToJSONObject(String jsonString) throws Exception {
    ObjectMapper jacksonObjMapper = new ObjectMapper();
    return jacksonObjMapper.readTree(jsonString);
}

//Example:
String jsonString = "{\"phonetype\":\"N95\",\"cat\":\"WP\"}";   
JsonNode jsonNode = stringToJSONObject(jsonString);
Assert.assertEquals("Phonetype value not legit!", "N95", jsonNode.get("phonetype").getTextValue());
Assert.assertEquals("Cat value is tragic!", "WP", jsonNode.get("cat").getTextValue());

（3） 将Java bean转换为JSON字符串

    public static Object JSONStringToBean(Class myBeanClass, String JSONString) throws Exception {
    ObjectMapper jacksonObjMapper = new ObjectMapper();
    return jacksonObjMapper.readValue(JSONString, beanClass);
}

裁判：

1. Codehaus Jackson（杰克逊代码旅馆）

2. JsonNode API - 如何使用、导航、解析和评估 JsonNode 对象中的值

3. Tutorial - 如何使用Jackson将JSON字符串转换为JsonNode的简单教程

使用 org.json.simple.JSONObject 将字符串转换为 Json 对象

private static JSONObject createJSONObject(String jsonString){
    JSONObject  jsonObject=new JSONObject();
    JSONParser jsonParser=new  JSONParser();
    if ((jsonString != null) && !(jsonString.isEmpty())) {
        try {
            jsonObject=(JSONObject) jsonParser.parse(jsonString);
        } catch (org.json.simple.parser.ParseException e) {
            e.printStackTrace();
        }
    }
    return jsonObject;
}

那些由于弃用问题而无法从发布的答案中找到解决方案的人，您可以从 com.google.gson 使用。JsonParser

例：

JsonObject jsonObject = JsonParser.parseString(jsonString).getAsJsonObject();
System.out.println(jsonObject.get("phonetype"));
System.out.println(jsonObject.get("cat"));

对于使用 的人，假设更复杂的数据格式，如下所示：com.alibaba/fastjson

{
  "phonetype":"N95",
  "cat":"WP",
  "data":{
      "phone":"95",
      "kitty":"W"
  }

}

您可以按如下方式解析数据：

JSONObject jsonObject = JSON.parseObject(str);
String pt = jsonObject.getString("phonetype");
JSONObject d = jsonObject.getJSONObject("data");
String p = d.getString("phone");

如果要获取键值，代码示例如下所示：

for(Map.Entry<String,Object> entry : jsonObject.entrySet()){
    String key = entry.getKey();
    Object value = entry.getValue();
    System.out.println(key + ", " + value.toString());
}

maven 项目的 pom 依赖：

<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>fastjson</artifactId>
  <version>1.2.47</version>
</dependency>