Comment convertir jsonString en JSONObject en Java
J'ai une variable de chaîne appelée jsonString:
{"phonetype":"N95","cat":"WP"}
Maintenant, je veux le convertir en objet JSON. J'ai cherché plus sur Google mais je n'ai pas eu les réponses attendues ...
Utiliser la bibliothèque org.json :
try {
JSONObject jsonObject = new JSONObject("{\"phonetype\":\"N95\",\"cat\":\"WP\"}");
}catch (JSONException err){
Log.d("Error", err.toString());
}
Pour ceux qui cherchent encore une réponse:
JSONParser parser = new JSONParser();
JSONObject json = (JSONObject) parser.parse(stringToParse);
Vous pouvez utiliser google-gson. Détails:
Exemples d'objets
class BagOfPrimitives {
private int value1 = 1;
private String value2 = "abc";
private transient int value3 = 3;
BagOfPrimitives() {
// no-args constructor
}
}
(Sérialisation)
BagOfPrimitives obj = new BagOfPrimitives();
Gson gson = new Gson();
String json = gson.toJson(obj);
==> json is {"value1":1,"value2":"abc"}
Notez que vous ne pouvez pas sérialiser des objets avec des références circulaires car cela entraînerait une récursion infinie.
(Désérialisation)
BagOfPrimitives obj2 = gson.fromJson(json, BagOfPrimitives.class);
==> obj2 is just like obj
Un autre exemple pour Gson:
Gson est facile à apprendre et à mettre en œuvre. Vous devez connaître les deux méthodes suivantes:
-> toJson () - convertit un objet Java au format JSON
-> fromJson () - convertit JSON en objet 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);
}
}
Sortie
{"data1":100,"data2":"hello"}
Ressources:
Il existe différents Java sérialiseurs et désérialiseurs JSON liés à partir de la page d'accueil JSON .
Au moment d'écrire ces lignes, il y a ces 22:
... mais bien sûr la liste peut changer.
solution Java 7
import javax.json.*;
...
String TEXT;
JsonObject body = Json.createReader(new StringReader(TEXT)).readObject()
;
J'aime utiliser google-gson pour cela, et c'est précisément parce que je n'ai pas besoin de travailler directement avec JSONObject.
Dans ce cas, j'aurais une classe qui correspondra aux propriétés de votre objet 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);
...
Cependant, je pense que votre question ressemble davantage à: Comment puis-je me retrouver avec un objet JSONObject réel à partir d'une chaîne JSON?.
J'étais en train de regarder l'API google-json et je n'ai rien trouvé d'aussi simple que celui de org.json, ce qui est probablement ce que vous voulez utiliser si vous avez un si grand besoin d'utiliser un JSONObject barebones.
http://www.json.org/javadoc/org/json/JSONObject.html
Avec org.json.JSONObject (une autre API complètement différente) Si vous voulez faire quelque chose comme ...
JSONObject jsonObject = new JSONObject("{\"phonetype\":\"N95\",\"cat\":\"WP\"}");
System.out.println(jsonObject.getString("phonetype"));
Je pense que la beauté de google-gson est que vous n'avez pas besoin de traiter avec JSONObject. Vous devez simplement saisir Json, laisser passer la classe dans laquelle vous souhaitez effectuer la désérialisation, et vos attributs de classe seront identiques à ceux du JSON, mais là encore, chacun a ses propres exigences. côté désérialisation car les choses pourraient être trop dynamiques du côté de la génération JSON. Dans ce cas, utilisez simplement json.org.
Pour convertir String en JSONObject, il vous suffit de passer l'instance String dans le constructeur de JSONObject.
Par exemple:
JSONObject jsonObj = new JSONObject("your string");
vous devez importer org.json
JSONObject jsonObj = null;
try {
jsonObj = new JSONObject("{\"phonetype\":\"N95\",\"cat\":\"WP\"}");
} catch (JSONException e) {
e.printStackTrace();
}
Chaîne vers JSON en utilisant Jackson avec com.fasterxml.jackson.databind:
En supposant que votre chaîne json représente ce qui suit: 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();
Utilisez JsonNode of FastXml pour l'analyse générique JSON. Il crée en interne une carte de valeur clé pour toutes les entrées.
Exemple:
private void test(@RequestBody JsonNode node)
chaîne d'entrée:
{"a":"b","c":"d"}
Si vous utilisez http://json-lib.sourceforge.net (net.sf.json.JSONObject)
c'est assez facile:
String myJsonString;
JSONObject json = JSONObject.fromObject(myJsonString);
ou
JSONObject json = JSONSerializer.toJSON(myJsonString);
récupérez les valeurs avec json.getString (param), json.getInt (param), etc.
Pas besoin d'utiliser une bibliothèque externe.
Vous pouvez utiliser cette classe à la place:) (gère même les listes, les listes imbriquées et 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;
}
}
Pour convertir votre chaîne JSON en hashmap utilisez ceci:
HashMap<String, Object> hashMap = new HashMap<>(Utility.jsonToMap(
Convertir une chaîne en json et le sting est comme json. {"type de téléphone": "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);
Utilisation de org.json
Si vous avez une chaîne contenant du texte au format JSON, vous pouvez obtenir un objet JSON en procédant comme suit:
String jsonString = "{\"phonetype\":\"N95\",\"cat\":\"WP\"}";
JSONObject jsonObj = null;
try {
jsonObj = new JSONObject(jsonString);
} catch (JSONException e) {
e.printStackTrace();
}
Maintenant pour accéder au type de téléphone
Sysout.out.println(jsonObject.getString("phonetype"));
NOTEZ que GSON avec la désérialisation d'une interface donnera lieu à une exception comme ci-dessous.
"Java.lang.RuntimeException: Unable to invoke no-args constructor for interface XXX. Register an InstanceCreator with Gson for this type may fix this problem."
En désérialisant; GSON ne sait pas quel objet doit être initié pour cette interface.
Ceci est résolu d'une manière ou d'une autre ici .
Cependant FlexJSON a cette solution de manière inhérente. pendant la sérialisation, il ajoute le nom de la classe dans json, comme ci-dessous.
{
"HTTPStatus": "OK",
"class": "com.XXX.YYY.HTTPViewResponse",
"code": null,
"outputContext": {
"class": "com.XXX.YYY.ZZZ.OutputSuccessContext",
"eligible": true
}
}
Donc, JSON en encombrera un peu; mais vous n'avez pas besoin d'écrire InstanceCreator ce qui est requis dans GSON.
Pour définir json objet unique à lister c'est-à-dire
"locations":{
}
dans List<Location>
utilisation
ObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
jackson.mapper-asl-1.9.7.jar