关于javajsonn的信息
本篇文章给大家谈谈javajsonn，以及对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
- 1、如何java解析json数组
- 2、用Java语言：从下列Json数组中只展示“productTypeName=公路零担”的数据集？
- 3、Java的json反序列化：Java数据类可以和json数据结构不一致吗？
- 4、java校验json格式及内容
如何java解析json数组
工具/原料
安装有eclipse软件的电脑一台
方法/步骤
1
首先我们在eclipse中创建一个java工程，在java工程中创建一个HelloWorld的类，在这个java的入口程序中，我们来创建一个json字符串，并且打印出来，如下图：
2
将我们刚刚创建的json字符串打印出来如下所示，可以看出这个json包含了一个大json对象，大json对象里面又包含一个json数组，一个数组里面又包含三个json对象，如下图：
3
在java中我们要解析json数组必须借助第三方包，所以这里我们加载一下第三方包，首先我们将鼠标移动到项目名称上面去，然后右键召唤出右键快捷菜单，然后依次点击Build Path-Configure Build Paht...，如下图：
4
然后我们按照图中红色方框所示点击Libraries,然后点击Add Library...，如下图所示：
5
然后我们继续按照图中所示点击User Library，然后点击Next，如下图：
6
然后我们继续按照图中红色方框所示点击User Libraries...，如下图：
7
然后我们点击New...，来开始创建我们自己的libraries，如下图：
8
然后我们输入我们自己jar库的名字，这里我使用了jsonjar作为我们的名字，如下图：
9
接下来为我们的jar库添加jar包，我们按照下图中红色方框所示点击“Add External JARs”,如下图：
10
我们添加json相关的jar包，这里涉及json的第三方包主要包括这七个，所以我们把这七个包都引入到我们自己的jar库中去，如下图：
11
返回到User Libraries中发现，我们已经引入了所有的jar包，如下图：
我们按照下图中红色方框所示画勾，然后点击finish，如下图：
然后我们按照图中红色边框所示点击Apply，然后点击OK，如下图：
回到我们的工程中，从工程目录中我们可以看到，我们已经添加了自己的名字为jsonjar的jar库，如下图：
接下来我们回到程序中，在头部添加“import net.sf.json.JSONArray;import net.sf.json.JSONObject;”这两句代码，这两句表示引入了解析json的对象和数组的包，如下图：
然后我们通过代码“JSONObject.fromObject(json_array)”来将我们之前创建的json字符串转换成json对象，并且通过键值对的方式打印出json对象名字为“employees”的值，如下图：
打印出的名字为“employees”的json对象的值如下图是一个数组字符串，如下图：
接下来我们通过代码“jsonobj.getJSONArray("employees")”来将获取的数组字符串转变成为json组数，如下图：
并且我们打印出json数组的长度，可见程序计算的json数组的长度和我们实际的数组长度相一致，如下图：
接下来我们通过一个for循环将我们获取的json数组中的值依次取出来，由于数组中又包含3个对象，我们又需要将3个对象使用代码“JSONObject.fromObject(jsonarr.get(i));”将得到的对象字符串变成对象然后再取出来，如下图：
最后，我们将json数组的所有内容都展示到控制台，这样我们就可以使用java通过第三方json包来解析json数组了，如下图：
用Java语言：从下列Json数组中只展示“productTypeName=公路零担”的数据集？
java处理json，最经典的做法还是将String字符串转换成对象来处理。
需要借助第三方jar包，常见的第三方json处理jar包有：阿里巴巴的fastjson，谷歌的gson还有诸如jackson之类的。
我习惯用gson：
1、引入gson依赖或去网上下载其jar包：
dependency
groupIdcom.google.code.gson/groupId
artifactIdgson/artifactId
version2.3.1/version
/dependency
2、根据json串，定义对象：
首先定义json最外层，我称其为Response，Response中有根节点data：
这里我用了lombok的@Data注解，自动生成getter、setter、toString等方法。
然后定义了根节点对象Data1，里面有Record集合records：
之后就是定义Record的各个字段：
现在我就有了完整的数据结构，使用gson进行转换即可：
接下来拿着response对象进行正常的java逻辑处理就行：
完整代码：
public class TController {
public static void main(String[] args) {
String jsonString = "{\n" +
"\"data\":{\n" +
"\"records\":[\n" +
"{\n" +
"\"couponName\":\"\",\n" +
"\"payTime\":\"2021-11-15 11:11:33\",\n" +
"\"providerEndAddress\":\"\",\n" +
"\"paidMoney\":268,\n" +
"\"weihuUserId\":\"0\",\n" +
"\"productTypeName\":\"公路零担\"\n" +
"},\n" +
"{\n" +
"\"couponName\":\"\",\n" +
"\"payTime\":\"2021-11-15 11:11:33\",\n" +
"\"providerEndAddress\":\"\",\n" +
"\"paidMoney\":268,\n" +
"\"weihuUserId\":\"0\",\n" +
"\"productTypeName\":\"航空运输\"\n" +
"}\n" +
"]\n" +
"}\n" +
"}";
Gson gson = new Gson();
Response response = gson.fromJson(jsonString, Response.class);
Data1 data = response.getData();//取出data
ListRecord records = data.getRecords();//取出records
for (int i = 0; i records.size(); i++) {
//循环判断records中的数据，ProductTypeName不为“公路零担”则移除
if (!"公路零担".equals(records.get(i).getProductTypeName())) {
records.remove(i);
i--;
}
}
data.setRecords(records);//覆盖原有的records
response.setData(data);//覆盖原有的data
System.out.println(gson.toJson(response, Response.class));//转成json字符串输出
}
@Data
private class Response {
private Data1 data;
}
@Data
private class Data1 {
private ListRecord records;
}
@Data
private class Record {
private String couponName;
private String payTime;
private String providerEndAddress;
private String paidMoney;
private String weihuUserId;
private String productTypeName;
}
}
运行结果：
Java的json反序列化：Java数据类可以和json数据结构不一致吗？
由于时间关系我也没有写全，这里提供一个思路吧。代码如下：
Account.java：
@Data
public class Account {
private int id;
private String name;
// @PowerfulAnnotation注解是我臆想的
@PowerfulAnnotation("token.id")
private String tokenId;
@PowerfulAnnotation("token.key")
private String key;
}
PowerfulAnnotation.java：
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface PowerfulAnnotation {
String value() default "";
}
测试类Main.java:
public class Main {
public static void main(String[] args) throws Exception {
Account account = new Account();
String ori = "{\n" +
"\"id\": 11111,\n" +
"\"name\": \"小李\",\n" +
"\"token\": {\n" +
"\"id\": 22222222,\n" +
"\"key\": \"ddddddddd\"\n" +
"}\n" +
"}";
Gson gson = new Gson();
//字符串json转JsonObject
JsonObject jsonObject = gson.fromJson(ori, JsonObject.class);
//反射获取目标对象属性
for (Field field : account.getClass().getDeclaredFields()) {
String fieldName = field.getName();
Class fieldClass = field.getType();
System.out.print("当前field名：[" + fieldName + "]，");
System.out.println("当前field类型：[" + fieldClass + "]");
Annotation annotation = field.getDeclaredAnnotation(PowerfulAnnotation.class);
//检查是否有PowerfulAnnotation注解
if (annotation != null) {
PowerfulAnnotation powerful = (PowerfulAnnotation) annotation;
String powerfulValue = powerful.value();
System.out.println("发现PowerfulAnnotation注解，值为：[" + powerfulValue + "]");
String[] tmp = powerfulValue.split("\\.");
//声明一个临时JsonObject，将用于获取下一层json对象
JsonObject tmpJson = jsonObject;
for (int i = 0; i tmp.length; i++) {
//目标值是在powerfulValue的最后一个字段，例如powerfulValue为token.id的话，目标的值就是id，所以先获取token这个jsonObject，并赋值给临时tmpJson
if (i != tmp.length - 1) {
tmpJson = jsonObject.get(tmp[i]).getAsJsonObject();
} else {
//到达powerfulValue的最后一个字段，检查其类型，并赋值给目标对象
Object value = checkFieldType(tmpJson, tmp[i], fieldClass);
//从目标对象中获取目标属性
Field targetField = account.getClass().getDeclaredField(field.getName());
targetField.setAccessible(true);//解除私有限制
System.out.println("将[" + powerfulValue + "]的值[" + value + "]赋给目标对象的[" + fieldName + "]");
//将值赋值给目标属性
targetField.set(account, value);
}
}
}
//属性上没有PowerfulAnnotation注解
else {
//检查当前属性的类型
Object value = checkFieldType(jsonObject, fieldName, fieldClass);
//从目标对象中获取目标属性
Field targetField = account.getClass().getDeclaredField(field.getName());
targetField.setAccessible(true);//解除私有限制
System.out.println("直接将值[" + value + "]赋给目标对象的[" + fieldName + "]");
//将值赋值给目标属性
targetField.set(account, value);
}
System.out.println("*********************************************\n");
}
System.out.println("目标对象最终值：" + account);
}
/**
* 检查当前属性的类型
* （这里由于时间关系，我没有写全，只检查了String、int、boolean类型，全类型应包括boolean、char、byte、short、int、long、float、double，你有时间自己补充一下）
*
* 如果发现当前属性是一个对象，那么应该将JsonObject转换成对应的对象再返回（由于时间关系，这里我也没有试过，总之思路是这样）
*/
private static Object checkFieldType(JsonObject field, String fieldName, Class fieldClass) {
if (fieldClass == String.class) {
return field.get(fieldName).getAsString();
}
if (fieldClass == int.class) {
return field.get(fieldName).getAsInt();
}
if (fieldClass == boolean.class) {
return field.get(fieldName).getAsBoolean();
}
return new Gson().fromJson(field.get(fieldName), fieldClass);
}
}
代码还没写完，主要集中在没有对JsonArray进行处理，当json串里包含数组时会报错，另外一些没写完的我在注释里写了点，你可以参照一下。整体思路还是利用java反射机制进行。
以上代码运行结果：
java校验json格式及内容
代码如下
import java.text.CharacterIterator;
import java.text.StringCharacterIterator;
public class JsonValidator {
private CharacterIterator it;
private char c;
private int col;
public JsonValidator(){
}
/**
* 验证一个字符串是否是合法的JSON串
*
* @param input 要验证的字符串
* @return true-合法 ，false-非法
*/
public boolean validate(String input) {
input = input.trim();
boolean ret = valid(input);
return ret;
}
private boolean valid(String input) {
if ("".equals(input)) return true;
boolean ret = true;
it = new StringCharacterIterator(input);
c = it.first();
col = 1;
if (!value()) {
ret = error("value", 1);
} else {
skipWhiteSpace();
if (c != CharacterIterator.DONE) {
ret = error("end", col);
}
}
return ret;
}
private boolean value() {
return literal("true") || literal("false") || literal("null") || string() || number() || object() || array();
}
private boolean literal(String text) {
CharacterIterator ci = new StringCharacterIterator(text);
char t = ci.first();
if (c != t) return false;
int start = col;
boolean ret = true;
for (t = ci.next(); t != CharacterIterator.DONE; t = ci.next()) {
if (t != nextCharacter()) {
ret = false;
break;
}
}
nextCharacter();
if (!ret) error("literal " + text, start);
return ret;
}
private boolean array() {
return aggregate('[', ']', false);
}
private boolean object() {
return aggregate('{', '}', true);
}
private boolean aggregate(char entryCharacter, char exitCharacter, boolean prefix) {
if (c != entryCharacter) return false;
nextCharacter();
skipWhiteSpace();
if (c == exitCharacter) {
nextCharacter();
return true;
}
for (;;) {
if (prefix) {
int start = col;
if (!string()) return error("string", start);
skipWhiteSpace();
if (c != ':') return error("colon", col);
nextCharacter();
skipWhiteSpace();
}
if (value()) {
skipWhiteSpace();
if (c == ',') {
nextCharacter();
} else if (c == exitCharacter) {
break;
} else {
return error("comma or " + exitCharacter, col);
}
} else {
return error("value", col);
}
skipWhiteSpace();
}
nextCharacter();
return true;
}
private boolean number() {
if (!Character.isDigit(c) c != '-') return false;
int start = col;
if (c == '-') nextCharacter();
if (c == '0') {
nextCharacter();
} else if (Character.isDigit(c)) {
while (Character.isDigit(c))
nextCharacter();
} else {
return error("number", start);
}
if (c == '.') {
nextCharacter();
if (Character.isDigit(c)) {
while (Character.isDigit(c))
nextCharacter();
} else {
return error("number", start);
}
}
if (c == 'e' || c == 'E') {
nextCharacter();
if (c == '+' || c == '-') {
nextCharacter();
}
if (Character.isDigit(c)) {
while (Character.isDigit(c))
nextCharacter();
} else {
return error("number", start);
}
}
return true;
}
private boolean string() {
if (c != '"') return false;
int start = col;
boolean escaped = false;
for (nextCharacter(); c != CharacterIterator.DONE; nextCharacter()) {
if (!escaped c == '\\') {
escaped = true;
} else if (escaped) {
if (!escape()) {
return false;
}
escaped = false;
} else if (c == '"') {
nextCharacter();
return true;
}
}
return error("quoted string", start);
}
private boolean escape() {
int start = col - 1;
if (" \\\"/bfnrtu".indexOf(c) 0) {
return error("escape sequence \\\",\\\\,\\/,\\b,\\f,\\n,\\r,\\t or \\uxxxx ", start);
}
if (c == 'u') {
if (!ishex(nextCharacter()) || !ishex(nextCharacter()) || !ishex(nextCharacter())
|| !ishex(nextCharacter())) {
return error("unicode escape sequence \\uxxxx ", start);
}
}
return true;
}
private boolean ishex(char d) {
return "0123456789abcdefABCDEF".indexOf(c) = 0;
}
private char nextCharacter() {
c = it.next();
++col;
return c;
}
private void skipWhiteSpace() {
while (Character.isWhitespace(c)) {
nextCharacter();
}
}
private boolean error(String type, int col) {
System.out.printf("type: %s, col: %s%s", type, col, System.getProperty("line.separator"));
return false;
}
public static void main(String[] args){
String jsonStr = "{\"website\":\"open-open.com\"}";
System.out.println(jsonStr+":"+new JsonValidator().validate(jsonStr));
}
}
关于javajsonn和的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。