Faire GSON désérialiser les chiffres pour les nombres entiers ou en double

Je vais avoir un moment difficile avec GSON.

J'ai un simple JSON que je veux désérialiser un Map<String,Object>.

C'est vraiment intuitif pour moi que 123 doit être analysée comme un int (ou long), 123.4 comme un float( ou double).

GSON d'autre part crée des Doubles de tous les temps.

Puis-je dire GSON de ne pas abuser de double de tous les temps?

Mon code:

Type mapType = new TypeToken<Map<String, Object>>() {}.getType();
GSON gson = new Gson();
Map<String, Object> map = gson.fromJson(someString, mapType);

La racine du problème est qu'il n'existe qu'un seul type de Numéro. JSON n'a pas de type int - ils sont tous à virgule flottante et en décimales sont omis lorsque cela est possible.
oui, je sais cela. Mais GSON comportement du fait de la désérialisation et la sérialisation de produire une autre sortie que de l'entrée d'origine, ce qui est vraiment méchant; par exemple, j'ai un timestamp champ qui est à l'origine 1234567890, et après deser-ser cycle est de 1.23456789E9
existe-il des solutions ?

InformationsquelleAutor Merchuk Hul | 2014-07-24

Le code suivant compile & travaux:

package test;
import java.lang.reflect.Type;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonParseException;
import com.google.gson.reflect.TypeToken;
public class Main {
public static void main(String[] args) {
GsonBuilder builder = new GsonBuilder();
builder.registerTypeAdapter(Object.class, new MyObjectDeserializer());
Gson gson = builder.create();
String array = "[1, 2.5, 4, 5.66]";
Type objectListType = new TypeToken<ArrayList<Object>>() {}.getType();
List<Object> obj = gson.fromJson(array, objectListType);
System.out.println(Arrays.toString(obj.toArray()));
}
public static class MyObjectDeserializer implements JsonDeserializer<Object> {
public Object deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) 
throws JsonParseException {
Number num = null;
try {
num = NumberFormat.getInstance().parse(json.getAsJsonPrimitive().getAsString());
} catch (Exception e) {
//ignore
}
if (num == null) {
return context.deserialize(json, typeOfT);
} else {
return num;
}
}
}
}

Ma solution va d'abord essayer d'analyser la chaîne comme un nombre, si cela échoue, il permettra à la norme Gson deserializer faire le travail.

Si vous avez besoin d'un analyseur de numéro qui n'est pas spécifique aux paramètres régionaux utiliser cette méthode pour analyser un nombre:

private static Number parse(String str) {
Number number = null;
try {
number = Float.parseFloat(str);
} catch(NumberFormatException e) {
try {
number = Double.parseDouble(str);
} catch(NumberFormatException e1) {
try {
number = Integer.parseInt(str);
} catch(NumberFormatException e2) {
try {
number = Long.parseLong(str);
} catch(NumberFormatException e3) {
throw e3;
}       
}       
}       
}
return number;
}

Merci. en fait je vais désérialiser une carte complète de la plupart des objets et des classes; GSON ne ce fichier, je ne n'aime pas la façon dont il traite les numéros..
J'ai mis à jour ma réponse en fonction de vos commentaires, si je vous comprends bien, alors je pense que ça devrait fonctionner
l'air prometteur, MAIS elle est locale dépendante (séparateurs), et ne doit pas être 🙁
Que voulez-vous dire paramètres régionaux dépendant? Je ne comprends pas. Là je l'ai corrigé en utilisant le contexte.. cela devrait fonctionner.
Je veux dire que Numberformat.getInstance() retourne une instance pour le courant de paramètres régionaux par défaut.
J'ai essayé votre code car il a l'air mieux, mais ça ne fonctionne pas. J'ai placé un point d'arrêt à l'intérieur de deserialize et il n'a pas y aller encore une fois.
je ne sais pas quoi te dire, le code est correct: stackoverflow.com/questions/16590377/...
vous pouvez me dire si cela a fonctionné quand u compilé 🙂

InformationsquelleAutor g00dnatur3

