如何防止 Gson 将整数表示为浮点数

You're telling Gson it's looking for a list of maps of Strings to Objects, which essentially says for it to make a best guess as to the type of the Object. Since JSON doesn't distinguish between integer and floating point fields Gson has to default to Float/Double for numeric fields.

Gson is fundamentally built to inspect the type of the object you want to populate in order to determine how to parse the data. If you don't give it any hint, it's not going to work very well. One option is to define a custom JsonDeserializer, however better would be to not use a HashMap (and definitely don't use Hashtable!) and instead give Gson more information about the type of data it's expecting.

class Response {
int id;
int field_id;
ArrayList<ArrayList<Integer>> body; // or whatever type is most apropriate
}


responses = new Gson()
.fromJson(draft, new TypeToken<ArrayList<Response>>(){}.getType());

Again, the whole point of Gson is to seamlessly convert structured data into structured objects. If you ask it to create a nearly undefined structure like a list of maps of objects, you're defeating the whole point of Gson, and might as well use some more simplistic JSON parser.

I'm late to the party, but I just ran into this myself. In my case, I didn't want to specify an Integer type in my ArrayList - since it could be a String or an Integer.

My solution is as follows:

GsonBuilder gsonBuilder = new GsonBuilder();
gsonBuilder.registerTypeAdapter(Double.class,  new JsonSerializer<Double>() {


public JsonElement serialize(Double src, Type typeOfSrc,
JsonSerializationContext context) {
Integer value = (int)Math.round(src);
return new JsonPrimitive(value);
}
});


Gson gs = gsonBuilder.create();

Rather than using the default Gson definition with Gson gs = new Gson();, I have overridden the Double.class serialization to return an integer.

In my case, I have Strings and Integers within my JSON, but I do not have any doubles, so this doesn't pose a problem.

If you need a double or a float value, I suppose it would be possible to add some logic that tested the value for attributes specific to each datatype and returned an appropriate value. Something like

if(/*source has a decimal point*/){
return new JsonPrimitive(src);
} else if (/* source has some attribute of a Float */){
Float value = /*convert the src value from double to a Float */;
return new JsonPrimitive(value);
} else {
//it looks like an integer
Integer value = (int)Math.round(src);
return new JsonPrimitive(value);
}

I don't know how to test for or convert those datatypes off the top of my head, but this should put you on the right path.

This works:

 Gson gson = new GsonBuilder().
registerTypeAdapter(Double.class,  new JsonSerializer<Double>() {


@Override
public JsonElement serialize(Double src, Type typeOfSrc, JsonSerializationContext context) {
if(src == src.longValue())
return new JsonPrimitive(src.longValue());
return new JsonPrimitive(src);
}
}).create();

Basically, there is no perfect answer for this issue. All "solutions" work for some cases only. This is an issue reported to gson team, unfortunately seems they insist that "javascript has no integer type" as if they do not realize that gson is for java not javascript. So they refused to fix it until today (2018 now), despite other lib like jackson does not have such issue at all, despite how easy to fix it. So you may have to fix the issue yourself from gson source code and build your own gson.jar. The source file is gson/src/main/java/com/google/gson/internal/bind/ObjectTypeAdapter.java

case NUMBER:
return in.nextDouble();

This work for me.

Step 1: Copy the ObjectTypeAdapter in gson into the project, keeping the path the same as in gson Like this

com
- xxx
- xxx
com
- google
- gson
- internal
- bind
ObjectTypeAdapter

Step 2: Modify ObjectTypeAdapter

case NUMBER:
return in.nextDouble();

Modified to

case NUMBER:
String number = in.nextString();
try {
return Long.valueOf(number);
} catch (NumberFormatException e) {
return Double.valueOf(number);
}

Gson will prioritizes the ObjectTypeAdapter in the project.

    fun jsonToMap(json: JSONObject): Map<String, Any> {
val doubles = Gson().fromJson<Map<String, Any>>(json.toString(), Map::class.java)
fun doublesToLong(doubles: Map<String, Any>): Map<String, Any> = doubles
.map { entry ->
Pair(entry.key, entry.value.let {
when (it) {
is Map<*, *> -> doublesToLong(it as Map<String, Any>)
is Double -> it.toLong()
else -> it
}
})
}
.toMap()
return doublesToLong(doubles)
}

Custom serializer solution in Kotlin, it's a bit tricky because you have to distinguish between java.lang.Double and Double (kotlin.Double).

private val Gson: Gson = GsonBuilder().registerTypeAdapter(java.lang.Double::class.java, object : JsonSerializer<Double> {
override fun serialize(src: Double, typeOfSrc: Type, context: JsonSerializationContext): JsonElement {
return if (src == src.toLong().toDouble()) JsonPrimitive(src.toLong()) else JsonPrimitive(src)
}
}).create()

There is a solution provided by the library from 2.8.9 version.

We can set how Object is converted to a number using, setObjectToNumberStrategy

Implementation of LONG_OR_DOUBLE will work in this case. Can be used as

GsonBuilder()
.setObjectToNumberStrategy(ToNumberPolicy.LONG_OR_DOUBLE)
.create()

Refer to below link for details

https://github.com/google/gson/pull/1290

Use Jackson

    public static Map<String, Object> jsonToMap(final String jsonString) {
try {
final ObjectMapper objectMapper = new ObjectMapper();
return objectMapper.convertValue(objectMapper.readTree(jsonString), new TypeReference<Map<String, Object>>() {
});
} catch (final Exception e) {
throw new InternalServiceException("lol");
}
}

google fixed issue https://github.com/google/gson/commit/fe30b85224316cabf19f5dd3223843437c297802#diff-9bf510cca1fa5b32b008e7daa417abf15602571dbc87f5436d9f3558ded492a5 please update gson version to 2.8.9