一：XML解析步骤
分析：XML解析最终是通过XMLReader的对象来关联一个自己继承自DefaultHandler抽象类（表示一个解析器，它是通过读数据流中对应的标签时触发里面对应的方法）。通过重写里面的：
//开始解析XML文件（当读到<文件头开始标签>事件触发，执行此方法)
public void startDocument(){}；
//结束解析XML文件（当读到<文件头结束标签>事件触发，执行此方法)
public void endDocument(){}；
//开始解析元素标签（当读到<标签头开始标签>事件触发，执行此方法)
public void startElement(String uri,String localName,String qName,
Attributes attributes）{
String localName：表示不带标签头的标签
String qName：表示带标签头的标签
Attributes attributes：代表标签中的属性
}；
//结束解析元素标签（当读到<标签头开始标签>事件触发，执行此方法)
public void endElement(String uri,String qName){}；
//解析标签对里面的内容，标签对只的内容存在char[] 数组中，通过判断当前解析的标签对的值，然后通过char[]数组和对应的参数来构建字符串，该字符串的值就是标签对中的内容。
public void characters(char[] ch,int start,
int length){
注意：该方法在遇到回车、换行、标签结束符时都会执行。
}；
五个方法。
1：创建DefaultHandler（解析器）的实现类：MySaxHandler类
public class MySaxHandler extends DefaultHandler{
重写对应的五个事件触发的方法。
}；
2:获取XMLReader（XML数据持有的者）的对象。（有两种方法可以获取）
第一步：获取Sax解析的工厂类的对象（表示是Sax解析）
SAXParserFactory saxfacFactory=SAXParserFactory.newInstance();
SAXParser parser=saxfacFactory.newSAXParser();
XMLReader reader=parser.getXMLReader();
直接通过XMLReaderFactory类来创建一个XMLReader（XML数据持有的者）的对象
XMLReader reader=XMLReaderFactory.createXMLReader();
3：通过XML数据持有者对象来关联自己创建的解析器类
reader.setContentHandler(new MySaxHandler());
4：通过数据持有者去解析对应的XML文件或者XML文件所对应的流
reader.parse(String XMLFile);
reader.parse(new InputSource(Intputstream in));
二：Json解析步骤：
分析：Json解析只是将XML文件换了一种表示形式，他通过一个Json对象的数组来对应一个XML文件。Json对象是包含在一个{}中的，Json对象中有多个键值对，对应着XML中的一个标签对和标签对中的值。注意：Json对象的值中可以内嵌多个Json对象，如同XML中的标签分层一样。Json对象键的属性都是String类类型。
一个最简单的Json类型的数据：String JsonData="[{\"name\":\"zhangsan\",\"age\":20},{\"name\":\"lisi\",\"age\":30}]";
里面对应两个Json对象：{\"name\":\"zhangsan\",\"age\":20}、{\"name\":\"lisi\",\"age\":30}。
当数据类型是Json数组格式时，Json解析（两种方式）的步骤如下：
第一种：通过JsonReader类来解析：
/**
* 通过JsonReader解析jsion数据
* @param jsionData 需要解析的jsion数据
* @param in 对应需要解析的数据流
* @throws IOException
*/
public void parseJsionByReader(InputStream in) throws IOException{
1： //获取JsionReader对象
JsonReader jsonReader=new JsonReader(new InputStreamReader(in));
try {
2：//开始解析JsonArray
jsonReader.beginArray();
3： //循环解析jsonArray中的对象
while(jsonReader.hasNext()){
//开始解析JsonObject
jsonReader.beginObject();
4：//循环解析JsonObject中的属性值
while(jsonReader.hasNext()){
//取出每个JsonObject中的键值
String jsonName=jsonReader.nextName();
if(jsonName.equals("name")){
//取出键值后面的value值
String value=jsonReader.nextString();
System.out.println("解析的值为："+jsonName+"--------value值 为:"+value);
}
if(jsonName.equals("age")){
int value=jsonReader.nextInt();
System.out.println("解析的值为："+jsonName+"--------value值 为:"+value);
}
}
//结束解析当前JsonObject对象
jsonReader.endObject();
}
//结束解析当前的JsonArray数组
jsonReader.endArray();
} catch (Exception e) {
e.printStackTrace();
}
}
第二种：通过JsonArray类来解析：
/**
*
* @param in对应需要解析的数据流
*/
public void parseJsonByArray(InputStream in){
try {
//获取Json对象耳的数组JsonArray里面的参数是通过对应的数据流来转换成一个字符串
JSONArray jsonArray=new JSONArray(new Scanner(in).useDelimiter("\\A").next());
//通过遍历JsonArray来获取该数组中的每个对象
for(int i=0;i<jsonArray.length();i++){
String name=jsonArray.getJSONObject(i).get("name").toString();
int age=jsonArray.getJSONObject(i).getInt("age");
System.out.println("name="+name+"------------age="+age);
}
} catch (JSONException e) {
e.printStackTrace();
}
}
Json数据端的封装可以通过字符串拼接和第三方的工具包去封装Json对象。
第一种：直接通过JsonObject对象来封装： 情况一：JSONObject studentJSONObject = new JSONObject(); try { studentJSONObject.put("name","Jason"); studentJSONObject.put("id",20130001); studentJSONObject.put("phone","13579246810"); } catch (JSONException e) { e.printStackTrace(); } return studentJSONObject.toString(); 情况二：private static String JSONText = "{\"id\":20130001,\"phone\": \"13579246810\",\"name\":\"Jason\"}"; private static String getJSONContent2(){ String name = null; int id = 0; String phone = null; try { JSONObject studentJSONObject = new JSONObject(JSONText); name = studentJSONObject.getString("name"); id = studentJSONObject.getInt("id"); phone = studentJSONObject.getString("phone"); } catch (JSONException e) { e.printStackTrace(); } return name + " " + id + " " + phone; } 第二种：通过JSONStringer对象来封装： JSONStringer jsonStringer = new JSONStringer(); try { jsonStringer.object(); jsonStringer.key("name"); jsonStringer.value("Jason"); jsonStringer.key("id"); jsonStringer.value(20130001); jsonStringer.key("phone"); jsonStringer.value("13579246810"); jsonStringer.endObject(); } catch (JSONException e) { e.printStackTrace(); } return jsonStringer.toString(); 第三种：通过JSONTokener对象来封装： private static String JSONText = "{\"id\":20130001,\"name\":\"Jason\"}"; private static String getJSONContent(){ JSONTokener jsonTokener = new JSONTokener(JSONText); JSONObject studentJSONObject; String name = null; int id = 0; String phone = null; try { studentJSONObject = (JSONObject) jsonTokener.nextValue(); name = studentJSONObject.getString("name"); id = studentJSONObject.getInt("id"); phone = studentJSONObject.getString("phone"); } catch (JSONException e) { e.printStackTrace(); } return name + " " + id + " " + phone; } 可见：三种方式都可以封装Json数据，第一种JsonObject对象封装的数据顺序杂乱，后面两种顺序一致。 所以：一般情况下使用JSONObject即可，但对于一些嵌套的JSON，某些JSONArray没有key,只有value等特殊情况，则使 用JSONStringer. 最后：两种的解析方式的与原理是一样的，只是数据封装的形式不同而已。