代码分析（九）

最新推荐文章于 2024-04-10 23:08:26 发布

鲲不鲲

最新推荐文章于 2024-04-10 23:08:26 发布

阅读量405

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_45767055/article/details/121735046

版权

APIJSON代码分析专栏收录该内容

14 篇文章 6 订阅

订阅专栏

2021SC@SDUSC

上次分析了使用频繁的JSONObject，这次分析一下使用同样多的JSONArray。

public class JSONArray extends JSON implements List<Object>, Cloneable, RandomAccess, Serializable

同样的，这个了同样是fastjson里面的一个类，同样实现了Cloneable, Serializable ，不同的是，它实现了RandomAccess。

RandomAccess：

根据javadoc的解释，RandomAccess 是一个标记接口，用于标明实现该接口的List支持快速随机访问，主要目的是使算法能够在随机和顺序访问的list中表现的更加高效。

     for (int i=0, n=list.size(); i < n; i++)
         list.get(i);
 
runs faster than this loop:
     for (Iterator i=list.iterator(); i.hasNext(); )
         i.next();

也就是说实现RandomAccess接口的的List可以通过简单的for循环来访问数据比使用iterator访问来的高效快速。
我们来具体分析一下：
Random是随机的意思，Access是访问的意思，合起来就是随机访问的意思。

RandomAccess接口是一个标记接口，用以标记实现的List集合具备快速随机访问的能力。

那么什么是随机访问的能力呢？其实很简单，随机访问就是随机的访问List中的任何一个元素。
所有的List实现都支持随机访问的，只是基于基本结构的不同，实现的速度不同罢了，这里的快速随机访问，那么就不是所有List集合都支持了。

ArrayList基于数组实现，天然带下标，可以实现常量级的随机访问，复杂度为O(1)
LinkedList基于链表实现，随机访问需要依靠遍历实现，复杂度为O(n)
二者的差距显而易见，所以ArrayList具备快速随机访问功能，而LinkedList没有。这也就是我们实现RandomAccess的巨大作用，它大大提高了查询时随机访问的性能。

然后回到我们当前，我么你先看一下这个快速在我们APIJSON里面的具体体现：

public static JSONArray format(final JSONArray array) {
		//太长查看不方便，不如debug	 Log.i(TAG, "format  array = \n" + JSON.toJSONString(array));
		if (array == null || array.isEmpty()) {
			Log.i(TAG, "format  array == null || array.isEmpty() >> return array;");
			return array;
		}
		JSONArray formatedArray = new JSONArray();

		Object value;
		for (int i = 0; i < array.size(); i++) {
			value = array.get(i);
			if (value instanceof JSONArray) {//JSONArray，遍历来format内部项
				formatedArray.add(format((JSONArray) value));
			}
			else if (value instanceof JSONObject) {//JSONObject，往下一级提取
				formatedArray.add(format((JSONObject) value));
			}
			else {//其它Object，直接填充
				formatedArray.add(value);
			}
		}

这个方法的作用就是去格式化key名称，首先传入一个JSONArray的对象，然后在从array里面取出数据的时候，便体现了它快速的点，我们遍历这个for循环时，便可以比Iterater还要快，然后分别取出数据放入到新创建的JSONArray里面，最后再返回此对象。
我们可以看一下这个类中的一些经典的方法：

private void readObject(final java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
        JSONObject.SecureObjectInputStream.ensureFields();
        if (JSONObject.SecureObjectInputStream.fields != null && !JSONObject.SecureObjectInputStream.fields_error) {
            ObjectInputStream secIn = new JSONObject.SecureObjectInputStream(in);
            try {
                secIn.defaultReadObject();
                return;
            } catch (java.io.NotActiveException e) {
                // skip
            }
        }

        in.defaultReadObject();
        for (Object item : list) {
            if (item == null) {
                continue;
            }

            String typeName = item.getClass().getName();
            if (TypeUtils.getClassFromMapping(typeName) == null) {
                ParserConfig.global.checkAutoType(typeName, null);
            }
        }
    }

这里使用了一个对象输入流作为参数，然后经过在fastjson里面定义的SecureObjectInputStream类进行了一个转化，主要是增加了一些判断，如果JSONObject.SecureObjectInputStream.fields_error为true，那么便存在异常，诸如此类的一些判定，然后就是读取这个对象流的内容。

而我们这个JSONArray类和JSONObject类投什么关联呢？

(一) java处理 json格式字符串 : 转成 JSONArray 或 JSONObject 类型
1 如果是JSONArray ，格式: 最外层是中括号，表示数组

 格式 :  [{key:value},{key:value}... ]
    	   ["str1","str2","str3",...]

语法:   JSONArray array = JSONArray.parseArray(strs)
这里注意:     strs 必须是json格式的字符串, 以"[  ]"中括号开头结尾. 否则会报错.
2  如果是JSONObject ，格式:  最外层是大括号，表示对象
格式: 	{key:value}
语法: 	JSONObject result = JSONArray.parseObject(strs );

（二）JSONArray 和 JSONObject 可以相互嵌套
1 JSONArray 添加 JSONObject
语法: JSONArray.add(JSONObject );

格式:  [{
			 	"key": "value",
				"key": "value"
	   }]

2 JSONObject 添加 JSONArray
语法: JSONObject.put(JSONArray);

格式:  
		"key": {
			"key": "value",
			"key":[ 
				"value"
			]
		}

与组员进行讨论

关于JSONObject和JSONArray之间的关系，由于原本是不同的组员负责的内容，秉持着队友协作完成的理念，所以我和组员讨论了好久去判断他们的关系与相互作用，直到最后发现上网查资料是一部分，更多的要看我们实际的实践操作，我们直接利用postman等相关软件直接进行一些相关的测试，测试结果便很明显的表明了它们之间的关系和作用。