多层嵌套数字key的json解析.docx
《多层嵌套数字key的json解析.docx》由会员分享，可在线阅读，更多相关《多层嵌套数字key的json解析.docx（26页珍藏版）》请在冰豆网上搜索。
多层嵌套数字key的json解析
变态的json解析，key为数字，设置没有key！
如何解析呢？
Android 康师傅
标题：
变态的json解析，key为数字，设置没有key！
如何解析呢？
关键字：
json解析、key为数字、没有key
导语：
最近做的项目是一个打车类的项目，需要选择地址，而数据是Json数据。
因为这些数据不对公司造成任何的损失，也没有涉及到任何的隐私或者商业秘密，所以就写此文，说说暂时的解决方法吧，嘻嘻！
遇到的问题：
不是标准的json数据，有些甚至没有key。
比如说一开始的北京，0，这些都没有key。
另外，有key的都是数字。
是数据的话，第一个层级是0~33.然而第二个层级是不定的，也就是不能用for循环啦，哈哈！
先看看数据吧：
数据如下：
全国省市县三级Json数据
解析的核心类：
（没有进行封装）
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
packagecom.sunofbeaches.jsondemo;
importjava.util.Map.Entry;
importjava.util.Set;
importcom.google.gson.JsonArray;
importcom.google.gson.JsonElement;
importcom.google.gson.JsonObject;
importcom.google.gson.JsonParser;
importandroid.os.Bundle;
importandroid.app.Activity;
publicclassMainActivityextendsActivity{
@Override
protectedvoidonCreate（BundlesavedInstanceState）{
super.onCreate（savedInstanceState）;
setContentView（R.layout.activity_main）;
parserJson（）;
}
privatevoidparserJson（）{
//获取到数据
StringjsonString=getResources（）.getString（R.string.jsonstring）;
//json解析者
JsonParserjsonParser=newJsonParser（）;
//解析成Json对象
JsonObjectasJsonObject=jsonParser.parse（jsonString）
.getAsJsonObject（）;
//遍历里头的数据
Set>entrySet=asJsonObject.entrySet（）;
for（Entryentry:
entrySet）{
JsonArrayasJsonArray=entry.getValue（）.getAsJsonArray（）;
StringasString=asJsonArray.get（0）.getAsString（）;//省份
System.out.println（"asString--"+asString）;
intasInt=asJsonArray.get
（1）.getAsInt（）;//那个数字
System.out.println（"asInt--"+asInt）;
//获取到第3个，又是一个json对象
JsonObjectasJsonObject2=asJsonArray.get
（2）.getAsJsonObject（）;
//遍历第2级数据
Set>entrySet2=asJsonObject2
.entrySet（）;
for（Entryentry2:
entrySet2）{
JsonArrayasJsonArray2=entry2.getValue（）.getAsJsonArray（）;
if（asJsonArray2.size（）==1）{//这一个判断是因为在河北市（42249）里头只有一级，没有下一级了
StringasString2=asJsonArray2.get（0）.getAsString（）;//市级
System.out.println（"asString2===="+asString2）;
}else{
StringasString2=asJsonArray2.get（0）.getAsString（）;//市级
System.out.println（"asString2===="+asString2）;
intasInt2=asJsonArray2.get
（1）.getAsInt（）;//数字
System.out.println（"asInt====="+asInt2）;
//获取第三级数据（县级/区）
JsonObjectasJsonObject3=asJsonArray2.get
（2）
.getAsJsonObject（）;
//遍历第三级数据
Set>entrySet3=asJsonObject3
.entrySet（）;
for（Entryentry3:
entrySet3）{
JsonArrayasJsonArray3=entry3.getValue（）
.getAsJsonArray（）;
StringasString3=asJsonArray3.get（0）.getAsString（）;//县级数据
System.out.println（"asString3>>>>>>"+asString3）;
}
}
}
}
}
}
封装成对象
因为数据不标准，所以我们不能直接创建一个bean类，用gson直接解析，因为gson的直接解析是使用反射的方法來做的。
那么这里也说说吧，如果直接是用bean类來解析的话，需要它的权限所有都是public的，类是public的，里面的成员，所有都是public的，这是第一点。
那么第二点就是这个里面的名字要和这个json数据里的名字要一样哦。
就是对应的数据名字要一样，原因还是因为使用反射的方法來解析嘛。
ok,那么通过上面这个核心方法，我们可以定义出以下的bean类，然后手动地赋值，就可以封装起來了。
主要的bean类
这些bean结构和Json里的数据是一样的结构，只是名字不一样。
因为Java中数字不能作为变量的名字嘛，是吧！
这个我们小时候学java就知道啦，标识符的规则。
好的，直接上bean类吧！
这个是整体的bean类
codeby
Java
1
2
3
4
5
6
7
8
packagecom.sunofbeaches.jsondemo.bean;
importjava.util.List;
publicclassJsonBean{
publicListProvinces;
}
这个省份的bean类
Java
1
2
3
4
5
6
7
8
9
10
packagecom.sunofbeaches.jsondemo.bean;
importjava.util.List;
publicclassProvinces{
publicStringprovinceName;
publicintshengNumber;
publicListcities;
}
市级的bean类
Java
1
2
3
4
5
6
7
8
9
packagecom.sunofbeaches.jsondemo.bean;
importjava.util.List;
publicclassCity{
publicStringcityName;
publicintchengshiNumber;
publicListcountries;
}
镇/区级的bean类
Java
1
2
3
4
5
packagecom.sunofbeaches.jsondemo.bean;
publicclassCountry{
publicStringcountryNmae;
}
有了bean类之后，我们可以对数据进行封装，因为前面我们已经解析了数据嘛！
数据封装：
数据封装核心类，其实和这个解析类在一起了，那么个类的功能就是解析数据，并封装数据，返回一个bean类
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
packagecom.sunofbeaches.jsondemo;
importjava.util.ArrayList;
importjava.util.Map.Entry;
importjava.util.Set;
importandroid.content.Context;
importcom.google.gson.JsonArray;
importcom.google.gson.JsonElement;
importcom.google.gson.JsonObject;
importcom.google.gson.JsonParser;
importcom.orange.jsondemo.R;
importcom.sunofbeaches.jsondemo.bean.City;
importcom.sunofbeaches.jsondemo.bean.Country;
importcom.sunofbeaches.jsondemo.bean.JsonBean;
importcom.sunofbeaches.jsondemo.bean.Provinces;
publicclassGetAllDatasBean{
publicJsonBeangetAllDatas（Contextcontext）{
//整体Bean类
JsonBeanbean=newJsonBean（）;
bean.Provinces=newArrayList（）;
//获取到数据
StringjsonString=context.getResources（）.getString（
R.string.jsonstring）;
//json解析者
JsonParserjsonParser=newJsonParser（）;
//解析成Json对象
JsonObjectasJsonObject=jsonParser.parse（jsonString）
.getAsJsonObject（）;
//遍历里头的数据
Set>entrySet=asJsonObject.entrySet（）;
for（Entryentry:
entrySet）{
//省bean类
Provincesprovince=newProvinces（）;
province.cities=newArrayList（）;
JsonArrayasJsonArray=entry.getValue（）.getAsJsonArray（）;
StringasString=asJsonArray.get（0）.getAsString（）;//省份
//赋值
province.provinceName=asString;
System.out.println（"asString>>"+asString）;
intasInt=asJsonArray.get
（1）.getAsInt（）;//那个数字
//赋值
province.shengNumber=asInt;
//获取到第3个，又是一个json对象
JsonObjectasJsonObject2=asJsonArray.get
（2）.getAsJsonObject（）;
//遍历第2级数据
Set>entrySet2=asJsonObject2
.entrySet（）;
for（Entryentry2:
entrySet2）{
JsonArrayasJsonArray2=entry2.getValue（）.getAsJsonArray（）;
//市bean类
Citycity=newCity（）;
city.countries=newArrayList（）;
if（asJsonArray2.size（）==1）{//这一个判断是因为在河北市（42249）里头只有一级，没有下一级了
StringasString2=asJsonArray2.get（0）.getAsString（）;//市级
city.cityName=asString2;
city.chengshiNumber=-1;//表示没有
city.countries=null;//表示没有，使用的时候要记得判断
}else{
StringasString2=asJsonArray2.get（0）.getAsString（）;//市级
//赋值
city.cityName=asString2;
intasInt2=asJsonArray2.get
（1）.getAsInt（）;//数字
//赋值
city.chengshiNumber=asInt2;
//获取第三级数据（县级/区）
JsonObjectasJsonObject3=asJsonArray2.get
（2）
.getAsJsonObject（）;
//遍历第三级数据
Set>entrySet3=asJsonObject3
.entrySet（）;
for（Entryentry3:
entrySet3）{
JsonArrayasJsonArray3=entry3.getValue（）
.getAsJsonArray（）;
StringasString3=asJsonArray3.get（0）.getAsString（）;//县级数据
//县级/区数据bean类
Countrycountry=newCountry（）;
country.countryNmae=asString3;
city.countries.add（country）;//添加县/区
}
}
province.cities.add（city）;
}
bean.Provinces.add（province）;
}
returnbean;
}
}
到这里，数据已经完成了解析，也完成了封装，可以直接得到一个包含了所有数据的类。
那么怎么使用呢？
下面，就通过一个例子來使用一下这面里的数据吧！
省市镇三级联动例子（使用数据）
布局如下：
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
android="
xmlns:
tools="
android:
layout_width="match_parent"
android:
layout_height="match_parent"
tools:
context=".MainActivity">
android:
id="@+id/provinces"
android:
layout_width="0dp"
android:
layout_height="wrap_content"
android:
layout_weight="1"/>
android:
id="@+id/cities"
android:
layout_width="0dp"
android:
layout_height="wrap_content"
android:
layout_weight="1"/>
android:
id="@+id/countries"
android:
layout_width="0dp"
android:
layout_height="wrap_content"
android:
layout_weight="1"/>
当然，是没有数据的，嘻嘻！
核心类如下：
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
packagecom.sunofbeaches.jsondemo;
importjava.util.List;
importandroid.app.Activity;
importandroid.os.Bundle;
importandroid.util.L
升级会员 