Android 三种解析Json分别 原生态 Goson FastJson

     json简单说就是javascript中的对象和数组，所以这两种结构就是对象和数组两种结构，通过这两种结构可以表示各种复杂的结构

    1、对象：对象在js中表示为“{}”括起来的内容，数据结构为 {key：value,key：value,...}的键值对的结构，在面向对象的语言中，key为对象的属性，value为对应的属性值，所以很容易理 解，取值方法为 对象.key 获取属性值，这个属性值的类型可以是 数字、字符串、数组、对象几种。

    2、数组：数组在js中是中括号“[]”括起来的内容，数据结构为 ["javascript","vb",...]，取值方式和所有语言中一样，使用索引获取，字段值的类型可以是 数字、字符串、数组、对象几种。

经过对象、数组2种结构就可以组合成复杂的数据结构了。

1使用原生态的方法解析json（记得配好网络环境 前面博客有怎么配的）还有配上联网的权限

<uses-permission android:name="android.permission.INTERNET"></uses-permission>  

布局的话就简单的写一个解析json的button

直接上Activity

public class MainActivity extends AppCompatActivity {  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
    }  
  
  
    public void parserJson(View view){  
        new MyTask().execute();  
    }  
  
    class MyTask extends AsyncTask{  
  
        @Override  
        protected Object doInBackground(Object[] params) {  
            try {  
                URL url=new URL(getString(R.string.service_name)+"person.json");  
                HttpURLConnection connection= (HttpURLConnection) url.openConnection();  
                //设置请求方式  
                connection.setRequestMethod("GET");  
                connection.setConnectTimeout(5000);  
  
                //获取结果码  
                int code=connection.getResponseCode();  
                if(code==200){  
                    InputStream is=connection.getInputStream();  
  
                    BufferedReader br=new BufferedReader(new InputStreamReader(is));  
                    String str=null;  
                    StringBuffer stringBuffer=new StringBuffer();  
                    while((str=br.readLine())!=null){  
                        stringBuffer.append(str);  
                    }  
                    Log.i("test",stringBuffer.toString());  
  
                    //01使用原生态的方式解析  
                    JSONObject jsonObject=new JSONObject(stringBuffer.toString());  
                    int list=jsonObject.getInt("list");  
                    Log.i("test","长度"+list);  
  
                    JSONArray jsonArray=jsonObject.getJSONArray("person");  
                    for (int i = 0; i < jsonArray.length(); i++) {  
                        JSONObject object=jsonArray.getJSONObject(i);  
                        int pid=object.getInt("pid");  
                        String pname=object.getString("pname");  
                        int page=object.getInt("page");  
                        Log.i("test",pid+"--"+pname+"--"+page);  
                    }  
                }  
  
            } catch (MalformedURLException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            } catch (JSONException e) {  
                e.printStackTrace();  
            }  
            return null;  
        }  
  
        @Override  
        protected void onPostExecute(Object o) {  
            super.onPostExecute(o);  
        }  
    }  
  
}  

原生态的就写完了 然后就是使用Goson解析json了首先害的将它们的依赖搭好

搜索Goson找到图片的这个直接确定添加就好

然后需要写两个实体类，符合Json文件，当然你也可以根据自己的json文件来写

{"list":2,"persons":[{"pid":1,"pname":"张三","page":10},{"pid":2,"pname":"李四","page":40}]}  

写的一个实体类是外面的这个大对象，

public class BigObject {  
    private int list;  
    private List<SmallObject> person;  
  
    public BigObject() {  
    }  
  
    public BigObject(int list, List<SmallObject> person) {  
        this.list = list;  
        this.person = person;  
    }  
  
    public int getList() {  
        return list;  
    }  
  
    public void setList(int list) {  
        this.list = list;  
    }  
  
    public List<SmallObject> getPerson() {  
        return person;  
    }  
  
    public void setPerson(List<SmallObject> person) {  
        this.person = person;  
    }  
}  

再来一个小的类在这个类里面，做了序列化的操作，重写两个方法describeContents、writeToP

public class SmallObject implements Parcelable{  
    private int pid;  
    private String pname;  
    private int page;  
  
    public SmallObject() {  
    }  
  
    public SmallObject(int pid, String pname, int page) {  
        this.pid = pid;  
        this.pname = pname;  
        this.page = page;  
    }  
  
    public int getPid() {  
        return pid;  
    }  
  
    public void setPid(int pid) {  
        this.pid = pid;  
    }  
  
    public String getPname() {  
        return pname;  
    }  
  
    public void setPname(String pname) {  
        this.pname = pname;  
    }  
  
    public int getPage() {  
        return page;  
    }  
  
    public void setPage(int page) {  
        this.page = page;  
    }  
  
  
    @Override  
    public int describeContents() {  
        return 0;  
    }  
  
    @Override// 序列化过程：必须按成员变量声明的顺序进行封装  
    public void writeToParcel(Parcel parcel, int i) {  
        parcel.writeInt(pid);  
        parcel.writeString(pname);  
        parcel.writeInt(page);  
    }  
  
  
    // 反序列过程：必须实现Parcelable.Creator接口，并且对象名必须为CREATOR  
    // 读取Parcel里面数据时必须按照成员变量声明的顺序，Parcel数据来源上面writeToParcel方法，读出来的数据供逻辑层使用  
    public static final Parcelable.Creator<SmallObject> CREATOR=new Parcelable.Creator<SmallObject>(){  
  
        @Override  
        public SmallObject createFromParcel(Parcel paecel) {  
            SmallObject smallObject=new SmallObject();  
            smallObject.setPid(paecel.readInt());  
            smallObject.setPname(paecel.readString());  
            smallObject.setPage(paecel.readInt());  
            return smallObject;  
        }  
  
        @Override  
        public SmallObject[] newArray(int size) {  
            return new SmallObject[0];  
        }  
    };  
}  

有了这些拿在Activity里面那代码就简单多了

/使用Gson解析Json  
                    Gson gson=new Gson();  
                    BigObject bigObject=gson.fromJson(stringBuffer.toString(),BigObject.class);  
                    Log.i("test",bigObject.getList()+"");  
  
                    List<SmallObject> objects=bigObject.getPerson();  
                    for (SmallObject object: objects) {  
                        Log.i("test",object.toString());  
                    }  

然后再来我们Fastjson解析json了

先把fastjson下载下来然后再复制到项目里面去添加到项目libs去在右击AddAsLibrary就行

//03.FastJson  
                    BigObject bigObject= JSON.parseObject(stringBuffer.toString(),BigObject.class);  
                    Log.i("test",bigObject.getList()+"");  
                    List<SmallObject> persons=bigObject.getPerson();  
                    for (SmallObject person : persons) {  
                        Log.i("test",person.toString());  
                    }  

这样就完成了三种方式解析简单的json了

不过想要熟悉这三种的一种那也得多多的去了解和熟悉它们底层运行原理。