1

Ce n'est pas une bonne approche de mélanger des types comme ça (entiers avec des doubles). Puisque vous êtes à l'aide de l'Objet comme un type, vous ne serez pas en mesure d'obtenir les nombres Entiers et Double à partir de la carte. Gson décide quel type est le plus adéquat pour l'Objet. Dans votre cas, il est Double, parce que toutes les valeurs PEUVENT ÊTRE doubles, mais toutes les valeurs ne PEUVENT PAS ÊTRE convertis en nombres entiers.

Si vous avez vraiment besoin de mélanger les types, essayez d'utiliser le Numéro de la classe à la place de l'Objet. Exemple:
```
public static void main(String[] args){
String array = "[1, 2.5, 4, 5.66]";
Gson gson = new Gson();
Type type = new TypeToken<ArrayList<Number>>() {}.getType();
List<Number> obj = gson.fromJson(array, type);
System.out.println(Arrays.toString(obj.toArray()));
}
```
De sortie: [1, 2.5, 4, 5.66]

Tout cela:
```
public static void main(String[] args){
String array = "[1, 2.5, 4, 5.66]";
Gson gson = new Gson();
Type type = new TypeToken<ArrayList<Object>>() {}.getType();
List<Object> obj = gson.fromJson(array, type);
System.out.println(Arrays.toString(obj.toArray()));
}
```
vous donnera de sortie: [1.0, 2.5, 4.0, 5.66]
- Je vous remercie. Mais j'ai besoin d'un Object, puisque d'autres non-champs numériques peuvent être présents, comme dans toute JSON. Je veux seulement changer la manipulation de nombres..
InformationsquelleAutor mayr

Vous pouvez effectuer les modifications suivantes dans le but d'analyser les données:

   testData1={"GOAL1":123, "GOAL2":123.45,"GOAL5":1256,"GOAL6":345.98}

et ci-dessous votre code est effectivement de les analyser.

Type mapType = new TypeToken<Map<String, Object>>() {
}.getType();
String str = prop.getProperty("testData1");
System.out.println(str);
Gson gson = new Gson();
Map<String, Object> map = gson.fromJson(str, mapType);
for (String key : map.keySet()) {
String a = null;
try {
if (map.get(key) instanceof Double) {
a = "" + map.get(key);
} else {
if (map.get(key) instanceof String) {
a = (String) map.get(key);
} else {
a = null;
}
}
if (a != null && a.contains(".") && !a.endsWith(".0")) {
//Convert it into Double/Float
} else {
//Work as Integer
}
} catch (Exception ex) {
ex.printStackTrace();
}
}

InformationsquelleAutor Praveen Kumar

Si vous n'êtes pas lié spécifiquement à l'utilisation gson bibliothèque, vous pouvez résoudre ce problème à l'aide de la désérialisation jackson l'un comme suit:

new ObjectMapper().readValue(yourJson, new TypeReference<Map<String,Object>>() {});

Ici un complet de test junit qui exposent les différences entre les deux bibliothèques de la désérialisation d'une valeur entière:

@Test
public void integerDeserializationTest() throws Exception {
final String jsonSource = "{\"intValue\":1,\"doubleValue\":2.0,\"stringValue\":\"value\"}";
//Using gson library "intValue" is deserialized to 1.0
final String gsonWrongResult = "{\"intValue\":1.0,\"doubleValue\":2.0,\"stringValue\":\"value\"}";
Map<String,Object> gsonMap = new Gson().fromJson(jsonSource, new TypeToken<Map<String, Object>>() {
}.getType());
assertThat(new Gson().toJson(gsonMap),is(gsonWrongResult));
//Using jackson library "intValue" is deserialized to 1
Map<String,Object> jacksonMap = new ObjectMapper().readValue(jsonSource, new TypeReference<Map<String,Object>>() {});
assertThat(new ObjectMapper().writeValueAsString(jacksonMap),is(jsonSource));
}

InformationsquelleAutor gcallea

Vous devez vous connecter pour publier un commentaire.