JSONObject、JSONArray

25-03-21 8

对于想了解JSONObject、JSONArray的读者，本文将是一篇不可错过的文章，并且为您提供关于011-JSON、JSONObject、JSONArray使用、JSON数组形式字符串转换为Lis

对于想了解JSONObject、JSONArray的读者，本文将是一篇不可错过的文章，并且为您提供关于011-JSON、JSONObject、JSONArray使用、JSON数组形式字符串转换为List>的8种方法、Android Volley POST JsonObject并获取JsonArray或JsonObject或其他响应、Fastjson, Gson, org.json.JSON三者对于JSONObject及JSONArray的判断、FastJSON--Java对象、集合转换成JSONObject、JSONArray的有价值信息。

本文目录一览：

JSONObject、JSONArray
011-JSON、JSONObject、JSONArray使用、JSON数组形式字符串转换为List>的8种方法
Android Volley POST JsonObject并获取JsonArray或JsonObject或其他响应
Fastjson, Gson, org.json.JSON三者对于JSONObject及JSONArray的判断
FastJSON--Java对象、集合转换成JSONObject、JSONArray

JSONObject、JSONArray

最近两个星期接触最多的就是json和map了。

之前用到的json，就是一个键对应一个值，超级简单的一对一关系。现在用到的json那可以层层嵌套啊，刚开始接触的时候，确实有种崩溃的赶脚，不想去理，取个数据还那么麻烦。其实，就跟if else语句一样，如果if中套if，if中再套if，写的规范了还行，要是代码格式不规范，那我们肯定也看着麻烦。所以啊，对于json嵌套，只要记住符号“：”前是键，符号后是值大括号成对找，一层层剥开，就清楚了。举个例子说明，如下：

从外到里看，例子中就是一个数组，数组里面是两个json格式的字符串。这样分析思路就清晰多了。

工作中需要取出name4的值，你们会怎么取呢？。最初我都想过字符串截取，那时还不了解JSONArray，现在知道了，取出来也就相当容易了。

取出name4值过程步骤：1，将以上字符串转换为JSONArray对象；2，取出对象的第一项，JSONObject对象；3，取出name1的值JSONObject对象；4，取出name2的值JSONObject对象；5，取出name4的值value2。

示例中json数组格式的字符串可以通过方法直接转换为JSONArray的格式:JSONArray.fromObject(String)

[java] view plain copy print ?

</pre><prename="code"class="java">JSONArraygetJsonArray=JSONArray.fromObject(arrayStr);//将结果转换成JSONArray对象的形式
JSONObjectgetJsonObj=getJsonArray.getJSONObject(0);//获取json数组中的第一项
Stringresult=getJsonObj.getJSONObject("name1").getJSONObject("name2").getJSONObject("name4");

好了我们说说这两个对象。

1，JSONObject

json对象，就是一个键对应一个值，使用的是大括号{ }，如：{key:value}

2，JSONArray

json数组，使用中括号[ ],只不过数组里面的项也是json键值对格式的

Json对象中添加的是键值对，JSONArray中添加的是Json对象

011-JSON、JSONObject、JSONArray使用、JSON数组形式字符串转换为List<Map<String,String>>的8种方法

011-JSON、JSONObject、JSONArray使用、JSON数组形式字符串转换为List>的8种方法

一、JSON数据格式

1.1、常用JSON数据格式

　　1、对象方式：JSONObject的数据是用 { } 来表示的，

　　例如： { "id" : "123", "courseID" : "huangt-test", "title" : "提交作业", "content" : null }

　　2、数组方式：JSONArray，顾名思义是由JSONObject构成的数组，用 [ { } , { } , ...... , { } ] 来表示

　　例如：[ { "id" : "123", "courseID" : "huangt-test", "title" : "提交作业" } , { "content" : null, "beginTime" : 1398873600000 "endTime" } ] ；

　　表示了包含2个JSONObject的JSONArray。

1.2、JSON、JSONObject、JSONArray使用

对象/数组	toJSONString	parse	parseObject	parseArray
JSON	对象/数组	数据是对象时，返回：JSONObject的Object 数据是数组时，返回：JSONArray的Object	对象	数组
JSONObject	对象/数组	数据是对象时，返回：JSONObject的Object 数据是数组时，返回：JSONArray的Object	对象	数组
JSONArray	对象/数组	数据是对象时，返回：JSONObject的Object 数据是数组时，返回：JSONArray的Object	对象	数组

