31

我需要将 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

4

8 回答 8

18

如果您可以选择序列化为字符串，则可以配置 GSON 以执行此操作：

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

这将产生类似的东西：

{numbers : [ "268627104", "485677888", "506884800" ] }
于 2014-05-05T23:44:10.037 回答
10

另一种解决方法是改用 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]}
于 2013-01-16T23:10:43.943 回答
8

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

我追踪了这种转换为ObjectTypeAdapter'sread方法，特别是：

case NUMBER:
  return in.nextDouble();

可能可以插入修改后TypeAdapter的 for Object，但我无法让它工作，所以我只是将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);
    }
}

所以现在代替new Gson().fromJson(r, Object.class)，我打电话给parse(r)。

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

于 2017-04-11T12:36:17.703 回答
5

遇到了同样的问题，经过一番调查，我发现了这里。

行为：

  • Gson
    对于没有小数部分的数字，Gson将其转换为Double,
  • Jackson
    对于没有小数部分的数字，Jackson将其转换为Integer或Long，取决于数字的大小。

可能的解决方案：

  • 明确地将Gson的返回值从转换Double为。Long
  • 改为使用Jackson。
    我更喜欢这个。

代码 - 测试Jackson

ParseNumberTest.java：

import java.util.List;

import org.testng.Assert;
import org.testng.annotations.Test;

import com.fasterxml.jackson.databind.ObjectMapper;

/**
 * test - jackson parse numbers,
 * 
 * @author eric
 * @date Jan 13, 2018 12:28:36 AM
 */
public class ParseNumberTest {
    @Test
    public void test() throws Exception {
    String jsonFn = "numbers.json";

    ObjectMapper mapper = new ObjectMapper();

    DummyData dd = mapper.readValue(this.getClass().getResourceAsStream(jsonFn), DummyData.class);
    for (Object data : dd.dataList) {
        System.out.printf("data type: %s, value: %s\n", data.getClass().getName(), data.toString());
        Assert.assertTrue(data.getClass() == Double.class || data.getClass() == Long.class || data.getClass() == Integer.class);

        System.out.printf("%s\n\n", "------------");
    }
    }

    static class DummyData {
    List<Object> dataList;

    public List<Object> getDataList() {
        return dataList;
    }

    public void setDataList(List<Object> dataList) {
        this.dataList = dataList;
    }
    }
}

数字.json：

{
    "dataList": [
        150000000000,
        150778742934,
        150000,
        150000.0
    ]
}

如何运行：

  • 测试用例基于Jackson& TestNG。
  • 放在numbers.json与 相同的包装中ParseNumberTest.java。
  • 作为 testng 测试运行，然后它将打印解析结果的类型和值。

输出：

data type: java.lang.Long, value: 150000000000
------------

data type: java.lang.Long, value: 150778742934
------------

data type: java.lang.Integer, value: 150000
------------

data type: java.lang.Double, value: 150000.0
------------

PASSED: test
于 2018-01-12T17:12:10.643 回答
0

不聪明，但仍然有效的方法是在数字的开头和结尾添加“。然后处理完成后，将其删除。

于 2017-11-29T09:29:11.867 回答
0

我们可以将以下代码解决方案用于数字 Long：

Document doc = documentCursor.next();  

JsonWriterSettings relaxed = JsonWriterSettings.builder().outputMode(JsonMode.RELAXED).build();  

CustomeObject obj = gson.fromJson(doc.toJson(relaxed), CustomeObject.class);
于 2019-08-21T02:46:11.450 回答
0

如果您需要它们作为字符串，最好的解决方案是在进行转换之前强制用单引号引用属性。

做这样的改变：

String readerAsString = convertReaderToString(reader);
readerAsString = readerAsString.toString().replace("=", "='");
readerAsString = readerAsString.toString().replace(",", "',");
readerAsString = readerAsString.toString().replace("}]", "'}]");
于 2021-04-27T11:09:20.637 回答
-1

我没有找到解决以 0 结尾的 gson 格式化数字到科学记数法的问题。相反，我使用一种变通方法将此科学记数法转换为我用逗号格式化的双精度记数法。“值”是 json 字符串。

  private String formatNumber(String value) { 
    double dValue = Double.parseDouble(value);
    String pattern = "#,###";
    DecimalFormat formatter = new DecimalFormat(pattern);
    String newNumber = formatter.format(dValue);

            return newNumber;
}

这并不能回答所提出的问题，而是解决问题以显示系统要求的数字的附加步骤。

于 2012-07-24T01:49:14.137 回答