java中解析json的三种方式
java中json数组去重_JS中Json数据的处理和解析JSON数据的方法详解
java中json数组去重_JS中Json数据的处理和解析JSON数据的方法详解在Java中，可以使用JSON库来处理和解析JSON数据。
常用的JSON 库包括Jackson、Gson和JSON-lib等。
接下来，将详细介绍在Java中处理和解析JSON数据的方法。
一、JSON的处理1.创建JSON对象在Java中，可以通过JSONObject类来创建JSON对象。
例如：```javaJSONObject json = new JSONObject(;```2.添加属性和值可以通过put方法向JSON对象中添加属性和对应的值。
例如：```javajson.put("name", "Alice");json.put("age", 25);```3.转换为JSON字符串通过调用toString(方法，可以将JSON对象转换为JSON字符串。
例如：```javaString jsonString = json.toString(;```二、JSON的解析1.解析JSON字符串为JSON对象可以通过调用JSON库提供的解析方法，将JSON字符串解析为JSON 对象。
例如，使用Gson库：```javaString jsonString = "{\"name\":\"Alice\",\"age\":25}";Gson gson = new Gson(;JsonObject jsonObject = gson.fromJson(jsonString, JsonObject.class);```2.解析JSON对象的属性值可以通过调用JSON对象的get方法，获取对应属性的值。
例如：```javaString name = jsonObject.get("name").getAsString(;int age = jsonObject.get("age").getAsInt(;```3.解析JSON数组在JSON中，可以使用数组结构。
JAVAJSON解析：类XPATH解析JSON
JAVAJSON解析：类XPATH解析JSON⽬前JAVA解析JSON的⽅式有很多种，json-lib啊，GJSON啊，等等都可以解析，但通常是将JSON转换为对象或者是LIST或者是MAP，对于我们测试⼈员来说，其实我们并不需要⾥⾯的全部信息，⼀般情况下，我们只需检查⾥⾯的某个具体的值即可，听说JSONPATH可以做到，我没仔细看过JSONPATH，但是，我们测试⼈员对于XPATH来说，应该是很熟悉了，于是乎，我利⽤XPATH的规则，写了⼀个取得JSON值的⼩应⽤，但是现在只⽀持绝对路径，下⾯来具体的介绍⼀下这个⼩应⽤的使⽤：1.path的写法:json⾥，⼀般是list与map,map好说，有具体的key,但list只有index,于是，我设计这个path的时候，把list⽤*[index]来代替，⾄于map，在path⾥直接写key就⾏，⽐如/*[1]/test，这就是⼀个path，表⽰取⼀个list形式的json串⾥⾯第2个list元素，这个取出来的list元素是个map,取其中的key为test的value，⽐如如下的json： [ { "firstName": "Eric", "lastName": "Clapton", "instrument": "guitar" }, { "firstName": "Sergei", "lastName": "Rachmaninoff", "instrument": "piano" } ]如果想取出Sergei,则path的写法为:/*[1]/firstName2.jar包的调⽤:JsonAction jsonAction = new JsonAction();3.提供出来的api:jsonAction.checkJsonString(json);//检查json串是否合法jsonAction.getPathValue(json, path);//核⼼⽅法，取得给定的path的值jsonAction.isExistPath(json, path);//检查path是否存在，或者说是否合法4.jar包下载地址：(⾥⾯包含源码)欢迎试⽤，如发现任何问题，请随时与我联系，⾮常感谢！。
java中fastjson生成和解析json数据（序列化和反序列化数据）
java中fastjson⽣成和解析json数据（序列化和反序列化数据）本⽂讲解2点：1. fastjson⽣成和解析json数据(举例：4种常⽤类型:JavaBean,List<JavaBean>,List<String>,List<Map<String,Object>)2.通过⼀个android程序测试fastjson的⽤法。
fastjson简介：⼀. fastjson⽣成json字符串(JavaBean,List<JavaBean>,List<String>,List<Map<String,Object>)String jsonStrng = JSON.toJSONString(object);⼆. fastjson 解析json字符串为四种类型1. JavaBeanPerson person = JSON.parseObject(jsonString, Person.class);2. List<JavaBean>List<Person> listPerson =JSON.parseArray(jsonString, Person.class);3. List<String>List<String> listString = JSON.parseArray(jsonString, String.class);4. List<Map<String,Object>>复制代码代码如下:List<Map<String, Object>> listMap = JSON.parseObject(jsonString, new TypeReference<List<Map<String,Object>>>(){}); (注意：此处可看出fastjson反射机制⽐gson更准确， id = 1001 通过fastjson反射仍是 id = 1001 , ⽽通过gson反射结果为 id =1001.0 ,JSON解析器fastjson（阿⾥巴巴出品，版本1.1.26），如果定义了JSONObject为{"JACKIE_ZHANG":"张学友","ANDY_LAU":"刘德华","LIMING":"黎明","Aaron_Kwok":"郭富城"}，那么读取值时,KEY顺序⽆序，测试代码：import comalibabafastjsonJSONObject;/*** Created by wangzhenfei on 14-4-*/public class FastJsonTest {public static void main(String[] args){String jsonStr = "{\"JACKIE_ZHANG\":\"张学友\",\"ANDY_LAU\":\"刘德华\",\"LIMING\":\"黎明\",\"Aaron_Kwok\":\"郭富城\"}" ;//做5次测试for(int i=0,j=5;i<j;i++){JSONObject jsonObject = JSONObjectparseObject(jsonStr) ;for(javautilMapEntry<String,Object> entry:jsonObjectentrySet()){Systemoutprint(entrygetKey()+"-"+entrygetValue()+"\t");}Systemoutprintln();//⽤来换⾏}}}运⾏结果：LIMING-黎明 Aaron_Kwok-郭富城JACKIE_ZHANG-张学友ANDY_LAU-刘德华Aaron_Kwok-郭富城 ANDY_LAU-刘德华LIMING-黎明JACKIE_ZHANG-张学友Aaron_Kwok-郭富城 JACKIE_ZHANG-张学友ANDY_LAU-刘德华LIMING-黎明LIMING-黎明 ANDY_LAU-刘德华JACKIE_ZHANG-张学友Aaron_Kwok-郭富城JACKIE_ZHANG-张学友 LIMING-黎明ANDY_LAU-刘德华Aaron_Kwok-郭富城解决办法：定义为JSONArray，代码如下：import comalibabafastjsonJSONArray;/*** Created by wangzhenfei on 14-4-*/public class FastJsonTest {public static void main(String[] args){String jsonStr = "[{\"JACKIE_ZHANG\":\"张学友\"},{\"ANDY_LAU\":\"刘德华\"},{\"LIMING\":\"黎明\"},{\"Aaron_Kwok\":\"郭富城\"}]" ;//做5次测试for(int i=0,j=5;i<j;i++){JSONArray jsonArray = JSONArrayparseArray(jsonStr);for(int k=0;k<jsonArraysize();k++){Systemoutprint(jsonArrayget(k) + "\t");}Systemoutprintln();//⽤来换⾏}}}运⾏结果为：{"JACKIE_ZHANG":"张学友"} {"ANDY_LAU":"刘德华"}{"LIMING":"黎明"}{"Aaron_Kwok":"郭富城"}{"JACKIE_ZHANG":"张学友"} {"ANDY_LAU":"刘德华"}{"LIMING":"黎明"}{"Aaron_Kwok":"郭富城"}{"JACKIE_ZHANG":"张学友"} {"ANDY_LAU":"刘德华"}{"LIMING":"黎明"}{"Aaron_Kwok":"郭富城"}{"JACKIE_ZHANG":"张学友"} {"ANDY_LAU":"刘德华"}{"LIMING":"黎明"}{"Aaron_Kwok":"郭富城"}{"JACKIE_ZHANG":"张学友"} {"ANDY_LAU":"刘德华"}{"LIMING":"黎明"}{"Aaron_Kwok":"郭富城"}如果就想要定义为JSONObject，⽽不是JSONArray，可以选⽤其他JSON解析器，个⼈推荐使⽤google的gson，⽂档明显⽐fastjson好很多（从这⾥可以看出阿⾥巴巴和⾕歌的差距）：import comgooglegsonJsonElement;import comgooglegsonJsonObject;import comgooglegsonJsonParser;/*** Created by wangzhenfei on 14-4-*/public class FastJsonTest {public static void main(String[] args){String jsonStr = "{\"JACKIE_ZHANG\":\"张学友\",\"ANDY_LAU\":\"刘德华\",\"LIMING\":\"黎明\",\"Aaron_Kwok\":\"郭富城\"}" ;//做5次测试for(int i=0,j=5;i<j;i++){JsonObject jsonObject = (JsonObject) new JsonParser()parse(jsonStr);for(javautilMapEntry<String,JsonElement> entry:jsonObjectentrySet()){Systemoutprint(entrygetKey()+"-"+entrygetValue()+"\t");}Systemoutprintln();//⽤来换⾏}}}运⾏结果：JACKIE_ZHANG-"张学友" ANDY_LAU-"刘德华" LIMING-"黎明" Aaron_Kwok-"郭富城"JACKIE_ZHANG-"张学友" ANDY_LAU-"刘德华" LIMING-"黎明" Aaron_Kwok-"郭富城"JACKIE_ZHANG-"张学友" ANDY_LAU-"刘德华" LIMING-"黎明" Aaron_Kwok-"郭富城"JACKIE_ZHANG-"张学友" ANDY_LAU-"刘德华" LIMING-"黎明" Aaron_Kwok-"郭富城"JACKIE_ZHANG-"张学友" ANDY_LAU-"刘德华" LIMING-"黎明" Aaron_Kwok-"郭富城"以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。
JavaJSON处理面试题及解析
JavaJSON处理面试题及解析Java JSON处理面试题及解析在Java开发中，处理JSON是一项重要的技能。
面试官通常会问一些与JSON处理相关的问题，以评估应聘者的能力和经验。
本文将介绍一些常见的Java JSON处理面试题，并提供详细的解析。
一、简要介绍JSONJSON（JavaScript Object Notation）是一种常用的数据交换格式，它使用易于人类阅读和编写的文本格式，使得数据传输和存储更加方便。
JSON由键值对组成，使用大括号{}包裹对象，使用中括号[]包裹数组。
键值对中的键是字符串，值可以是字符串、数字、布尔值、对象、数组等。
二、常见的Java JSON处理面试题1. 如何将Java对象转换为JSON字符串？在Java中，我们可以使用各种JSON库来将Java对象转换为JSON字符串，例如Jackson、Gson等。
这些库提供了相应的API来实现对象到JSON字符串的转换。
可以使用库提供的序列化方法，将对象转换为JSON字符串。
2. 如何将JSON字符串转换为Java对象？同样地，可以使用JSON库提供的反序列化方法，将JSON字符串转换为Java对象。
库会根据JSON字符串的结构和Java对象的定义，自动地将JSON字符串中的值赋给Java对象的属性。
3. 如何从JSON对象中获取特定的值？当处理JSON时，我们需要从JSON对象中提取特定的值。
可以使用JSON库提供的API来获取JSON对象中指定键的值。
根据JSON对象的结构，可以使用点(.)或方括号([])来访问嵌套的值。
4. 如何遍历JSON数组？当JSON对象中包含数组时，我们可能需要对数组进行遍历。
可以使用JSON库提供的API来遍历JSON数组。
利用循环结构，依次获取数组中的每个元素。
5. 如何处理JSON中的嵌套对象？在一些复杂的JSON结构中，可能存在嵌套对象的情况。
可以通过逐层访问和解析，逐步获取嵌套对象中的值。
java后台对json格式数据的解析
java后台对json格式数据的解析什么是 JsonJSON 的两种结构1.“名称/值”对的集合（A collection of name/value pairs）。
不同的语⾔中，它被理解为对象（object），纪录（record），结构（struct），字典（dictionary），哈希表（hash table），有键列表（keyed list），或者关联数组（associative array）。
在 Java 语⾔中，我们可以将它理解成 HashMap。
对象是⼀个⽆序的"'名称/值'对"集合。
⼀个对象以"{"（左括号）开始，"}"（右括号）结束。
每个“名称”后跟⼀个":"（冒号）；"'名称/值' 对"之间使⽤","（逗号）分隔。
⽰例：var json = {"name":"Jack","age":90,"Marray":true};2. 值的有序列表（An ordered list of values）。
在⼤部分语⾔中，它被理解为数组（Array 或 List）。
数组是值（value）的有序集合。
⼀个数组以"["（左中括号）开始，"]"（右中括号）结束。
值之间使⽤","（逗号）分隔。
⽰例：var json = ["Jack","Rose","Tom",89,true,false];Json-lib转换 javabeans, maps, collections, java arrays 和 XML 成为 json 格式数据转换 json 格式数据成为 javabeans 对象Json-lib 需要的 jar 包commons-beanutils-1.8.3.jarcommons-collections-3.2.1.jarcommons-lang-2.6.jarcommons-logging-1.1.1.jarezmorph-1.0.6.jarjson-lib-2.4-jdk15.ja rJson-lib 的使⽤1. 将 Array 解析成 Json 串。
java json_decode用法
javajson_decode用法JSON是一种常用的数据交换格式，在Java中，我们经常需要处理JSON数据。
JSON_decode是Java中用于解析JSON字符串的常用方法。
以下是JSON_decode的基本用法和注意事项。
一、JSON_decode的基本用法1.引入相关库在使用JSON_decode之前，需要引入相关的库。
在Java中，常用的库是org.json。
可以使用以下代码导入库：```javaimportorg.json.JSONObject;importorg.json.JSONArray;```2.解析JSON字符串使用JSON_decode方法可以将JSON字符串解析为Java对象。
例如，假设有一个JSON字符串：`{"name":"John","age":30}`，可以使用以下代码将其解析为一个JSONObject对象：```javaStringjsonString="{\"name\":\"John\",\"age\":30}";JSONObjectjsonObject=newJSONObject(jsonString);```3.访问JSON数据使用JSONObject对象的get方法可以访问JSON数据。
例如，上面的例子中，可以使用以下代码获取name和age的值：```javaStringname=jsonObject.getString("name");intage=jsonObject.getInt("age");```二、JSON_decode的注意事项1.确保JSON格式正确在使用JSON_decode之前，需要确保输入的JSON字符串格式正确。
如果JSON格式不正确，会导致解析失败或出现错误。
解析json的3种方法
解析json的3种方法JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，它易于人们阅读和编写，也易于机器解析和生成。
在前端开发中，我们经常需要解析JSON数据来处理接口返回的数据，因此掌握解析JSON的方法是非常重要的。
下面我们将介绍三种解析JSON的方法。
第一种方法是使用原生JavaScript的JSON对象来解析JSON数据。
在JavaScript中，我们可以使用JSON.parse()方法来将JSON字符串解析为JavaScript 对象。
这种方法非常简单直接，只需要一行代码即可完成解析。
例如：```javascript。
var jsonStr = '{"name": "Alice", "age": 25}';var jsonObj = JSON.parse(jsonStr);console.log(); // 输出，Alice。
console.log(jsonObj.age); // 输出，25。
```。
第二种方法是使用第三方库来解析JSON数据。
在实际开发中，我们经常会使用一些第三方库来简化开发工作。
比如，我们可以使用jQuery库中的$.parseJSON()方法来解析JSON数据。
这种方法同样非常简单，只需要引入相应的库，然后调用相应的方法即可完成解析。
例如：```javascript。
var jsonStr = '{"name": "Bob", "age": 30}';var jsonObj = $.parseJSON(jsonStr);console.log(); // 输出，Bob。
console.log(jsonObj.age); // 输出，30。
```。
第三种方法是使用ES6中的解构赋值来解析JSON数据。
java解析json文件（省，市，区）
controller层代码： public static void main(String[] args){
//创建一个文件对象，指定要读取的文件
//
File file = new File("F:/json文件/provinces");
//省数据
JSONArray ja = new JSONArray();
街道：
人民路街道办事处,659004003 兵团一零一团,659004500 兵团一零二团,659004501 兵团一零三团,659004502 博古其镇,659006100 双丰镇,659006101
现在想把数据拼接起来，街道总把数据拼接起来街道总共4万多条不知道要怎么操作了
java解析 json文件（省，市，区）
[{"code":"11","name":"北京市"},{"code":"12","name":"天津市"},{"code":"13","name":"河北省"},{"code":"14","name":"山西省"},{"code":"15","name":"内蒙古自治区"}, {"code":"21","name":"辽宁省"},{"code":"22","name":"吉林省"},{"code":"23","name":"黑龙江省"},{"code":"31","name":"上海市"},{"code":"32","name":"江苏省"}, {"code":"33","name":"浙江省"},{"code":"34","name":"安徽省"},{"code":"35","name":"福建省"},{"code":"36","name":"江西省"},{"code":"37","name":"山东省"}, {"code":"41","name":"河南省"},{"code":"42","name":"湖北省"},{"code":"43","name":"湖南省"},{"code":"44","name":"广东省"},{"code":"45","name":"广西壮族自治区"}, {"code":"46","name":"海南省"},{"code":"50","name":"重庆市"},{"code":"51","name":"四川省"},{"code":"52","name":"贵州省"},{"code":"53","name":"云南省"}, {"code":"54","name":"西藏自治区"},{"code":"61","name":"陕西省"},{"code":"62","name":"甘肃省"},{"code":"63","name":"青海省"},{"code":"64","name":"宁夏回族自治区"}, {"code":"65","name":"新疆维吾尔自治区"}]
解析json的3种方法
解析json的3种方法JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，它易于人们阅读和编写，同时也易于机器解析和生成。
在日常的软件开发中，我们经常会遇到需要解析JSON数据的情况。
本文将介绍解析JSON的三种方法，希望能够帮助大家更好地理解和应用JSON数据。
第一种方法是使用内置的JSON对象进行解析。
在JavaScript 中，可以使用JSON对象的parse方法将JSON字符串转换为JavaScript对象，或者使用stringify方法将JavaScript对象转换为JSON字符串。
这种方法简单易用，适用于简单的JSON数据解析和生成。
第二种方法是使用第三方库进行解析。
除了内置的JSON对象，还有许多第三方库可以用来解析JSON数据，例如在Node.js中常用的库有`jsonparse`、`json5`等。
这些库通常提供了更多的功能和更灵活的选项，可以满足各种复杂的JSON数据解析需求。
第三种方法是使用JSON Schema进行解析。
JSON Schema是一种用于描述JSON数据结构的语言，可以用来验证和解析JSON数据。
通过定义JSON Schema，可以规定JSON数据的结构和约束条件，然后使用相应的工具来解析和验证JSON数据。
这种方法适用于需要对JSON数据进行严格验证和规范的场景。
总的来说，解析JSON数据有多种方法可供选择，每种方法都有其适用的场景和特点。
在实际应用中，我们可以根据具体的需求和情况选择合适的方法来解析JSON数据，以便更好地处理和利用JSON数据。
希望本文介绍的三种方法能够对大家有所帮助，让大家在日常的软件开发中更加轻松地处理JSON数据。
java中对json进行解析(使用net.sf.json)
net.sf.json依赖的包很多。
有commons-collections，commons-beanutils.jar，commons-httpclient.jar，commons-lang.jar，ezmorph-1.0.5.jar，morph-1.1.1.jar1./**2.* 从一个JSON 对象字符格式中得到一个java对象，形如：3.* {"id" : idValue, "name" : nameValue, "aBean" : {"aBeanId" : aBeanIdValue, ...}}4.* @param object5.* @param clazz6.* @return7.*/8. public static Object getDTO(String jsonString, Class clazz){9. JSONObject jsonObject = null;10. try{11. setDataFormat2JAVA();12. jsonObject = JSONObject.fromObject(jsonString);13. }catch(Exception e){14. e.printStackTrace();15. }16. return JSONObject.toBean(jsonObject, clazz);17. }18.19./**20.* 从一个JSON 对象字符格式中得到一个java对象，其中beansList是一类的集合，形如：21.* {"id" : idValue, "name" : nameValue, "aBean" : {"aBeanId" : aBeanIdValue, ...},22.* beansList:[{}, {}, ...]}23.* @param jsonString24.* @param clazz25.* @param map 集合属性的类型(key : 集合属性名, value : 集合属性类型clas s) eg: ("beansList" : Bean.class)26.* @return27.*/28. public static Object getDTO(String jsonString, Class clazz, Map map){29. JSONObject jsonObject = null;30. try{31. setDataFormat2JAVA();32. jsonObject = JSONObject.fromObject(jsonString);33. }catch(Exception e){34. e.printStackTrace();35. }36. return JSONObject.toBean(jsonObject, clazz, map);37. }38.39./**40.* 从一个JSON数组得到一个java对象数组，形如：41.* [{"id" : idValue, "name" : nameValue}, {"id" : idValue, "name" : nameValue}, ...]42.* @param object43.* @param clazz44.* @return45.*/46. public static Object[] getDTOArray(String jsonString, Class clazz){47. setDataFormat2JAVA();48. JSONArray array = JSONArray.fromObject(jsonString);49. Object[] obj = new Object[array.size()];50. for(int i = 0; i < array.size(); i++){51. JSONObject jsonObject = array.getJSONObject(i);52. obj[i] = JSONObject.toBean(jsonObject, clazz);53. }54. return obj;55. }56.57./**58.* 从一个JSON数组得到一个java对象数组，形如：59.* [{"id" : idValue, "name" : nameValue}, {"id" : idValue, "name" : nameValue}, ...]60.* @param object61.* @param clazz62.* @param map63.* @return64.*/65. public static Object[] getDTOArray(String jsonString, Class clazz, Map map){66. setDataFormat2JAVA();67. JSONArray array = JSONArray.fromObject(jsonString);68. Object[] obj = new Object[array.size()];69. for(int i = 0; i < array.size(); i++){70. JSONObject jsonObject = array.getJSONObject(i);71. obj[i] = JSONObject.toBean(jsonObject, clazz, map);72. }73. return obj;74. }75./**76.* 从一个JSON数组得到一个java对象集合77.* @param object78.* @param clazz79.* @return80.*/81. public static List getDTOList(String jsonString, Class clazz){82. setDataFormat2JAVA();83. JSONArray array = JSONArray.fromObject(jsonString);84. List list = new ArrayList();85. for(Iterator iter = array.iterator(); iter.hasNext();){86. JSONObject jsonObject = (JSONObject)iter.next();87. list.add(JSONObject.toBean(jsonObject, clazz));88. }89. return list;90. }91.92./**93.* 从一个JSON数组得到一个java对象集合，其中对象中包含有集合属性94.* @param object95.* @param clazz96.* @param map 集合属性的类型97.* @return98.*/99. public static List getDTOList(String jsonString, Class clazz, Map map){ 100. setDataFormat2JAVA();101. JSONArray array = JSONArray.fromObject(jsonString);102. List list = new ArrayList();103. for(Iterator iter = array.iterator(); iter.hasNext();){104. JSONObject jsonObject = (JSONObject)iter.next();105. list.add(JSONObject.toBean(jsonObject, clazz, map));106. }107. return list;108. }109.110./**111.* 从json HASH表达式中获取一个map，该map支持嵌套功能112.* 形如：{"id" : "johncon", "name" : "小强"}113.* 注意commons-collections版本，必须包含mons.collections.map. MultiKeyMap114.* @param object115.* @return116.*/117. public static Map getMapFromJson(String jsonString) {118. setDataFormat2JAVA();119. JSONObject jsonObject = JSONObject.fromObject(jsonString);120. Map map = new HashMap();121. for(Iterator iter = jsonObject.keys(); iter.hasNext();){122. String key = (String)iter.next();123. map.put(key, jsonObject.get(key));124. }125. return map;126. }127.128./**129.* 从json数组中得到相应java数组130.* json形如：["123", "456"]131.* @param jsonString132.* @return133.*/134. public static Object[] getObjectArrayFromJson(String jsonString) {135. JSONArray jsonArray = JSONArray.fromObject(jsonString);136. return jsonArray.toArray();137. }138.139./**140.* 把数据对象转换成json字符串141.* DTO对象形如：{"id" : idValue, "name" : nameValue, ...}142.* 数组对象形如：[{}, {}, {}, ...]143.* map对象形如：{key1 : {"id" : idValue, "name" : nameValue, ...}, key2 : {}, ...}144.* @param object145.* @return146.*/147. public static String getJSONString(Object object) throws Exception{148. String jsonString = null;149.//日期值处理器150. JsonConfig jsonConfig = new JsonConfig();151. jsonConfig.registerJsonValueProcessor(java.util.Date.class, new JsonDateValue Processor());152. if(object != null){153. if(object instanceof Collection || object instanceof Object[]){154. jsonString = JSONArray.fromObject(object, jsonConfig).toString(); 155. }else{156. jsonString = JSONObject.fromObject(object, jsonConfig).toString(); 157. }158. }159. return jsonString == null ? "{}" : jsonString; 160. }。
java中json的使用和解析
java中json的使⽤和解析1.创建json对象1.1创建JSONObject对象使⽤map初始化json@Testpublic void test1(){Map<String, Object> map = new LinkedHashMap<String, Object>();map.put("name", "孙笑川");map.put("age", 25);map.put("height", 1.70);map.put("major", new String[] { "理发", "挖掘机" });map.put("hasGirlFriend", false);map.put("car", null);map.put("house", null);//null作为value时，转换成json后不会保存JSONObject json1 = new JSONObject(map);System.out.println(json1.toString());Map map2 = json1.toMap();System.out.println(map2.toString());}可以看到，当value为null时，转化为json后不会保存，会直接抛弃。
使⽤javabean初始化json//javaBeanclass Person {public String name;public int age;public String idCard;//省略getter&setter}//使⽤javaBean初始化json@Testpublic void test2(){Person person = new Person();person.setName("孙亚龙");person.setAge(30);person.setIdCard("512445546565164641212");JSONObject json2 = new JSONObject(person);System.out.println(json2.toString());}直接创建JSONObject @Testpublic void test3(){JSONObject json3 = new JSONObject();Object nullObj = null;json3.put("name", "孙悟空");json3.put("changeTimes", 72);json3.put("name", "MonkeySun"); //put⽅法：value保留原格式，若key相等，value会覆盖原值json3.put("isHuman", false);json3.append("nickName", "齐天⼤圣"); //append⽅法：value存放在数组中，若key相等，value会覆盖原值json3.append("nickName", "弼马温");json3.accumulate("Teacher", "元始天尊"); //accmulate⽅法,和append⽅法⼀样json3.accumulate("Teacher", "唐三藏");System.out.println(json3.toString());}1.2创建JSONArray对象 ⽤给定的字符串初始化JSONArray对象，字符串最外层必须为中括号包裹： @Testpublic void test12(){String jsonString = "['white','卢本伟','芦苇','卢姥爷']";JSONArray jsonArray = new JSONArray(jsonString);for (Object object : jsonArray) {System.out.println(object);}}直接创建JSONArray对象： 创建⼀个空的JSONArray对象，使⽤put传值@Testpublic void test_1(){JSONArray jsonArray = new JSONArray();//1.put(value)⽅法jsonArray.put("孙悟空");//2.put(index value)⽅法jsonArray.put(1,"{'变化':72,'武器',⾦箍棒}");System.out.println(jsonArray);}2.解析json2.1官⽅json包解析 使⽤官⽅json包解析时，需要下载json官⽅jar包，并导⼊ 下载地址(maven仓库)： 导⼊jar包：import org.json.JSONArray;import org.json.JSONObject;待解析的字符串是简单对象类型，被⼤括号{}包围时：@Testpublic void test6(){//待解析的json字符串String jsonString = "{'name':'卢本伟','age':24,'Position':'Mid'}";//因为json字符串是⼤括号包围，所以⽤JSONObject解析JSONObject json = new JSONObject(jsonString);String name = json.getString("name");int age = json.getInt("age");String position = json.getString("Position");System.out.println("姓名："+name);System.out.println("年龄："+age);System.out.println("位置"+position);}待解析的字符串是数组类型，被中括号[]包围时：@Testpublic void test7(){//待解析的json字符串String jsonString = "['卢本伟','white','卢伟','五五开']";//因为json字符串是⼤括号包围，所以⽤JSONArray解析JSONArray jsonArray = new JSONArray(jsonString);//遍历即可，foreach或for循环for (Object name : jsonArray) {System.out.println(name);待解析的字符串既有中括号[]、⼜有⼤括号[]包围时，逐层解析@Testpublic void test5(){//待解析的json字符串String jsonString = "{'name':'卢本伟','age':24,'Hero':{'name':'Fizz','Position':'Mid','charactor':'killer'},'nickNames':['五五开','芦苇','white'],'Honors':[{'year':2011,'name':'TGA总决赛冠军'},{'year':2013,'name':'S3全球总决赛中国区冠军'},{'year':2013,'na try {//因为json字符串是⼤括号包围，所以⽤JSONObject解析JSONObject json = new JSONObject(jsonString);/** 普通元素，根据类型直接获取*/String name = json.getString("name");int age = json.getInt("age");System.out.println("姓名："+name);System.out.println("年龄："+age);System.out.println("————————————————————————————————");/** 属性⼤括号包括，先获取JSONObject对象*/JSONObject hero = json.getJSONObject("Hero");String hero_name = hero.getString("name");String hero_position = hero.getString("Position");String hero_charactor = hero.getString("charactor");System.out.println("擅长英雄：");System.out.println("英雄名："+hero_name);System.out.println("位置："+hero_position);System.out.println("英雄定位："+hero_charactor);System.out.println("————————————————————————————————");/** 属性被中括号包括，获取JSONArray对象,遍历即可*/System.out.println("外号：");JSONArray nickNames = json.getJSONArray("nickNames");for (Object nickName : nickNames) {System.out.println(nickName);}System.out.println("————————————————————————————————");/** 属性中既有中括号包括，⼜嵌套了⼤括号，⼀层层获取即可*/JSONArray Honors = json.getJSONArray("Honors");System.out.println("所获荣誉：");for(int i=0;i<Honors.length();i++){JSONObject honor = Honors.getJSONObject(i);int honor_year = honor.getInt("year");String honor_name = honor.getString("name");System.out.println(honor_year+" : "+ honor_name);}}catch(Exception e){System.out.println(e.getMessage());}}2.2fastjson解析fastjson是阿⾥巴巴开源产品之⼀，解析速度快。
java读取文件内容,解析Json格式数据方式
java读取⽂件内容,解析Json格式数据⽅式⽬录java读取⽂件内容,解析Json格式数据⼀、读取txt⽂件内容(Json格式数据)⼆、解析处理Json格式数据三、结果存⼊数据库四、测试java 读取txt⽂件中的json数据，进⾏导出以下代码可直接运⾏java读取⽂件内容,解析Json格式数据⼀、读取txt⽂件内容(Json格式数据)public static String reader(String filePath) {try {File file = new File(filePath);if (file.isFile() && file.exists()) {InputStreamReader read = new InputStreamReader(new FileInputStream(file), "UTF-8");BufferedReader bufferedReader = new BufferedReader(read);String lineTxt = bufferedReader.readLine();while (lineTxt != null) {return lineTxt;}}} catch (UnsupportedEncodingException | FileNotFoundException e) {System.out.println("Cannot find the file specified!");e.printStackTrace();} catch (IOException e) {System.out.println("Error reading file content!");e.printStackTrace();}return null;}⼆、解析处理Json格式数据private static void process(String txtStr) {JSONObject json = JSONObject.fromObject(txtStr);JSONArray datas = json.getJSONObject("data").getJSONArray("rows");List<Map<String, Object>> list = new ArrayList<>();for (int i = 0; i < datas.length(); i++) {Map<String, Object> map = new HashMap<>();JSONObject obj = datas.getJSONObject(i).getJSONObject("cells");String name = obj.getString("weibo_name");String code = obj.getString("weibo_id");String url = BASE_URL + obj.getString("url");map.put("name", name);map.put("code", code);map.put("url", url);list.add(map);}if (!list.isEmpty()) {insert(list);}}三、结果存⼊数据库private static void insert(List<Map<String, Object>> list) {for (Map<String, Object> map : list) {//遍历数据，写存储⽅法}}四、测试public static void main(String[] args) {String filePath = "E:\\wugang\\data\\weiboyi\\wechat.txt";String txtStr = reader(filePath);if (txtStr != null) {process(txtStr);} else {System.out.println("Read the content is empty!");}System.out.println("--- end ---");}java 读取txt⽂件中的json数据，进⾏导出txt⽂件中的内容如下以下代码可直接运⾏package com.hwt.count.test;import java.io.BufferedReader;import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.InputStreamReader;import java.util.ArrayList;import java.util.List;import ermodel.HSSFCell;import ermodel.HSSFCellStyle;import ermodel.HSSFFont;import ermodel.HSSFRow;import ermodel.HSSFSheet;import ermodel.HSSFWorkbook;import org.apache.poi.hssf.util.CellRangeAddress;import org.apache.poi.hssf.util.HSSFColor;import net.sf.json.JSONObject;public class Testaa {public static void main(String[] args) {try {String path = "C:/Users/dell/Desktop/test.txt";File file = new File(path);InputStreamReader isr = new InputStreamReader(new FileInputStream(file),"GBK");BufferedReader br = new BufferedReader(isr);String content = br.readLine() ;br.close();isr.close();content = content.substring(2, content.length()-2);content = content.replace("},{", ";");String[] arrContent = content.split(";");//设置列头名称和表体数据String[] rowsName = new String[]{"code_type","code","name"};List<Object[]> dataList = new ArrayList<Object[]>();for(String arrc : arrContent){JSONObject jsonObj = JSONObject.fromObject("{"+arrc+"}");String code = jsonObj.getString("code");String name = jsonObj.getString("name");Object[] obj = new Object[rowsName.length];obj[0] = "TYPE";obj[1] = code;obj[2] = name;dataList.add(obj);}//设置列头名称和表体数据HSSFWorkbook workbook = setWorkBookDate(dataList,rowsName);try {// 将workbook对象输出到⽂件test.xlsFileOutputStream fos = new FileOutputStream("C:/Users/dell/Desktop/test.xls");workbook.write(fos);fos.flush(); // 缓冲fos.close(); // 关闭流}catch (Exception e1) {e1.printStackTrace();}} catch (Exception e) {e.printStackTrace();}}private static HSSFWorkbook setWorkBookDate(List<Object[]> dataList,String[] rowsName){ //创建⼯作簿对象HSSFWorkbook workbook = new HSSFWorkbook();//创建⼯作表，设置当前页名称HSSFSheet sheet = workbook.createSheet("测试");//设置默认⾏⾼sheet.setDefaultRowHeight((short)350);//合并表头表尾的单元格/*sheet.addMergedRegion(new CellRangeAddress(0, 2, 0, 3));sheet.addMergedRegion(new CellRangeAddress(3, 3, 0, 3));//冻结⾏workbook.getSheetAt(0).createFreezePane(0, 4);RegionUtil.setBorderBottom(1, new CellRangeAddress(3, 3, 0, 3), workbook.getSheetAt(0), workbook);//设置边框*/ // 获取表头样式对象// 获取表体样式对象HSSFCellStyle style = getCommonStyle(workbook);// 定义所需列数int columnNum = rowsName.length;//创建列头HSSFRow rowHead = sheet.createRow(0);for(int n = 0;n < columnNum;n++){HSSFCell cellRow = rowHead.createCell(n,HSSFCell.CELL_TYPE_STRING);//创建列头对应个数的单元格cellRow.setCellValue(rowsName[n]);//设置列头单元格的值cellRow.setCellStyle(style);//设置列头单元格样式}//将查询出的数据设置到sheet对应的单元格中for(int i=0;i<dataList.size();i++){Object[] obj =new Object[dataList.get(i).length];obj[0] = dataList.get(i)[0];obj[1] = dataList.get(i)[1];obj[2] = dataList.get(i)[2];HSSFRow row = sheet.createRow(i+1);//创建所需的⾏数for(int j = 0; j < obj.length; j++){HSSFCell cell = row.createCell(j,HSSFCell.CELL_TYPE_STRING);//设置单元格的数据类型if(!"".equals(obj[j]) && obj[j] != null){cell.setCellValue(obj[j].toString());//设置单元格的值}else{cell.setCellValue("");//设置单元格的值为空字符串}cell.setCellStyle(style);//设置单元格样式}}//让列宽随着导出的列长⾃动适应for (int colNum = 0; colNum < columnNum; colNum++) {int columnWidth = sheet.getColumnWidth(colNum) / 256;for (int rowNum = 0; rowNum < sheet.getLastRowNum(); rowNum++) {HSSFRow currentRow;//当前⾏未被使⽤过if (sheet.getRow(rowNum) == null) {currentRow = sheet.createRow(rowNum);} else {currentRow = sheet.getRow(rowNum);}if (currentRow.getCell(colNum) != null) {HSSFCell currentCell = currentRow.getCell(colNum);if(currentCell != null && !"".equals(currentCell)){if (currentCell.getCellType() == HSSFCell.CELL_TYPE_STRING) {int length = currentCell.getStringCellValue().getBytes().length;if (columnWidth < length) {columnWidth = length;}}}}}if(colNum == 0){//设置表体第⼀列的宽度sheet.setColumnWidth(colNum, (columnWidth+4) * 400);}else{//设置表体其他列的宽度sheet.setColumnWidth(colNum, (columnWidth+4) * 400);}}return workbook;}public static HSSFCellStyle getCommonStyle(HSSFWorkbook workbook) {// 设置字体HSSFFont font = workbook.createFont();//设置字体⼤⼩font.setFontHeightInPoints((short)11);//字体加粗//font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);//设置字体名字font.setFontName("Courier New");//设置样式;HSSFCellStyle style = workbook.createCellStyle();//设置底边框;style.setBorderBottom(HSSFCellStyle.BORDER_THIN);//设置底边框颜⾊;style.setBottomBorderColor(HSSFColor.BLACK.index);//设置左边框;style.setBorderLeft(HSSFCellStyle.BORDER_THIN);//设置左边框颜⾊;style.setLeftBorderColor(HSSFColor.BLACK.index);//设置右边框;style.setBorderRight(HSSFCellStyle.BORDER_THIN);//设置右边框颜⾊;style.setRightBorderColor(HSSFColor.BLACK.index);//设置顶边框;style.setBorderTop(HSSFCellStyle.BORDER_THIN);//设置顶边框颜⾊;style.setTopBorderColor(HSSFColor.BLACK.index);//在样式⽤应⽤设置的字体;style.setFont(font);//设置⾃动换⾏;style.setWrapText(false);//设置⽔平对齐的样式为居中对齐;style.setAlignment(HSSFCellStyle.ALIGN_CENTER);//设置垂直对齐的样式为居中对齐;style.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);return style;}}以上为个⼈经验，希望能给⼤家⼀个参考，也希望⼤家多多⽀持。
解析json的3种方法
解析json的3种方法解析JSON数据有三种常见的方法：手动解析、使用第三方库和利用语言内置的解析器。
下面将详细介绍这三种方法。
1. 手动解析手动解析是最基本的JSON解析方法之一。
它适用于简单的JSON结构和较小的JSON文件。
手动解析的主要步骤包括以下几个方面：1.1 读取JSON数据首先，需要将JSON数据读取到内存中。
可以使用文件读写操作或网络请求等方式获取JSON数据，然后将数据存储在字符串变量中。
1.2 解析JSON数据接下来，需要逐个解析JSON数据的各个字段。
JSON数据由键值对组成，每个键对应一个值。
可以使用字符串处理操作（例如截取子字符串）和正则表达式等方式逐步解析JSON数据。
手动解析需要注意处理JSON数据中可能出现的异常情况，例如缺失的字段或字段值为null等。
1.3 获取JSON字段值完成解析后，可以通过键来获取对应的值。
根据JSON数据的结构，可以使用字符串处理操作和类型转换等方式将获取到的值转换为所需的数据类型，例如字符串、整数、浮点数等。
手动解析的优点是灵活性高，适用于简单的JSON结构和小型JSON文件。
缺点是需要编写较多的代码来处理JSON数据，且容易出错。
2. 使用第三方库第二种方法是使用第三方库来解析JSON数据。
大多数编程语言都提供了丰富的JSON解析库，例如Python中的json库、Java中的Gson和Jackson库，以及JavaScript中的JSON.parse()等。
使用第三方库的主要步骤如下：2.1 导入第三方库首先，需要导入所需的JSON解析库。
可以使用包管理工具或手动将库文件添加到项目中。
2.2 加载JSON数据接下来，需要将JSON数据加载到程序中。
可以使用文件读写操作或网络请求等方式获取JSON数据，并将其存储在合适的数据结构中（例如字符串、字典或列表）。
2.3 解析JSON数据使用第三方库提供的API，可以方便地解析JSON数据。
java jsonparser用法
java jsonparser用法Java JSONParser 是一个用于解析 JSON 格式数据的工具。
它提供了一种方便和高效的方式来解析和访问 JSON 数据。
在本文中，我们将介绍如何使用 Java JSONParser 解析 JSON 数据。
首先，我们需要引入相应的 JSONParser 类。
在 Java 中，我们可以使用第三方库，如 Jackson、Gson 或者 JSON.simple 来提供 JSON 解析的功能。
其中，JSON.simple 是一个轻量级且易于使用的库，因此我们将重点介绍如何使用JSON.simple 中的 JSONParser。
要使用 JSON.simple 中的 JSONParser，我们首先需要添加 JSON.simple 的依赖。
在项目的 pom.xml 文件中，可以添加以下依赖：```xml<dependencies><dependency><groupId>com.googlecode.json-simple</groupId><artifactId>json-simple</artifactId><version>1.1.1</version></dependency></dependencies>```完成依赖添加后，我们可以开始使用 JSONParser。
首先，我们需要将 JSON 格式的数据转换为字符串。
在 Java 中，我们可以使用字符串来表示 JSON 数据，然后通过 JSONParser 进行解析。
下面是一个简单的示例代码：```javaimport org.json.simple.JSONObject;import org.json.simple.parser.JSONParser;import org.json.simple.parser.ParseException;public class JsonParserExample {public static void main(String[] args) {String jsonString = "{\"name\":\"John\", \"age\":30, \"city\":\"New York\"}"; try {// 创建 JSONParser 对象JSONParser parser = new JSONParser();// 将字符串解析为 JSON 对象JSONObject jsonObject = (JSONObject) parser.parse(jsonString);// 获取 JSON 对象中的数据String name = (String) jsonObject.get("name");long age = (Long) jsonObject.get("age");String city = (String) jsonObject.get("city");// 打印获取到的数据System.out.println("Name: " + name);System.out.println("Age: " + age);System.out.println("City: " + city);} catch (ParseException e) {e.printStackTrace();}}}```在上述代码中，我们首先创建了一个 JSONParser 对象。
Java从String开始解析JSON
Java从String开始解析JSON菜鸟教程的 JSON 教程链接：⼀、JSON 格式简析。
{"person_num": 1,"person_info": [{"body_parts": {"nose": {"x": 96.34375,"y": 101.53125},"right_knee": {"x": 89.6875,"y": 314.53125},"location": {"width": 91.40377044677734,"height": 354.7197875976562}}]} 1. 对象在 { } ⼤括号中 2. 数组在 [ ] 中括号中 3. key:value 值，中间⽤冒号隔开⼆、将 String 类型的数据转换为 JSON 格式数据 需要导⼊⼏个 jar 包，⽂件在以下链接中：链接：https:///s/1SNMIPJal0-YKpsMqTnzjsg提取码：ezmb复制这段内容后打开百度⽹盘⼿机App，操作更⽅便哦 需要导⼊的类如下：import net.sf.json.JSONArray;import net.sf.json.JSONObject; String 类型数据转换为 JSON 格式数据代码如下：//result 是上⽅ JSON 数据的String 格式String result = "{"person_num": 1,"person_info": [{"body_parts": {"nose": {"x": 96.34375,"y": 101.53125},"right_knee": {"x": 89.6875,"y": 314.53125},"location": {"width": 91.40377044677734,"height": 354.7197875976562}}]}" JSONObject jsonObject = JSONObject.fromObject(result);//将String 类型数据转换为 JSON 格式数据三、将 JSON 中的数据提取出来 代码⽰例为上⽅提供的 JSON 格式数据（取出其中 "nose" 的数据） 1. 取对象中的数组数据：（"person_info" 对应的 JSON 值是数组类型）JSONArray person_info = jsonObject.getJSONArray("person_info"); 2. 取数组中的对象：（取 person_info 中第⼀个数据，在上⾯的例⼦中 "person_info" 数组中有两个数据："body_parts" 和 "location" ）JSONObject body_parts = person_info.getJSONObject(0); 3. ⼀个对象中有多个对象： 是可以直接利⽤第 1 个⽰例中的⽅法调⽤，但是这⾥⽐较特殊的地⽅在于："body_parts" 刚从数组中得到数据，还要进⾏转化：//由于 body_parts中还有JSONObject，因此还要将 body_parts取出来body_parts = body_parts.getJSONObject("body_parts");//得到⿐⼦的信息JSONObject nose = body_parts.getJSONObject("nose"); 4. 得到 key-value值：（得到 "nose" 中的 x、y 值）double nose_x = nose.getDouble("x");double nose_y = nose.getDouble("y"); 后⾯就可以直接利⽤ JSON 中的数据了。
java多种方式解析json字符串
java多种方式解析 json字符串
第一种：用net.sf.json硬解。缺点：要求字段名称和json字符串中的字段名一样，字段命名会违反驼峰规则，也不利于拓展； JSONArray jsonArray = JSONArray.fromObject(str);
JSONObject jObj = jsonArray.getJSONObject(0); User user= (User)jObj.toBean(jObj,User.class); 第二种：用Gson解析json字符串。优点：写法简单，字段名称只要使用@SerializedName注解，皆可以是使对象字段和json一一对应；缺 点：解析json数组这样的字符串稍微麻烦点 Gson gson = new Gson(); User user= gson.fromJson(msg, User.class); 解析JSON数组： List<T> list = gson.fromJson(str, new TypeToken<List<T>>(){}.getType());
第三种：用jackson解析。优点：与Gson解析一样，字段名称可以使用@JsonProperty注解； ObjectMapper mapper = new ObjectMapper(); User user= mapper.readValue(msg, User.class);
[Java]-Java中使用JSON（整理）
![[Java]-Java中使用JSON（整理）](https://img.taocdn.com/s3/m/b91e58f8b9f67c1cfad6195f312b3169a551ea54.png)
[Java]-Java中使⽤JSON（整理）⼀、JSON类库Json类库选择：Java中并没有内置JSON的解析，因此使⽤JSON需要借助第三⽅类库。
下⾯是⼏个常⽤的 JSON 解析类库：Gson：⾕歌开发的JSON库，功能⼗分全⾯。
FastJson：阿⾥巴巴开发的JSON库，性能⼗分优秀。
Jackson：社区⼗分活跃且更新速度很快。
⼆、FastJson简介Fastjson特性提供服务器端、安卓客户端两种解析⼯具，性能表现较好。
提供了 toJSONString() 和 parseObject() ⽅法来将 Java 对象与 JSON 相互转换。
调⽤toJSONString()⽅法即可将对象转换成 JSON 字符串，parseObject() ⽅法则反过来将 JSON 字符串转换成对象。
允许转换预先存在的⽆法修改的对象（只有class、⽆源代码）。
Java泛型的⼴泛⽀持。
允许对象的⾃定义表⽰、允许⾃定义序列化类。
⽀持任意复杂对象（具有深厚的继承层次和⼴泛使⽤的泛型类型）。
FastJson使⽤：<dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>1.2.47</version></dependency>其中 1.2.47 是版本号，根据需要使⽤特定版本，建议使⽤最新版本。
三、Fasjson中的主要类定义FastJson类库中最基本的类和⽅法定义：1、JSONJSON类在com.alibaba.fastjson.JSON包中。
JSON类提供了多种 Java对象<->JSON字符串直接互相转换的⽅法。
JSON.parseObject()：从字符串解析 JSON 对象。
JSON.parseArray()：从字符串解析 JSON 数组。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
// System.out.println(str);
String response = jsonObject.getString("response");
JSONObject jsonObject2 = JSONObject.fromObject(response);
String str[] =
json.replaceAll(".*\"address\":\"(.*?)\".*\"province\":\"(.*?)\",.*\"district\":\"(.*?)\",.*\"city\":\"(.*?)\".*",
"$2,$4,$3,$1").split(",");
System.out.println(data2.getString("address"));
System.out.println(data2.getString("province"));
System.out.println(data2.getString("district"));
System.out.println(data2.getString("city"));
JSONArray data = jsonObject2.getJSONArray("data");
for(int i=0;i<data.length();i++){
String s = data.getString(i);
JSONObject data2 = JSONObject.fromObject(s);
System.out.println(s);
JSONObject data2 = JSONObject.fromObject(s);
System.out.println(data2.getString("id"));
System.out.println(data2.getString("name"));
}
}
//第三种(只获取json里面数据)
public static void main(String[] args) {
String json =
"{\"response\":{\"data\":[{\"address\":\"北京\",\"province\":\"海淀\",\"district\":\"三环\",\"city\":\"桥\"}]},\"status\":\"ok\"}";
int status = data.optInt("status");
JSONArray data1 = data.getJSONArray("data");
if (status==200) {
for(int i=0;i<data1.length();i++){
String s = data1.getString(i);
for (String s : str) {
System.out.println(s);
}
}
//第一种
public void jsonTx() {
String json = "{'status':200,'message':'查询成功','data':[{'id':1,'name':'name1','describe':'第一条数据'}]}";
JSONObject data = new JSONObject(json);
String json =
"{'response':{'data':[{'address':'北京','province':'海淀','district':'西三旗','city':'地铁'}]},'status':'ok'}";
JSONObject jsonObject = JSONObject.fromObject(json);
System.out.println(data2.getString("describe"));
}
}else if(status==500) {
String msg = data.getString("message");
System.out.println(msgublic void getJson() {