如何防止Gson将长数字（json字符串）转换为科学记数法格式？

Question

我需要将json字符串转换为java对象，并将其显示为long。json字符串是一个固定的长数字数组：

{numbers
[ 268627104, 485677888, 506884800 ] }

要转换的代码在所有情况下都可以正常工作，但以0结尾的数字除外。它将这些转换为科学符号数字格式：

   public static Object fromJson(HttpResponse response, Class<?> classOf)
    throws IOException {
    InputStream instream = response.getResponseInputStream();                   

    Object obj = null;
    try {
        Reader reader = new InputStreamReader(instream, HTTP.UTF_8);

        Gson gson = new Gson();

        obj = gson.fromJson(reader, classOf); 

        Logger.d(TAG, "json --> "+gson.toJson(obj));
    } catch (UnsupportedEncodingException e) {
        Logger.e(TAG, "unsupported encoding", e);
    } catch (Exception e) {
        Logger.e(TAG, "json parsing error", e);
    }

    return obj;
}

实际结果：Java对象：268627104、485677888、5.068848E 8

请注意，最后一个数字已转换为科学记数法格式。有人能建议如何解决它、防止它或撤销它吗？我正在使用Gson v1.7.1

Answer 1

我有一个类似的问题，它不仅将整数转换为double，而且对于某些长的数字，它实际上会失去精度，如相关问题中所述。

我跟踪了这个转换到ObjectTypeAdapter的read方法，具体是：

case NUMBER:
  return in.nextDouble();

可能可以为Object插入修改后的TypeAdapter，但我无法让它工作，所以我只是将read方法（Object read（JsonReader in））复制到我自己的代码并将上述行修改为：

case NUMBER:
    final String s = in.nextString();
    try {
        return Integer.parseInt(s);
    } catch (NumberFormatException e) {
        // ignore
    }
    try {
        return Long.parseLong(s);
    } catch (NumberFormatException e) {
        // ignore
    }
    return Double.parseDouble(s);

我希望Gson默认这样做...

然后我把其他连接部分放在一个助手方法中，看起来像这样：

public static Object parse(final Reader r) {
    try (final JsonReader jr = new JsonReader(r)) {
        jr.setLenient(true);
        boolean empty = true;
        Object o = null;
        try {
            jr.peek();
            empty = false;
            o = read(jr);
        } catch (EOFException e) {
            if (!empty) {
                throw new JsonSyntaxException(e);
            }
        }
        if (o != null && jr.peek() != JsonToken.END_DOCUMENT) {
            throw new JsonIOException("JSON document was not fully consumed.");
        }
        return o;
    } catch (IOException e) {
        throw new JsonIOException(e);
    }
}

因此，现在不再使用新的Gson（）。从JSON（r，Object.class），我调用解析（r）。

这对我很有效，因为我希望能够解析具有任何结构的json数据，但是如果您有一个特定的目标类，您可能只需要消除该类成员中出现的Object。

Answer 2

另一个解决方法是改用JsonParser类。这将返回Gson对象表示（JsonElement），而不是用户定义的类，但避免了转换为科学符号的问题。

import java.lang.reflect.Type;
import java.util.Map;

import com.google.gson.Gson;
import com.google.gson.JsonElement;
import com.google.gson.JsonParser;
import com.google.gson.reflect.TypeToken;

public class GsonTest
{
    public static void main(String[] args)
    {
        String json = "{numbers:[268627104,485677888,506884800]}";

        Gson gson = new Gson();
        Type type = new TypeToken<Map<String, Object>>(){}.getType();
        Map<String, Object> jsonMap = gson.fromJson(json, type);
        System.out.println("Gson output:");
        System.out.println(jsonMap);

        JsonParser jsonParser = new JsonParser();
        JsonElement jsonElement = jsonParser.parse(json);
        System.out.println("JsonParser output:");
        System.out.println(jsonElement);
    }
}

代码输出：

Gson output:  
{numbers=[2.68627104E8, 4.85677888E8, 5.068848E8]}  
JsonParser output:  
{"numbers":[268627104,485677888,506884800]}

Answer 3

如果您可以选择序列化为字符串，则可以通过以下方式配置GSON：

GsonBuilder gsonBuilder = new GsonBuilder();
gsonBuilder.setLongSerializationPolicy( LongSerializationPolicy.STRING );
Gson gson = gsonBuilder.create();

这将产生如下结果：

{numbers : [ "268627104", "485677888", "506884800" ] }