　　parseObject：泛型实现返回具体bean；非泛型实现返回 JSONObject

　　parseArray：泛型实现返回具体List<bean>；非泛型实现返回 JSONArray<JSONObject>

　　parse：相当于parseObject和parseArray的非泛型实现

工具类Person

public class Person {
    private String name;
    private Integer age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }

    @Override
    public String toString() {
        return "Person{" +
                "name=''" + name + ''\'''' +
                ", age=" + age +
                ''}'';
    }
}

View Code

1.2.1、数据是对象方式测试【parseObject】

/**
 * 数据是 对象 测试
 */
public class ObjectJsonTest {

    @Test
    public void testtoJSONString(){
        Person person = new Person("aa", 1);
        String s1 = JSON.toJSONString(person);
        System.out.println(s1);
        String s2 = JSONObject.toJSONString(person);
        System.out.println(s2);
        String s3 = JSONArray.toJSONString(person);
        System.out.println(s3);
    }

    @Test
    public void testparseObject(){
        Person person = new Person("aa", 1);
        String s1 = JSON.toJSONString(person);
        System.out.println(s1);

        Person p1 = JSON.parseObject(s1, Person.class);
        JSONObject jsonObject = JSON.parseObject(s1);
        System.out.println(p1);
        Person p2 =  JSONObject.parseObject(s1, Person.class);
        System.out.println(p2);
        Person p3 =  JSONArray.parseObject(s1, Person.class);
        System.out.println(p3);
    }

    /**
     * 失败
     */
    @Test
    public void testparseArray(){
        Person person = new Person("aa", 1);
        String s1 = JSON.toJSONString(person);
        System.out.println(s1);

        //失败：转数组 必须是 list
        List<Person> p1 = JSON.parseArray(s1, Person.class);
        System.out.println(p1);
        //失败：转数组 必须是 list
        List<Person> p2 =  JSONObject.parseArray(s1, Person.class);
        System.out.println(p2);
        //失败：转数组 必须是 list
        List<Person> p3 =  JSONArray.parseArray(s1, Person.class);
        System.out.println(p3);
    }
}

View Code

1.2.2、数据是数组方式测试【parseArray】

/**
 * 数据是 数组 测试
 */
public class ArrayJsonTest {

    @Test
    public void testtoJSONString(){
        Person person = new Person("aa", 1);
        List<Person> list =new ArrayList<>();
        list.add(person);

        String s1 = JSON.toJSONString(list);
        System.out.println(s1);
        String s2 = JSONObject.toJSONString(list);
        System.out.println(s2);
        String s3 = JSONArray.toJSONString(list);
        System.out.println(s3);
    }

    //失败
    @Test
    public void testparseObject(){
        Person person = new Person("aa", 1);
        List<Person> list =new ArrayList<>();
        list.add(person);

        String s1 = JSON.toJSONString(list);
        System.out.println(s1);

        //失败：转对象 必须是 {}
        Person p1 = JSON.parseObject(s1, Person.class);
        System.out.println(p1);
        //失败：转对象 必须是 {}
        Person p2 =  JSONObject.parseObject(s1, Person.class);
        System.out.println(p2);
        //失败：转对象 必须是 {}
        Person p3 =  JSONArray.parseObject(s1, Person.class);
        System.out.println(p3);
    }

    @Test
    public void testparseArray(){
        Person person = new Person("aa", 1);
        List<Person> list =new ArrayList<>();
        list.add(person);

        String s1 = JSON.toJSONString(list);
        System.out.println(s1);

        List<Person> p1 = JSON.parseArray(s1, Person.class);
        System.out.println(p1);
        List<Person> p2 =  JSONObject.parseArray(s1, Person.class);
        System.out.println(p2);
        List<Person> p3 =  JSONArray.parseArray(s1, Person.class);
        System.out.println(p3);
    }
}

View Code

1.2.3、非泛型示例【主要是parseObject、parseArray以及parse】

/**
 * 非泛型示例
 */
public class JSONObjectJsonTest {

    //数据是 对象
    @Test
    public void testparseObject1(){
        Person person = new Person("aa", 1);
        String s1 = JSON.toJSONString(person);
        System.out.println(s1);

        JSONObject p1 = JSON.parseObject(s1);
        System.out.println(p1);
        System.out.println(p1.getString("name"));
        JSONObject p2 =  JSONObject.parseObject(s1);
        System.out.println(p2);
        JSONObject p3 =  JSONArray.parseObject(s1);
        System.out.println(p3);
    }

    //数据是 对象
    @Test
    public void testparseObject2(){
        Person person = new Person("aa", 1);
        String s1 = JSON.toJSONString(person);
        System.out.println(s1);

        Object p1 = JSON.parse(s1);
        System.out.println(p1.getClass());
        System.out.println(p1);

        Object p2 =  JSONObject.parse(s1);
        System.out.println(p2.getClass());
        System.out.println(p2);

        Object p3 =  JSONArray.parse(s1);
        System.out.println(p3.getClass());
        System.out.println(p3);
    }

    //数据是 数组
    @Test
    public void testparseArray1(){
        Person person = new Person("aa", 1);
        List<Person> list =new ArrayList<>();
        list.add(person);

        String s1 = JSON.toJSONString(list);
        System.out.println(s1);

        JSONArray p1 = JSON.parseArray(s1);
        System.out.println(p1);
        JSONArray p2 =  JSONObject.parseArray(s1);
        System.out.println(p2);
        JSONArray p3 =  JSONArray.parseArray(s1);
        System.out.println(p3);
    }

    //数据是 数组
    @Test
    public void testparseArray2(){
        Person person = new Person("aa", 1);
        List<Person> list =new ArrayList<>();
        list.add(person);

        String s1 = JSON.toJSONString(list);
        System.out.println(s1);

        JSONArray p1 = (JSONArray)JSON.parse(s1);
        System.out.println(p1.getClass());
        System.out.println(p1);

        Object p2 =  JSONObject.parse(s1);
        System.out.println(p2.getClass());
        System.out.println(p2);

        Object p3 =  JSONArray.parse(s1);
        System.out.println(p3.getClass());
        System.out.println(p3);
    }
}

View Code

二、JSON数组形式字符串转换为List<Map<String,String>>的8种方法

public class JsonToLIstMapTest {
    String strArr = "[{\"0\":\"zhangsan\",\"1\":\"lisi\",\"2\":\"wangwu\",\"3\":\"maliu\"}," +
            "{\"00\":\"zhangsan\",\"11\":\"lisi\",\"22\":\"wangwu\",\"33\":\"maliu\"}]";
    @Test
    public void test(){
        //第一种方式
        List<Map<String,String>> listObjectFir = (List<Map<String,String>>) JSONArray.parse(strArr);
        System.out.println("1、利用JSONArray中的parse方法来解析json数组字符串");//com.alibaba.fastjson.JSONObject
        System.out.println("类型："+listObjectFir.get(0).getClass());
        for(Map<String,String> mapList : listObjectFir){
            for (Map.Entry entry : mapList.entrySet()){
                System.out.println( entry.getKey()  + "  " +entry.getValue());
            }
        }
        //第二种方式
        List<Map<String,String>> listObjectSec = JSONArray.parseObject(strArr,List.class);
        System.out.println("2、利用JSONArray中的parseObject方法并指定返回类型来解析json数组字符串");//com.alibaba.fastjson.JSONObject
        System.out.println("类型："+listObjectSec.get(0).getClass());
        for(Map<String,String> mapList : listObjectSec){
            for (Map.Entry entry : mapList.entrySet()){
                System.out.println( entry.getKey()  + "  " +entry.getValue());
            }
        }
        //第三种方式
        JSONArray listObjectThir = JSONArray.parseArray(strArr);
        System.out.println("3、利用JSONArray中的parseArray方法来解析json数组字符串");
        System.out.println("类型："+listObjectThir.get(0).getClass());//com.alibaba.fastjson.JSONObject
        for(Object mapList : listObjectThir){
            for (Object entry : ((Map)mapList).entrySet()){
                System.out.println(((Map.Entry)entry).getKey()  + "  " +((Map.Entry)entry).getValue());
            }
        }
        //第四种方式
        List listObjectFour = JSONArray.parseArray(strArr,Map.class);
        System.out.println("4、利用JSONArray中的parseArray方法并指定返回类型来解析json数组字符串");
        System.out.println("类型："+listObjectFour.get(0).getClass());//java.util.HashMap
        for(Object mapList : listObjectFour){
            for (Object entry : ((Map)mapList).entrySet()){
                System.out.println(((Map.Entry)entry).getKey()  + "  " +((Map.Entry)entry).getValue());
            }
        }
        //第五种方式
        JSONArray listObjectFifth = JSONObject.parseArray(strArr);
        System.out.println("5、利用JSONObject中的parseArray方法来解析json数组字符串");
        System.out.println("类型："+listObjectFifth.get(0).getClass());//com.alibaba.fastjson.JSONObject
        for(Object mapList : listObjectFifth){
            for (Object entry : ((Map)mapList).entrySet()){
                System.out.println(((Map.Entry)entry).getKey()  + "  " +((Map.Entry)entry).getValue());
            }
        }
        //第六种方式
        List listObjectSix = JSONObject.parseArray(strArr,Map.class);
        System.out.println("6、利用JSONObject中的parseArray方法并指定返回类型来解析json数组字符串");
        System.out.println("类型："+listObjectSix.get(0).getClass());//java.util.HashMap
        for(Object mapList : listObjectSix){
            for (Object entry : ((Map)mapList).entrySet()){
                System.out.println(((Map.Entry)entry).getKey()  + "  " +((Map.Entry)entry).getValue());
            }
        }
        //第七种方式
        JSONArray listObjectSeven = JSON.parseArray(strArr);
        System.out.println("7、利用JSON中的parseArray方法来解析json数组字符串");
        System.out.println("类型："+listObjectSeven.get(0).getClass());//com.alibaba.fastjson.JSONObject
        for(Object mapList : listObjectSeven){
            for (Object entry : ((Map)mapList).entrySet()){
                System.out.println(((Map.Entry)entry).getKey()  + "  " +((Map.Entry)entry).getValue());
            }
        }
        //第八种方式
        List listObjectEigh = JSONObject.parseArray(strArr,Map.class);
        System.out.println("8、利用JSON中的parseArray方法并指定返回类型来解析json数组字符串");
        System.out.println("类型："+listObjectEigh.get(0).getClass());//java.util.HashMap
        for(Object mapList : listObjectEigh){
            for (Object entry : ((Map)mapList).entrySet()){
                System.out.println(((Map.Entry)entry).getKey()  + "  " +((Map.Entry)entry).getValue());
            }
        }
    }
}

Android Volley POST JsonObject并获取JsonArray或JsonObject或其他响应

在齐射中,我们具有从服务器检索数据的能力,例如jsonObject,jsonArray和String.在以下示例中,我们可以从服务器获取jsonObject或jsonArray响应,

public static void POST(HashMap<String, String> params, final Listeners.ServerResponseListener listener) {
    JsonObjectRequest req1 = new JsonObjectRequest(ApplicationController.URL, new JSONObject(params),
            new Response.Listener<JSONObject>() {
                @Override
                public void onResponse(JSONObject response) {
                    Log.e("Response:", response.toString());
                    if (listener != null)
                        listener.onResultJsonObject(response);
                    else
                        Log.e(TAG,"Error: SetServerResponse interface not set");
                }
            }, new Response.ErrorListener() {
        @Override
        public void one rrorResponse(VolleyError error) {
            Log.e("Error: ", error.getMessage());
        }
    });
    ApplicationController.getInstance().addToRequestQueue(req1);
}

我的问题是我想从此方法发送jsonObject并从服务器获取jsonArray或jsonObject,而我无法使用此方法简单地从服务器获取数组.例如,我必须对此jsonObject进行过滤服务器响应：

HashMap<String, String> params = new HashMap<String, String>();
params.put("token", "AbCdEfGh123456");
params.put("search_count", "10");
params.put("order_by", "id");

服务器返回jsonArray并且我无法通过Volley响应得到它

解决方法:

查看JsonArrayRequest的源代码.有一个构造函数,它接收JSONObject.你应该检查一下

Fastjson, Gson, org.json.JSON三者对于JSONObject及JSONArray的判断

1.Fastjson

我们通常在已知格式的情况下直接使用JSONObject,JSONArray，但是如果遇到需要判断格式呢？

       try{
            Object object = JSON.parse(a);
            if (object instanceof JSONObject){
                //JSONObject
            }
            if (object instanceof JSONArray){
                //JSONArray
            }
        }catch (com.alibaba.fastjson.JSONException e){
            //非JSON字符串
        }

2.org.json.JSON

直接使用JSON库做解析的情况不多，但是这里也稍微写一下

log.info(JSON.parse(jsonStr).getClass().getName());
try {
    Object json = new JSONTokener(jsonStr).nextValue();
   log.info( json.getClass().toString());
//            json.toString();
    if(json instanceof JSONObject){
        log.info("is JSONObject");
        JSONObject jsonObject = (JSONObject)json;
        //further actions on jsonObjects
        //...
    }else if (json instanceof JSONArray){
        log.info("is JSONArray");
        JSONArray jsonArray = (JSONArray)json;
        //further actions on jsonArray
        //...
    }
}catch (Exception e){
    e.printstacktrace();
}

3.GSON，也是蛮强大的一个库，没有依赖包，只是在反射到Map的使用上有点麻烦。

GSON里面最有意思的就是JsonPrimitive,原始JSON。

先给代码

String str = "";
JsonParser jsonParser = new JsonParser();
try{
    JsonElement jsonElement = jsonParser.parse(str);
    log.info("jsonElement "+jsonElement.getClass().getName());
    if (jsonElement.isJsonObject()){
        //JsonObject
        log.info(jsonElement.getAsJsonObject().get("aa").getAsstring());
    }
    if (jsonElement.isJsonArray()){
        //JsonArray
        log.info(jsonElement.getAsJsonArray().get(0).getAsJsonObject().get("aa").getAsstring());
    }
    if (jsonElement.isJsonNull()){
        //空字符串
        log.info(jsonElement.getAsstring());
    }
    if (jsonElement.isJsonPrimitive()){
        log.info(jsonElement.getAsstring());
    }
}catch (Exception e){
    //非法
//            e.printstacktrace();
    log.info("非法 "+e.getMessage());
}

可知,GSON中定义了四个JSON类型，分别是JSONObject,JSONArray,JSONPrimitive,JSONNull。

但是官方对JSON的严格定义是{}为JSONObject,[]为JSONArray。

所以只用JsonElement jsonElement = jsonParser.parse(str);能正常解析的字符串并不意味着是一个合法的JSON,必须满足

jsonElement.isJsonObject()或者jsonElement.isJsonArray()。

另说一个题外话，关于对jsonElement.getAsJsonPrimitive()方法的理解。

JsonPrimitive即时指JSON value的原始数据，包含三种类型，数字，双引号包裹的字符串，布尔。

所以JsonPrimitive.toString得到的不是实际的值，而是JSON中的:后面的完整内容，需要再做一次getAs。

例如

String str = "{\"aa\":\"aa\"}";
JsonElement jsonElement = jsonParser.parse(str);
log.info(jsonElement.getAsJsonObject().get("aa").getAsstring());
str = "{\"aa\":true}";
jsonElement = jsonParser.parse(str);
jsonElement.getAsJsonObject().get("aa").getAsBoolean();
str = "{\"aa\":1.2}";
jsonElement.getAsJsonObject().get("aa").getAsBigDecimal();

所以Gson还有一个好处就是自带转换为java常规类型。

FastJSON--Java对象、集合转换成JSONObject、JSONArray

Student student=new Student();
//      Java对象转JSONObect对象
        JSONObject jsonObject=(JSONObject) JSONObject.toJSON(studentDTO.getCla***oom());
        JSONObject jsonObject2=JSONObject.parseObject(JSON.toJSONString(student.getCla***oom()));
        student.setCla***oom(jsonObject);
//      Java集合转JSON数组
        JSONArray jsonArray=(JSONArray) JSONArray.toJSON(studentDTO.getTeachers());
        JSONArray jsonArray2= JSONArray.parseArray( JSON.toJSONString(studentDTO.getCla***oom()) ) ;

今天关于JSONObject、JSONArray的分享就到这里，希望大家有所收获，若想了解更多关于011-JSON、JSONObject、JSONArray使用、JSON数组形式字符串转换为List>的8种方法、Android Volley POST JsonObject并获取JsonArray或JsonObject或其他响应、Fastjson, Gson, org.json.JSON三者对于JSONObject及JSONArray的判断、FastJSON--Java对象、集合转换成JSONObject、JSONArray等相关知识，可以在本站进行查询。

本文标签：