>我需要将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
如果序列化为字符串是一个选项，则可以将 GSON 配置为执行以下操作：
GsonBuilder gsonBuilder = new GsonBuilder();
gsonBuilder.setLongSerializationPolicy( LongSerializationPolicy.STRING );
Gson gson = gsonBuilder.create();
这将产生类似以下内容的内容：
{numbers : [ "268627104", "485677888", "506884800" ] }
另一种解决方法是改用 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]}
我有一个类似的问题，它不仅将整数转换为双精度，而且实际上会失去某些长数字的精度，如本相关问题中所述。
我追踪到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);
}
}
所以现在不是new Gson().fromJson(r, Object.class)，而是我打电话给parse(r).
这对我来说效果很好，因为我希望能够解析具有任何结构的 json 数据，但是如果您有一个特定的目标类，您可能只需要消除该类成员中出现的Object。
遇到同样的问题，经过一些调查，这是我发现的。
行为：
- 格森
对于没有小数部分的数字，Gson将其转换为Double， - 杰克逊
对于没有小数部分的数字，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: %sn", data.getClass().getName(), data.toString());
Assert.assertTrue(data.getClass() == Double.class || data.getClass() == Long.class || data.getClass() == Integer.class);
System.out.printf("%snn", "------------");
}
}
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
我们可以对数字 Long 使用以下代码解决方案：
Document doc = documentCursor.next();
JsonWriterSettings relaxed = JsonWriterSettings.builder().outputMode(JsonMode.RELAXED).build();
CustomeObject obj = gson.fromJson(doc.toJson(relaxed), CustomeObject.class);
不聪明，但仍然有效的方法是在数字的开头和结尾添加 "。然后在处理完成后，将其删除。
如果您需要它们作为字符串，最好的解决方案是在进行转换之前强制使用单引号引用属性。
执行如下更改：
String readerAsString = convertReaderToString(reader);
readerAsString = readerAsString.toString().replace("=", "='");
readerAsString = readerAsString.toString().replace(",", "',");
readerAsString = readerAsString.toString().replace("}]", "'}]");
data class Answer(
val question: String,
val value: Any
)
鉴于上面的value:Any属性，我发现 Gson 遇到 JSON 值 1(不是 "1"(并且无法推断出显而易见的事实是可疑的：1是一个Int。 相反，Gson 将整数值转换为双精度1.0。
如果上面的 value 属性类型为 Float 或 Double，则 Gson 应仅将 JSON 值从 1 转换为 1.0 。当 Gson 遇到类型为 Any 的属性时，它应该(非常简单地(从它收到的 JSON 值推断出类型。不幸的是，它没有，它更喜欢通过将传入的整数值强制转换为 Double 来实际损坏它们，这不出所料会立即导致异常。
对于 Gson 解析器的这种特性，我找不到合理的解决方案。因此，我被迫在使用 Gson 后手动将所有这些双精度值转换回 int 值，或者为 Gson 实现我自己的通用自定义类型适配器。这两种选择都没有吸引力。
我没有找到解决 gson 将以 0 结尾的数字格式化为科学记数法的问题的解决方案。相反，我使用了一个解决方法将这个科学记数法转换为我用逗号格式化的双精度。"value"是 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;
}
这不会回答所提出的问题，但是是解决问题的附加步骤，以按照系统要求显示数字。