Java学习笔记:JSONObject与JSONArray的使用
java jsonarray用法
java jsonarray用法JSONArray是Java中用于处理JSON数组数据的一种重要类。
在Java中,使用JSONArray可以方便地操作和处理JSON数据,包括添加、删除、遍历、查找等操作。
本篇文档将详细介绍JSONArray的用法,帮助您更好地理解和应用JSONArray。
一、JSONArray简介JSONArray是JSON数据结构中的一种,用于表示一个包含多个JSON对象的数组。
在Java中,可以使用org.json包中的JSONArray 类来表示和操作JSONArray。
JSONArray类提供了丰富的API,方便开发者进行各种操作。
二、创建JSONArray对象要创建一个JSONArray对象,可以使用JSONArray类的构造函数。
构造函数接受一个字符串数组作为参数,用于表示JSONArray中的元素。
例如:```javaString[]jsonArrayElements={"元素1","元素2","元素3"};JSONArrayjsonArray=newJSONArray(jsonArrayElements);```上述代码创建了一个包含三个元素的JSONArray对象。
三、添加元素到JSONArray使用JSONArray类的add()方法可以将一个或多个元素添加到JSONArray中。
例如:```javaJSONArrayjsonArray=newJSONArray();jsonArray.add("元素1");jsonArray.add("元素2");jsonArray.add(newJSONObject("{\"key\":\"value\"}"));```上述代码将三个元素添加到了jsonArray中。
JSONObject和JSONArray使用手册
JSONObject和JSONArray使用import net.sf.json.JSONArray;import net.sf.json.JSONObject;import java.util.*;public class Java Test {public static void main(String[] args){JSONObject obj=new JSONObject();obj.put("derek","23");obj.put("dad", "49");obj.put("mom", "45");System.out.println("通过构造器的方式创建的JSONObject对象:"+obj);Map<string,string> map=new LinkedHashMap<>();map.put("derek","23");map.put("dad", "49");map.put("mom", "45");System.out.println("通过fromObject方法将map对象转换为JSONObject对象:"+JSONObject.fromObject(map));JSONArray arr=new JSONArray();arr.add(0,"derek");arr.add(1,"dad");arr.add(2,"mom");System.out.println("通过构造器的方式创建的JSONArray:"+arr);ArrayList list=new ArrayList<>();list.add("derek");list.add("dad");list.add("mom");System.out.println("通过fromObject方法将Arraylist对象转换为JSONArray对象:"+JSONArray.fromObject(list));System.out.println("将HashMap对象通过fromObject方法转换为JSONArray对象"+JSONArray.fromObject(map));String str="{\"derek\":23,\"dad\":49,\"mom\":45}";System.out.println("解析之后的JSON对象:"+JSONObject.fromObject(str));//遍历输出Iterator it=obj.keys();while(it.hasNext()){String key=it.next();System.out.println(key+":"+obj.get(key));}}}运行结果如下:通过构造器的方式创建的JSONObject对象:{"derek":"23","dad":"49","mom":"45"}通过fromObject方法将map对象转换为JSONObject对象:{"derek":"23","dad":"49","mom":"45"}通过构造器的方式创建的JSONArray:["derek","dad","mom"]通过fromObject方法将Arraylist对象转换为JSONArray对象:["derek","dad","mom"]将HashMap对象通过fromObject方法转换为JSONArray对象[{"derek":"23","dad":"49","mom":"45"}]解析之后的JSON对象:{"derek":23,"dad":49,"mom":45}derek:23dad:49mom:45Java List 用法java List是个集合接口,只要是集合类接口都会有个“迭代子”(Iterator ),利用这个迭代子,就可以对list内存的一组对象进行操作。
java jsonarray排序方法
java jsonarray排序方法Java JSONArray是一种用于存储和操作JSON数据的数据结构。
在实际应用中,经常需要对JSONArray进行排序操作,以满足业务需求。
本文将介绍一些常用的JSONArray排序方法,帮助读者快速理解和使用。
一、JSONArray排序概述JSONArray是Java中用于表示JSON数组的类,它可以存储多个JSON对象。
而JSON对象是由键值对组成的,每个键值对表示一个属性。
在排序JSONArray时,我们通常是根据某个属性的值进行排序,比如按照年龄、价格等进行升序或降序排列。
二、使用JSONArray的sort方法进行排序JSONArray提供了一个sort方法,可以直接对数组进行排序。
sort方法有两个重载版本,一个是不传递Comparator参数的,默认按照元素的自然顺序进行排序;另一个是传递Comparator参数的,可以自定义排序规则。
1.默认排序JSONArray的sort方法默认按照元素的自然顺序进行排序。
自然顺序是根据元素的类型进行排序,比如数字从小到大,字符串按照字典序等。
示例代码如下:```javaJSONArray jsonArray = new JSONArray("[3, 1, 2]"); jsonArray.sort();System.out.println(jsonArray.toString());```输出结果为:[1, 2, 3]2.自定义排序如果要对JSONArray中的对象按照某个属性进行排序,可以使用传递Comparator参数的sort方法。
Comparator是一个函数式接口,可以根据自己的需求编写排序规则。
示例代码如下:```javaJSONArray jsonArray = new JSONArray("[{\"name\":\"Alice\", \"age\":18}, {\"name\":\"Bob\", \"age\":20}, {\"name\":\"Cindy\", \"age\":15}]");jsonArray.sort((o1, o2) -> {int age1 = ((JSONObject) o1).getInt("age");int age2 = ((JSONObject) o2).getInt("age");return age1 - age2;});System.out.println(jsonArray.toString());输出结果为:[{"name":"Cindy","age":15},{"name":"Alice","age":18},{"name":" Bob","age":20}]三、使用Collections工具类进行排序除了JSONArray提供的sort方法外,我们还可以使用Collections 工具类的sort方法对JSONArray进行排序。
使用Gson将字符串转换成JsonObject和JsonArray
使⽤Gson将字符串转换成JsonObject和JsonArray ⽬录Gson将字符串转JsonObject和JsonArray以下均利⽤Gson来处理JSONObject与JSON互转引⼊ jar , 此处引⼊ com.alibaba.fastjson 版本的jar包建⽴测试类对象转换Gson将字符串转JsonObject和JsonArray以下均利⽤Gson来处理1.将bean转换成Json字符串:public static String beanToJSONString(Object bean) {return new Gson().toJson(bean);}2.将Json字符串转换成对象:public static Object JSONToObject(String json,Class beanClass) {Gson gson = new Gson();Object res = gson.fromJson(json, beanClass);return res;}注:转换后的对象使⽤前进⾏强转:例如bean bean1 = (bean)FormatUtil.JSONToObject(json, bean.class);3.将Json字符串转换成JsonObject对象:JsonObject returnData = new JsonParser().parse(jsonstr).getAsJsonObject();4.将JsonArray类型的Json字符串解析成对象⽅法Gson gson = new Gson();JsonParser parser = new JsonParser();JsonArray Jarray = parser.parse(jstring).getAsJsonArray();ArrayList<channelSearchEnum> lcs = new ArrayList<channelSearchEnum>();for(JsonElement obj : Jarray ){channelSearchEnum cse = gson.fromJson( obj , channelSearchEnum.class);lcs.add(cse);}或者String json = "[{\"username\":\"test\"},{\"username\":\"test2\"}]";System.out.println(new JsonParser().parse(json).getAsJsonArray().get(0).getAsJsonObject().get("username").getAsString());5.获取JsonObject中指定key值对应的JsonArray对象:String json= "{\"pids\":[\"1\",\"2\",\"3\"]}";System.out.println(new JsonParser().parse(json).getAsJsonObject().getAsJsonArray("pids").get(0).getAsString()); JSONObject与JSON互转使⽤⽬的⽬前数据交互⼤多以 JSON 字符串为信息传输,主要格式有{"age":"22","name":"李四"}[{"age":"21","name":"张三"}]最常见的应⽤场景是前后端对接,第三⽅平台⽂档对接,下⾯展⽰转换使⽤。
jsonobject动态解析多层嵌套构造
一、什么是jsonobject动态解析JSON(JavaScript Object Notation)是一种轻量级的数据交换格式,它以文本格式来传输结构化的数据。
在Java中,JSON数据通常以JSONObject的形式进行解析和构造。
JSONObject是org.json中的一个类,可以动态构造和解析多层嵌套的JSON数据。
二、为什么需要动态解析多层嵌套的JSON数据在实际开发中,我们经常会遇到多层嵌套的JSON数据,这些数据可能来自后端接口、第三方API,甚至是本地文件等。
动态解析多层嵌套的JSON数据可以帮助我们轻松地获取所需的数据,并对其进行操作和处理。
掌握动态解析多层嵌套的JSON数据是非常重要的。
三、使用JSONObject动态解析多层嵌套的JSON数据在Java中,我们可以使用JSONObject来动态解析多层嵌套的JSON 数据。
下面是一些常用的方法:1. 创建JSONObject对象```javaJSONObject jsonObject = new JSONObject(jsonString);```这里的jsonString可以是从后端接口或其他数据源获取的JSON字符串。
2. 获取一级属性```javaString value = jsonObject.getString("key");```这里的"key"是JSON数据中的属性名称,我们可以通过getString、getInt、getDouble等方法来获取相应类型的属性值。
3. 获取嵌套属性```javaJSONObject nestedObject =jsonObject.getJSONObject("nestedKey");String nestedValue = nestedObject.getString("nestedValue"); ```如果JSON数据中存在嵌套的对象,我们可以使用getJSONObject 方法获取嵌套的JSONObject,并继续对其进行解析。
递归解析嵌套jsonjsonarray和jsonobject
递归解析嵌套jsonjsonarray和jsonobject 在处理嵌套的JSON数据时,我们通常会遇到两种类型的数据结构:JSON数组和JSON对象。
JSON数组是一个有序的列表,可以包含多个JSON对象或其他类型的值。
JSON对象是一个无序的键/值对集合,每个键都对应一个值。
当JSON数组或JSON对象嵌套在另一个JSON数组或JSON对象中时,我们就需要使用递归解析。
递归是一种自己调用自己的算法,在处理嵌套数据时非常有用。
例如,假设我们有以下JSON数据:{'name': 'John','age': 30,'cars': [{'model': 'BMW','year': 2018},{'model': 'Mercedes','year': 2019}]}要解析这个JSON数据,我们可以使用以下递归函数:function parseJSON(data) {for(var key in data) {var value = data[key];if(Array.isArray(value)) {// 如果值是一个数组,递归解析数组中的每个元素value.forEach(function(element) {parseJSON(element);});}else if(typeof value === 'object') {// 如果值是一个对象,递归解析对象中的每个键/值对parseJSON(value);}else {// 如果值是一个基本类型,直接输出console.log(key + ': ' + value);}}}使用此函数,我们可以对整个JSON数据进行递归解析。
在每次递归中,我们检查值的类型,并根据需要递归到更深层次的嵌套数据中。
关于java中JSONArray、JSONObject、List、String之间的转换
关于java中JSONArray、JSONObject、List、String之间的转换本⼈最近⼏个⽉才开始JAVA开发⼯作,以前⼀直做的BI开发,转变的过程都是很艰难的。
新产品开发的过程中,由于新⼈,能⼒有限,遇到了N多困难,幸亏有关系很好的同事在旁边加油打⽓。
有好⼏次我悄悄跟同事说,不⾏了,我坚持不下去了,我就不是开发的料,同事每次都劝我开始都是难的,这段时间过去了你会发现其实没那么难。
是啊,就去登泰⼭,站在⼭脚下我就被它的巍峨吓得望⽽却步,那我怎么可能会登顶看到⽇出。
总嘚努⼒了才有放弃的资格。
于是就这样,坚持了⼏个⽉,现在虽然⾃⼰依然是个菜鸟,但是进步还是很⼤。
可能已经爬到了泰⼭的脚背上。
开发过程中很让⼈头疼的就是各种类型之间的转换,⼀开始真是蒙圈,后来⽤了⼏次好点了,赶紧把⾃⼰记得的写下来,怕以后忘了。
⼀、JASSONArray转为JSONObjectJSONArray result_type = new JSONArray();StringBuffer cdsIdxType = new StringBuffer();cdsIdxType.append(" select id from table_type ");result_type = jdbcTemp.queryForJSONArray(cdsIdxType.toString());JSONObject jsonObject = (JSONObject) result_type.get(i);⼆、JASONArray转为ListJSONArray result_type = new JSONArray();StringBuffer cdsIdxType = new StringBuffer();cdsIdxType.append(" select id from table_type ");result_type = jdbcTemp.queryForJSONArray(cdsIdxType.toString());ArrayList list_type = new ArrayList();for (int i = 0; i < result_type.size(); i++) {JSONObject jsonObject = (JSONObject) result_type.get(i);list_type.add(jsonObject.get("id"));}三、JSONArray转为StringJSONArray result_type = new JSONArray();StringBuffer cdsIdxType = new StringBuffer();cdsIdxType.append(" select id from table_type ");result_type = jdbcTemp.queryForJSONArray(cdsIdxType.toString());String typeAll = "";ArrayList list_type = new ArrayList();for (int i = 0; i < result_type.size(); i++) {JSONObject jsonObject = (JSONObject) result_type.get(i);list_type.add(jsonObject.get("id"));}for(int j=0;j<list_type.size();j++){typeAll = typeAll + "'" + list_type.get(j) + "'" + ",";}typeAll = typeAll.substring(0, typeAll.length() -1);四、String转换为ArrayListString tablecode = request.getParameter("tablecode");tablecode = tablecode.substring(1, tablecode.length()-1).replace("\"", "");String[] list = tablecode.split(",");ArrayList tables = new ArrayList();for(int i=0; i<list.length; i++){tables.add(list[i]);}五.String转JSONObjectString jsonMese = "{\"语⽂\":\"88\",\"数学\":\"78\",\"计算机\":\"99\"}";JSONObject myJson = JSONObject.fromObject(jsonMese);六.String转JSONArrayString jsonMessage = "[{'num':'成绩', '外语':88, '历史':65, '地理':99, 'object':{'aaa':'1111','bbb':'2222','cccc':'3333'}}," + "{'num':'兴趣', '外语':28, '历史':45, '地理':19, 'object':{'aaa':'11a11','bbb':'2222','cccc':'3333'}}," + "{'num':'爱好', '外语':48, '历史':62, '地理':39, 'object': {'aaa':'11c11','bbb':'2222','cccc':'3333'}}]";JSONArray myJsonArray = JSONArray.fromObject(jsonMessage);七.String转数组String string = "a,b,c"; String [] stringArr= string.split(","); //注意分隔符是需要转译如果是"abc"这种字符串,就直接String string = "abc" ; char [] stringArr = string.toCharArray(); //注意返回值是char数组如果要返回byte数组就直接使⽤getBytes⽅法就ok了String string = "abc" ; byte [] stringArr = string.getBytes();⼋、数组转Stringchar[] data={a,b,c};String s=new String(data);注:本⽂是通过⾃⼰的总结和总结他⼈经验得出来的结论,学疏才浅如果错误⼤家可以指出并改正。
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中jsonobject的用法
java中jsonobject的用法Java中的JSONObject是一个用于处理JSON数据的类。
JSON(JavaScript Object Notation)是一种用于数据交换的轻量级数据格式,常用于网络传输和存储数据。
通过JSONObject类,我们可以方便地解析和操作JSON数据。
一、导入JSONObject类首先,我们需要导入JSON库中的JSONObject类,即在代码的头部添加以下语句:import org.json.JSONObject;这样,我们就可以在代码中使用JSONObject类了。
二、创建JSONObject对象在Java中,可以通过以下两种方式来创建JSONObject对象:1. 使用字符串创建JSONObject对象可以通过将一个JSON格式的字符串传递给JSONObject类的构造函数,来创建一个JSONObject对象。
例如:String jsonString = "{\"name\":\"John\", \"age\":30, \"city\":\"New York\"}";JSONObject jsonObject = new JSONObject(jsonString);上述代码将创建一个名为jsonObject的JSONObject对象,该对象包含了名为name、age和city的三个属性,对应的值分别为John、30和New York。
2. 使用键值对创建JSONObject对象可以通过逐个添加键值对的方式,来创建一个JSONObject对象。
例如:JSONObject jsonObject = new JSONObject();jsonObject.put("name", "John");jsonObject.put("age", 30);jsonObject.put("city", "New York");上述代码将创建一个名为jsonObject的JSONObject对象,该对象包含了名为name、age和city的三个属性,对应的值分别为John、30和New York。
Java创建和解析Json数据方法——org.json包的使用(转)
Java创建和解析Json数据⽅法——org.json包的使⽤(转)org.json包的使⽤1.简介⼯具包org.json.jar,是⼀个轻量级的,JAVA下的json构造和解析⼯具包,它还包含JSON与XML, HTTP headers, Cookies, CDL的转换。
这篇学习笔记,主要介绍常⽤的⼀些类如:JSONObject、JSONArray、JSONStringer等的⼀些⽤法;介绍了如何将Map、Collection、Java Bean等对象转化为json数据;介绍了如何使⽤org.json包解析json数据等。
2.常⽤类3.构造json的⽰例⽤法3.1 JSONObject.java官⽹给出的JSONObject的构造函数如下:⽐较常⽤就是传⼊String、map或者bean来构造JSON对象,代码例⼦如下:⾸先定义⼀个java bean类:[java]1. package orgjson;2.3. /**4. * 包含getter和setter的java bean类5. * @author Zen96. */7. public class Student {8. private String name;9. private String sex;10. private int age;11.12. public String getName() {13. return name;14. }15. public void setName(String name) {16. = name;17. }18. public String getSex() {19. return sex;20. }21. public void setSex(String sex) {22. this.sex = sex;23. }24. public int getAge() {25. return age;26. }27. public void setAge(int age) {28. this.age = age;29. }30. }然后测试构造⽅法;也可以⽤put⽅法来向JSON对象中添加key/value对,当⽤put⽅法时候,value值可以是int、double、String、、boolean、collection、Map等等,但不可以为bean类型,代码如下:[java]1. package orgjson;4. import java.util.List;5. import java.util.Map;6. import org.json.*;7. public class JsonTest {8. public static void constructorTest() {9.10. String jsonStr = "{'name':'JTZen9','age':21}";11. JSONObject strJson = new JSONObject(jsonStr); // 传⼊字符串12. System.out.println("构造参数为String类:" + strJson);13.14. Map<string object> map = new HashMap<string object>();15. map.put("age", 21);16. map.put("sex", "male");17. map.put("name", "JTZen9");18. JSONObject mapJson = new JSONObject(map); // 传⼊Map类型19. System.out.println("构造参数为Map类:" + mapJson);20.21. Student student = new Student();22. student.setAge(21);23. student.setName("JTZen9");24. student.setSex("male");25. JSONObject beanJson = new JSONObject(student); // 传⼊Bean类型26. System.out.println("构造参数为Bean类:" + beanJson);27. }28.29. public static void putMethodTest() {30.31. JSONObject jsonObject1 = new JSONObject();32. jsonObject1.put("bookName", "JTZen9");33. jsonObject1.put("age", 21);34. System.out.println(jsonObject1);35.36. JSONObject jsonObject2 = new JSONObject();37. List<object> list = new ArrayList</object><object>();38. for (int i = 1; i < 3; i++) {39. Map<string object=""> map = new HashMap<string object="">();40. map.put("title", "java程序设计第" + i + "版");41. map.put("price", i*20);42. list.add(map);43. }44. jsonObject2.put("book", list);45. System.out.println(jsonObject2);46.47. Student student = new Student();48. student.setAge(21);49. student.setName("JTZen9");50. student.setSex("male");51. jsonObject2 = new JSONObject(student);52. JSONObject jsonObject3 = new JSONObject();53. jsonObject3.put("people", jsonObject2); //不可以直接传bean类对象put("people",student)54. System.out.println(jsonObject3);55. }56.57. public static void main(String[] args) throws Exception {58. constructorTest();59. System.out.println("---------------------------------------------------------");60. putMethodTest();61. }62. }输出结果:3.2 JSONArray.java1.构造函数这⾥⽤Collection、String和Object型的array作为参数,给出例⼦如下:[java]1. package orgjson;2. import java.util.ArrayList;3. import java.util.HashMap;4. import java.util.List;5. import java.util.Map;6. import org.json.*;7. public class JsonArrayTest {8. public static void constructorTest() {9.10. String jsonStr = "[{'name':'JTZen9','age':21}]";11. JSONArray strJson = new JSONArray(jsonStr); // 传⼊字符串12. System.out.println("构造参数为String类:" + strJson);13.14. List<Object> list = new ArrayList<Object>();15. for (int i = 1; i < 3; i++) {16. Map<string object=""> map = new HashMap<string object="">();17. map.put("title", "java程序设计第" + i + "版");18. map.put("price", i*20);19. list.add(map);20. }21. JSONArray mapJson = new JSONArray(list); // 传⼊Collection类型22. System.out.println("构造参数为Collection类:" + mapJson);23.24. int[] numlist = new int[10];25. for (int i = 0; i < numlist.length; i++) {26. numlist[i] = i;27. }28. JSONArray arrayJson = new JSONArray(numlist); // 传⼊Array类型,实例129. System.out.println(arrayJson);30.31. Student[] student = {new Student(),new Student()};32. student[0].setAge(21);33. student[0].setName("JTZen9");34. student[0].setSex("male");35. student[1].setAge(21);36. student[1].setName("heiheihei");37. student[1].setSex("female");38. JSONArray beanJson = new JSONArray(student); // 传⼊Array类型,实例239. System.out.println("构造参数为Array类:" + beanJson);40. }41.42. public static void main(String[] args) {43. constructorTest();44. }45. }输出结果如下:2.put⽅法创建put⽅法中可以直接将int、double、Collection、Map等加进去,也可以添加下标来指定添加的位置:put(int index, java.util.Map value),使⽤put⽅法构造的JSON数组,如果传⼊的是数组,都会⾃动加⼀对中括号[ ],那么出来的结果就会有两层的中括号[ ],代码例⼦如下:[java]1. package orgjson;2. import java.util.HashMap;3. import java.util.Map;4. import org.json.*;5. public class JSONArrayTest {6. public static void putMethodTest() {7. JSONArray jsonArray1 = new JSONArray();8. jsonArray1.put("JTZen9");11. System.out.println(jsonArray1);12.13. JSONArray jsonArray2 = new JSONArray();14. Map<string object=""> map = new HashMap<string object="">();15. map.put("title", "java程序设计第2版");16. map.put("price", 20);17. jsonArray2.put(map); //传⼊⼀个map18. System.out.println("传⼊⼀个Map:" + jsonArray2);19. map.clear();20. map.put("title", "java程序设计第3版");21. map.put("price", 30);22. jsonArray2.put(map); //没有下标的直接在结果后⾯添加23. System.out.println("没有指定下标:" + jsonArray2);24. map.clear();25. map.put("title", "java程序设计第1版");26. map.put("price", 10);27. jsonArray2.put(0,map); //使⽤下标可以添加到⾃定义的位置28. System.out.println("添加到第⼀个位置:" + jsonArray2);29.30. Student[] student = { new Student(), new Student() };31. student[0].setAge(21);32. student[0].setName("JTZen9");33. student[0].setSex("male");34. student[1].setAge(21);35. student[1].setName("heiheihei");36. student[1].setSex("female");37. JSONArray jsonArray3 = new JSONArray();38. jsonArray3.put(student);39. System.out.println("注意输出结果:" + jsonArray3);40.41. }42.43. public static void main(String[] args) {44. putMethodTest();45. }46. }输出的结果如下:3.3 JSONStringer.java & JSONWriter.java①JSONWriter可以⽤来构建⼀个JSON格式的⽂本,并转换成String,可以写⼊⽂件,便于传输和存储。
jsonobject 使用
jsonobject 使用JSON,全称JavaScript Object Notation,是一种轻量级的数据交换格式,它有着简洁易懂的语法,是开发者采用的首选。
JSONObject是一个易于使用的JavaScript来操作Json的库,它具有灵活的操作性以及方便的使用方式,可以极大的提高开发效率和提升开发体验。
JSONObject非常容易上手,你可以使用JSONObject(json)的方式来创建一个新的JSONObject实例,参数json可以是一个JSON字符串或者是一个JSONObject实例,这样就可以实现快速进行JSON 对象复制等操作。
你可以使用put(key, value)这个方法来向JSONObject中添加简单类型的数据,例如字符串、布尔值、数字等,也可以直接添加JSONObject或者JSONArray对象,这就可以实现构造复杂嵌套数据结构。
JSONObject可以满足你很多数据转换的需求,可以使用toString()方法将JSONObject实例转换成JSON字符串,也可以使用toJSONObject()方法将JSONObject实例转换成Java的Map实例,反之也可以使用fromObject()方法将Java的Map实例转换成JSONObject实例。
JSONObject可以使用has(key)方法来判断某个对象是否存在,使用get(key)方法来获取JSONObject中的数据,如果数据 value 一个 JSONArray例,则可以使用optJSONArray(key)方法来获取,以此类推,JSONObject还提供了其他各种数据类型的获取方法,也可以使用getNames()方法来获取JSONObject中key值列表。
JSONObject提供了多种数据遍历的方法,可以使用keys()方法获取JSONObject中所有key值,可以使用forEach()方法遍历JSONObject实例,可以使用getValues()方法获取所有的value 值,也可以使用toList()方法将JSONObject实例转换成java的List实例,从而实现集合的操作,更多的用法你可以参考官方文档和源码,里面有它最详细的说明。
java 的jsonarray 的方法
java 的jsonarray 的方法JSON数组(JSONArray)在Java编程中常用于处理数据结构。
本文将详细介绍Java中JSONArray的相关方法,帮助读者更好地理解并运用这一数据类型。
### Java的JSONArray方法在Java中,`JSONArray`类是`json`包的一部分,通常与`JSONObject`一起使用,用于处理JSON数据。
以下是JSONArray的一些常用方法:1.**构造方法**- `JSONArray()`: 创建一个空的JSONArray对象。
- `JSONArray(JSONObject object)`: 创建一个包含指定JSONObject 的JSONArray对象。
2.**添加元素**- `put(Object value)`: 将一个值添加到JSONArray末尾。
- `put(int index, Object value)`: 在指定的索引位置插入一个值。
3.**获取元素**- `get(int index)`: 获取指定索引位置的元素。
- `opt(int index)`: 获取指定索引位置的元素,如果索引超出范围,则返回null。
4.**查询元素**- `isNull(int index)`: 检查指定索引位置的元素是否为null。
- `getBoolean(int index)`: 获取指定索引位置的元素作为布尔值。
- `getDouble(int index)`: 获取指定索引位置的元素作为双精度浮点数。
- `getInt(int index)`: 获取指定索引位置的元素作为整数。
- `getLong(int index)`: 获取指定索引位置的元素作为长整数。
5.**修改元素**- `remove(int index)`: 移除指定索引位置的元素。
- `set(int index, Object value)`: 设置指定索引位置的元素值。
jsonobject遍历方法
jsonobject遍历方法json 是一种数据交换格式,常用于存储和传输数据。
在 Java 中,可以使用 JSONObject 类来操作 JSON 数据。
JSONObject 是一种键值对的数据结构,可以动态添加、删除和修改键值对。
在遍历 JSONObject 对象时,可以使用不同的方法来获取键值对的信息。
方法一:使用 keySet( 方法遍历JSONObject对象keySet( 方法返回 JSONObject 对象中所有键的集合,可以通过遍历键集合来获取键值对的信息。
以下是使用 keySet( 方法遍历 JSONObject 对象的示例代码:```JSONObject jsonObject = new JSONObject(jsonString);Set<String> keys = jsonObject.keySet(;for (String key : keys)Object value = jsonObject.get(key);System.out.println("Key: " + key + " Value: " + value);```方法二:使用 entrySet( 方法遍历JSONObject对象entrySet( 方法返回 JSONObject 对象中所有键值对的集合,可以通过遍历键值对集合来获取键值对的信息。
以下是使用 entrySet( 方法遍历 JSONObject 对象的示例代码:JSONObject jsonObject = new JSONObject(jsonString);Set<Map.Entry<String, Object>> entries =jsonObject.entrySet(;for (Map.Entry<String, Object> entry : entries)String key = entry.getKey(;Object value = entry.getValue(;System.out.println("Key: " + key + " Value: " + value);```方法三:使用 Iterator 遍历 JSONObject 对象除了使用 keySet( 或 entrySet( 方法,还可以使用 Iterator 迭代器遍历 JSONObject 对象。
JSONObject与JSONArray,转换为字符串
JSONObject与JSONArray,转换为字符串public class TestArrayToList {public static void main(String[] args) {// TODO Auto-generated method stub// 数组转换为集合Array to List 将字符串数组转换为集合String[] arr = new String[5];arr[0] = "a";arr[1] = "b";arr[2] = "c";arr[3] = "d";arr[4] = "e";List<String> list = new ArrayList<String>();list = Arrays.asList(arr);// 将集合转换为数组List<String> testList = new ArrayList<String>();testList.add("A");testList.add("B");testList.add("C");testList.add("D");testList.add("E");Object[] objects = testList.toArray();// 循环遍历数组,获取到数组⾥⾯的值String objectString = "";for (int o = 0; o < objects.length; o++) {objectString += objects[o].toString();}System.out.println("objectString:" + objectString);// 将list转换为字符串String listString = "";for (int i = 0; i < list.size(); i++) {listString += list.get(i);}System.out.println("listString:" + listString);// 将数组转换为字符串String arrString = StringUtils.join(arr);System.out.println("arrString:" + arrString);// 对象数组转换为对象集合 JSONArray JSOBObject之间的关系 JSONObject相当于是⼀个对象,JAONArray就是⼀个对象数组// 1.通过JSONObject将String 转换为实体类Size s = JSONObject.parseObject("{page:123,size:456}", Size.class);System.out.println("s.getPage():" + s.getPage());System.out.println("s.getSize():" + s.getSize());// 对象数组JSONArray array = JSONArray.parseArray("[{page:123,size:456},{page:112233,size:445566},{page:111222333,size:444555666}]"); System.out.println("array:" + array);for (int i = 0; i < array.size(); i++) {JSONObject object = (JSONObject) array.get(i);System.out.println("object:" + object);StringBuilder sb = new StringBuilder();sb.append(object.get("size")).append(",").append(object.get("page"));System.out.println("sb:" + sb);}// ⼀维对象数组转换为list的情况// Size s1 = JSONObject.parseObject("[{page:123,size:456},{page:123,size:456},{page:123,size:456}]", Size.class);JSONArray jsonArray1 = JSONArray.parseArray("[{page:123,size:456},{page:123,size:456},{page:123,size:456}]");// 把String转换为json // 将JSONArray 转换为listString jsonStr = JSONObject.toJSONString(jsonArray1);List<String> aList = JSONObject.parseArray(jsonStr, String.class);// 把list转换为StringString str4 = StringUtils.join(aList, ",");System.out.println("str4:" + str4);// ⼆维数组转换为list的情况String string1 = "[[110121,110102,210120],[110121,110102,210120]]";JSONArray jsonArray2 = JSONArray.parseArray(string1);// 把String转换为jsonString jsonStr1 = JSONObject.toJSONString(jsonArray2);List<List> aList1 = JSONObject.parseArray(jsonStr1, List.class);String str5 = "";for (int a = 0; a < aList1.size(); a++) {str5 += StringUtils.join(aList1.get(a), ",") + (a == aList1.size() - 1 ? "" : "-");}System.out.println("str5:" + str5);}控制台输出:objectString:ABCDElistString:abcdearrString:abcdes.getPage():123s.getSize():456array:[{"size":456,"page":123},{"size":445566,"page":112233},{"size":444555666,"page":111222333}] object:{"size":456,"page":123}sb:456,123object:{"size":445566,"page":112233}sb:445566,112233object:{"size":444555666,"page":111222333}sb:444555666,111222333str4:{"size":456,"page":123},{"size":456,"page":123},{"size":456,"page":123}str5:110121,110102,210120-110121,110102,210120。
Java使用fastjson对String、JSONObject、JSONArray相互转换
Java使⽤fastjson对String、JSONObject、JSONArray相互转换⽬录fastjson对String、JSONObject、JSONArray相互转换com.alibaba.fastjson.JSONObject、JSONArray与String之间的转换demofastjson对String、JSONObject、JSONArray相互转换fastjson是阿⾥巴巴的开源JSON解析库,它可以解析JSON格式的字符串,⽀持将Java Bean序列化为JSON字符串,也可以从JSON字符串反序列化到JavaBean下⾯主要是本⼈在⼯作中经常⽤到的关于String、JSONObject、JSONArray的相互装换String——>>>JSONArrayString st = "[{name:Tim,age:25,sex:male},{name:Tom,age:28,sex:male},{name:Lily,age:15,sex:female}]";JSONArray tableData = JSONArray.parseArray(st);JSONArray——>>>JSONObjectJSONObject rowData = new JSONObject();for(int i;i<tableData.length();i++){rowData = tableData.getJSONObject[i];}String——>>>JSONObjectString st = "{name:Tim,age:25,sex:male}";JSONObject rowData = JSONObject.parseObject(st);JSONObject——>>>JSONArrayJSONObject rowData = {info:[{name:Tim,age:25,sex:male},{name:Tom,age:28,sex:male},{name:Lily,age:15,sex:female}]};JSONArry tableData = rowData.get("info");com.alibaba.fastjson.JSONObject、JSONArray与String之间的转换demo话不多说,直接上代码import com.alibaba.fastjson.JSON;import com.alibaba.fastjson.JSONArray;import com.alibaba.fastjson.JSONObject;import java.util.Map;/*** Created by LH on 2019/2/21 14:08*/public class JsonDemo {public static void main(String[] args) {//1.json字符串转换为对象String jsonString="{'name':'42313123','id':'2345','age':12}";JSONObject jsonObject = JSONObject.parseObject(jsonString);String id = jsonObject.getString("id");System.out.println(id);//2. JSONObject转化成⾃定义类对象PeoplePo peoplePo1 = JSONObject.parseObject(jsonString, PeoplePo.class);System.out.println(peoplePo1);//3. JSONObject转化成Map集合Map map = JSONObject.parseObject(jsonString, Map.class);System.out.println(map);//4. ⾃定义对象转化成json格式的字符串PeoplePo peoplePo = new PeoplePo();peoplePo.setId("1");peoplePo.setAge(11);peoplePo.setName("LH");String peopleJson = JSON.toJSONString(peoplePo);System.out.println(peopleJson);//5. String类型转化成JSONObject;String str = "{\"result\":\"success\",\"message\":\"成功!\"}";JSONObject jsonObject1 = JSONObject.parseObject(str);System.out.println(jsonObject1);//6. JSONObject转化成JSONArray的两种⽅式String str1 = "{\"result\":\"success\",\"message\":\"成功!\",\"data\":[{\"name\":\"Tom\",\"age\":\"20\"}]}"; JSONObject jsonToArray = JSONObject.parseObject(str1);//⽅式⼀JSONArray data = jsonToArray.getJSONArray("data");System.out.println(data);//⽅式⼆JSONArray jsonArray = JSONArray.parseArray(jsonToArray.getString("data"));System.out.println(jsonArray);//7. jsonArray转化成JSONObject并取出其中的元素数据JSONObject o = (JSONObject) jsonArray.get(0);String name = o.getString("name");System.out.println(o);System.out.println(name);System.out.println(jsonArray.toString());}}以上为个⼈经验,希望能给⼤家⼀个参考,也希望⼤家多多⽀持。
jsonobject 用法
jsonobject 用法JSONObject是一个java类,它提供了一种简单而灵活的方法来处理JSON数据。
它可以用来解析JSON数据,也可以用来创建新的JSON数据对象。
JSON数据是一种轻量级的数据格式,它是一种文本格式,非常易于阅读和编写。
以下是JSONObject的主要用法:1. 创建JSONObject对象创建JSONObject对象有两种方式:第一种是使用无参构造函数,第二种是使用带有JSON字符串参数的构造函数。
例如:JSONObject jsonObject = new JSONObject();JSONObject jsonObject = new JSONObject('{'name':'张三','age':18}');2. 添加键值对添加键值对可以使用put()方法,其中键是一个字符串,值可以是一个JSONObject、JSONArray、字符串、数字、布尔值或空值。
例如:jsonObject.put('name', '张三');jsonObject.put('age', 18);jsonObject.put('address', new JSONObject('{'province':'广东','city':'深圳'}'));3. 获取键值对获取JSONObject对象中的键值对可以使用get()方法,其中键是一个字符串,返回值可以是一个JSONObject、JSONArray、字符串、数字、布尔值或空值。
例如:String name = jsonObject.getString('name');int age = jsonObject.getInt('age');JSONObject address =jsonObject.getJSONObject('address');4. 判断是否包含某个键判断JSONObject对象是否包含某个键可以使用has()方法,其中键是一个字符串。
jsonobject 用法
jsonobject 用法JSON是一种轻量级的数据交换格式,与XML类似,但更加简单易用。
而JSONObject是Java语言中的一个类,位于org.json包中,用于创建和处理JSON对象。
它提供了一系列的方法来操作和处理JSON数据。
本文将介绍JSONObject的用法。
1. 创建JSONObject对象创建JSONObject对象的方式有两种:手动创建和解析已有JSON字符串。
手动创建方式如下:```JSONObject obj = new JSONObject();obj.put("name", "张三");obj.put("age", 18);obj.put("gender", "男");```在上述例子中,通过put()方法将属性名和属性值添加到JSONObject 对象中。
解析已有JSON字符串的方式如下:String jsonStr = "{\"name\":\"张三\",\"age\":18,\"gender\":\"男\"}";JSONObject obj = new JSONObject(jsonStr);```在上述例子中,通过JSONObject构造器将JSON字符串转化为JSONObject对象。
2. 获取JSONObject对象中的值通过get()方法获取JSONObject对象中指定属性名的属性值。
例如,obj.get("name")将返回字符串型的"张三"。
3. 将JSONObject对象转化为JSON字符串调用JSONObject对象的toString()方法,将JSONObject对象转化为标准的JSON字符串。
jsonobject 用法
jsonobject 用法JSONObject是一种用于处理JSON数据的Java类。
它可以将JSON 格式的字符串转换为Java对象,也可以将Java对象转换为JSON格式的字符串。
使用JSONObject可以更方便地处理JSON数据。
使用JSONObject的第一步是创建一个JSONObject对象。
可以通过以下代码创建一个JSONObject对象:```JSONObject jsonObj = new JSONObject();```创建JSONObject对象之后,可以使用put方法向JSONObject对象添加键值对。
例如,可以使用以下代码将一个字符串和一个整数添加到JSONObject对象中:```jsonObj.put('name', 'John');jsonObj.put('age', 25);```JSONObject对象也可以从JSON格式的字符串中创建。
例如,可以使用以下代码从一个JSON格式的字符串中创建一个JSONObject对象:```String jsonString = '{'name':'John','age':25}';JSONObject jsonObj = new JSONObject(jsonString);```使用get方法可以从JSONObject对象中获取指定键的值。
例如,可以使用以下代码获取JSONObject对象中'name'键对应的值:```String name = jsonObj.getString('name');```除了getString方法,JSONObject还提供了许多其他的get方法,如getInt、getDouble、getBoolean等,可根据键的值类型进行选择。
JSONObject对象还可以嵌套。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
Java不像PHP解析和生产JSON总是一个比较痛苦的过程。
但是使用JSONObject和JSONArray会让整个过程相对舒服一些。
需要依赖的包:commons-lang.jar commons-beanutils.jar commons-collections.jar commons-logging.jar ezmorph.jar json-lib-2.2.2-jdk15.jar
1. 创建一个JSONObject对象:
package .video.resource.controller.web;
import java.util.ArrayList;
import java.util.HashMap;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
public class Test {
public static void main(String[] args) {
//JsonObject和JsonArray区别就是JsonObject是对象形式,JsonArray是数组形式 //创建JsonObject第一种方法
JSONObject jsonObject = new JSONObject();
jsonObject.put("UserName", "ZHULI");
jsonObject.put("age", "30");
jsonObject.put("workIn", "ALI");
System.out.println("jsonObject1:" + jsonObject);
//创建JsonObject第二种方法
HashMap<String, String> hashMap = new HashMap<String, String>();
hashMap.put("UserName", "ZHULI");
hashMap.put("age", "30");
hashMap.put("workIn", "ALI");
System.out.println("jsonObject2:" + JSONObject.fromObject(hashMap));
//创建一个JsonArray方法1
JSONArray jsonArray = new JSONArray();
jsonArray.add(0, "ZHULI");
jsonArray.add(1, "30");
jsonArray.add(2, "ALI");
System.out.println("jsonArray1:" + jsonArray);
//创建JsonArray方法2
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("ZHULI");
arrayList.add("30");
arrayList.add("ALI");
System.out.println("jsonArray2:" + JSONArray.fromObject(arrayList));
//如果JSONArray解析一个HashMap,则会将整个对象的放进一个数组的值中
System.out.println("jsonArray FROM HASHMAP:" +
JSONArray.fromObject(hashMap));
//组装一个复杂的JSONArray
JSONObject jsonObject2 = new JSONObject();
jsonObject2.put("UserName", "ZHULI");
jsonObject2.put("age", "30");
jsonObject2.put("workIn", "ALI");
jsonObject2.element("Array", arrayList);
System.out.println("jsonObject2:" + jsonObject2);
}
}
结果:
jsonObject1:{"UserName":"ZHULI","age":"30","workIn":"ALI"}
jsonObject2:{"workIn":"ALI","age":"30","UserName":"ZHULI"}
jsonArray1:["ZHULI","30","ALI"]
jsonArray2:["ZHULI","30","ALI"]
jsonArray FROM HASHMAP:[{"workIn":"ALI","age":"30","UserName":"ZHULI"}] jsonObject2:{"UserName":"ZHULI","age":"30","workIn":"ALI","Array":["ZHULI","30","ALI"]}
解析JSON字符串:
package .video.resource.controller.web;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
public class Test {
public static void main(String[] args) {
String jsonString =
"{\"UserName\":\"ZHULI\",\"age\":\"30\",\"workIn\":\"ALI\",\"Array\":[\"ZHULI\",\"3 0\",\"ALI\"]}";
//将Json字符串转为java对象
JSONObject obj = JSONObject.fromObject(jsonString);
//获取Object中的UserName
if (obj.has("UserName")) {
System.out.println("UserName:" + obj.getString("UserName"));
}
//获取ArrayObject
if (obj.has("Array")) {
JSONArray transitListArray = obj.getJSONArray("Array");
for (int i = 0; i < transitListArray.size(); i++) {
System.out.print("Array:" + transitListArray.getString(i) + " "); }
}
}
}
返回:
UserName:ZHULI
Array:ZHULI Array:30 Array:ALI。