Android为啥使用org.json而不用gson, 如何更好的测试和对比这两个东西, 哪个大神能告诉我小萌头?

我这篇文章真心求教两个困扰我的问题, 并给予某些人一下忠告:

如题, Android为啥使用org.json而不用gson, 看中了什么, 我目前看不到org.json比gson更为决定性突出的地方?

如题, 如何更好的测试和对比org.json和gson, 包括内存消耗情况, 和运行速度, 开发效率, 或者还有其他?

import java.io.BufferedInputStream;

import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import android.test.AndroidTestCase;
import android.test.suitebuilder.annotation.SmallTest;
import android.util.Log;

import com.google.gson.Gson;

public class MyAndroidTestCase extends AndroidTestCase
{
    public static final String TAG = "MyAndroidTestCase";
    
    private String json;
    
    @Override
    protected void setUp() throws Exception
    {
        InputStream is = new BufferedInputStream(getContext().getResources().openRawResource(R.raw.test));
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buffer = new byte[512];
        int len = -1;
        while((len = is.read(buffer)) > 0)
        {
            baos.write(buffer, 0, len);
        }
        json = new String(baos.toByteArray(), "UTF-8");
        baos.close();
        is.close();
    }
 
    @SuppressWarnings({ "unchecked", "unused" })
    public void testParseWithGson()
    {
        long start = System.nanoTime();                                      
        Log.e(TAG, "before parse" + Runtime.getRuntime().totalMemory()); //24813568, 24821760, 24784896, 24772608
        Gson gson = new Gson();
        Map<String, Object> map = gson.fromJson(json, Map.class);
        Log.e(TAG, "after parse" + Runtime.getRuntime().totalMemory()); //24862720, 24870912, 24834048, 24870912
        Log.e(TAG, (System.nanoTime() - start) + ""); //18689583, 18566416, 18470583, 18800249, 18638334, 18547416, 18722334
    }
    
    @SmallTest
    public void testParseWithAndroidApi()
    {
        long start = System.nanoTime();
        Log.e(TAG, "before parse" + Runtime.getRuntime().totalMemory()); //24743936, 24752128, 24760320, 24735744
        try {
            JSONObject obj = new JSONObject(json);
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("status", obj.getInt("status"));
            map.put("message", obj.getString("message"));
            map.put("total", obj.getInt("total"));
            JSONArray array = obj.getJSONArray("results");
            ArrayList<HashMap<String, Object>> results = new ArrayList<HashMap<String,Object>>();
            map.put("results", results);
            int len = array.length();
            for(int i = 0; i < len; ++i)
            {
                obj = array.getJSONObject(i);
                HashMap<String, Object> item = new HashMap<String, Object>();
                item.put("name", obj.getString("name"));
                item.put("address", obj.getString("address"));
                item.put("street_id", obj.getString("street_id"));
                item.put("telephone", obj.getString("telephone"));
                item.put("uid", obj.getString("uid"));
                JSONObject loc = obj.getJSONObject("location");
                HashMap<String, String> location = new HashMap<String, String>();
                location.put("lat", loc.getString("lat"));
                location.put("lng", loc.getString("lng"));
                item.put("location", location);
                results.add(item);
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }
        Log.e(TAG, "after parse" + Runtime.getRuntime().totalMemory()); //24866816, 24875008, 24883200, 24858624
        Log.e(TAG, (System.nanoTime() - start) + ""); //21554666, 22857584, 22218333, 23027833, 19536501, 18642584, 20328000
    }
}

这是我做的速度和内存测试, 也许测试有欠考虑的地方(如果您有更好的方案, 请一定要通知我), 但是可以看出这两方面gson并不比org.json差(我的测试数据显示比org.gson强), 我知道如果采用gson, 并作混淆的话, 需要做些配置, 而且使开发包增加170K(压缩完估计40-50K), 但是敢问各位, 没看到上面的gson是多么简洁吗, 而且很容易形成面向对象的风格, 因为有gson.from相关的方法, 我们可以先建模, 如果采用org.json, 那真的是要对json字符串一个个解析开来了, 开发效率和可维护性大大提高, 不是吗?

所以我的忠告就是, 也许我刚刚下的结论因为认知的局限有失客观, 但是不要一味的认为自带的就是最合适最好的, 保持中庸而非左倾或右倾的思想才能走的更远, 不是吗?