Android foundation summarizes XML data and JSON data

One XML data

1.1 introduction to XML data

XML, or Extensible Markup Language, is very suitable for world wide web transmission. It provides a unified method to describe and exchange structured data independent of applications or suppliers. It is widely used on the Internet.

  • To transfer data rather than display data, you need to customize the label as plain text
  • Case sensitive, correctly nested, attribute values are quoted, spaces are reserved, and there must be a root element

1.2 comparison of three XML parsing methods

1.3 core code

  • ① SAX parsing class:
public class SaxHelper extends DefaultHandler {
    private Person person;
    private ArrayList<Person> persons;
    //Currently resolved element label
    private String tagName = null;
     * When reading the document start flag is triggered, some initialization operations are usually completed here
    public void startDocument() throws SAXException {
        this.persons = new ArrayList<Person>();
        Log.i("SAX", "Read to document header,Start parsing xml");

     * Called when a start tag is read. The second parameter is the tag name and the last parameter is the attribute array
    public void startElement(String uri, String localName, String qName,
                             Attributes attributes) throws SAXException {
        if (localName.equals("person")) {
            person = new Person();
            Log.i("SAX", "Start processing person element~");
        this.tagName = localName;

     * After reading the content, the first parameter is the string content, followed by the starting position and length

    public void characters(char[] ch, int start, int length)
            throws SAXException {
        //Determine whether the current tag is valid
        if (this.tagName != null) {
            String data = new String(ch, start, length);
            //Read the contents of the label
            if (this.tagName.equals("name")) {
                Log.i("SAX", "handle name Element content");
            } else if (this.tagName.equals("age")) {
                Log.i("SAX", "handle age Element content");

     * Triggered at the end of the processing element, where the object is added to the union
    public void endElement(String uri, String localName, String qName)
            throws SAXException {
        if (localName.equals("person")) {
            person = null;
            Log.i("SAX", "handle person End of element~");
        this.tagName = null;

     * Triggered when the end of the document is read,
    public void endDocument() throws SAXException {
        Log.i("SAX", "Read to end of document,xml End of parsing");

    //Get the persons collection
    public ArrayList<Person> getPersons() {
        return persons;
  • ② Dom parsing class:
public class DomHelper {
    public static ArrayList<Person> queryXML(Context context)
        ArrayList<Person> Persons = new ArrayList<Person>();
        try {
            //① Get an example of a DOM parser factory:
            DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
            //② Get the DOM parser from the DOM factory
            DocumentBuilder dbBuilder = dbFactory.newDocumentBuilder();
            //③ Read the xml file to be parsed into the Dom parser
            Document doc = dbBuilder.parse(context.getAssets().open("person2.xml"));
            System.out.println("To process this document DomImplemention object=" + doc.getImplementation());
            //④ Get the node list of the element named person in the document
            NodeList nList = doc.getElementsByTagName("person");
            //⑤ Traverse the collection, displaying the names of the elements and child elements in the collection
            for(int i = 0;i < nList.getLength();i++)
                //Start with the Person element
                Element personElement = (Element) nList.item(i);
                Person p = new Person();

                //Get the Note collection of name and age under person
                NodeList childNoList = personElement.getChildNodes();
                for(int j = 0;j < childNoList.getLength();j++)
                    Node childNode = childNoList.item(j);
                    //Judge whether the sub note type is a note element
                    if(childNode.getNodeType() == Node.ELEMENT_NODE)
                        Element childElement = (Element) childNode;
                        else if("age".equals(childElement.getNodeName()))
        } catch (Exception e) {e.printStackTrace();}
        return Persons;
  • ③ Pull parsing class:
public static ArrayList<Person> getPersons(InputStream xml)throws Exception{
    //XmlPullParserFactory pullPaser = XmlPullParserFactory.newInstance();
    ArrayList<Person> persons = null;
    Person person = null;
    // Create an xml parsing factory  
    XmlPullParserFactory factory = XmlPullParserFactory.newInstance();  
    // Get a reference to the xml parsing class  
    XmlPullParser parser = factory.newPullParser();  
    parser.setInput(xml, "UTF-8");  
    // Gets the type of event  
    int eventType = parser.getEventType();  
    while (eventType != XmlPullParser.END_DOCUMENT) {  
        switch (eventType) {  
        case XmlPullParser.START_DOCUMENT:  
            persons = new ArrayList<Person>();  
        case XmlPullParser.START_TAG:  
            if ("person".equals(parser.getName())) {  
                person = new Person();  
                // Fetch attribute value  
                int id = Integer.parseInt(parser.getAttributeValue(0));  
            } else if ("name".equals(parser.getName())) {  
                String name = parser.nextText();// Get the content of this node  
            } else if ("age".equals(parser.getName())) {  
                int age = Integer.parseInt(parser.nextText());  
        case XmlPullParser.END_TAG:  
            if ("person".equals(parser.getName())) {  
                person = null;  
        eventType =;  
    return persons;  

I. JSON data

1.1 JSON data introduction

  • What's Jason?
    JavaScript object naming, a lightweight data exchange format, is a widely used solution for client-side and server-side interaction like XML! It has the characteristics of good readability and easy to write quickly.
  • Comparison between Json and XML:
    • The data readability of JSON and XML is basically the same;

    • JSON and XML also have rich parsing tools

    • Compared with XML, JSON has a small volume of data

    • The interaction between JSON and JavaScript is more convenient

    • JSON is less descriptive of data than XML

    • JSON is much faster than XML

      Small size, save traffic, but not as intuitive as XML and slightly worse readability!

  • Json's format specification
    json has two data structures
    • One is an unordered jsonObject object in the form of (key/value) pairs,
      An object starts with "{" (left curly bracket) and ends with "}" (right curly bracket). Each "name" is followed by a ":" (colon); "," (comma) is used to separate the 'name / value' pairs.
      For example: {"name": "xiaoluo"}, this is the simplest json object. For this data format, the key value must be of string type, while for value, it can be of string, number, object, array and other data types:

    • A data format is an ordered set of values. This form is called jsonArray, and an array is an ordered set of values.
      An array starts with "[" (left bracket) and ends with "]" (right bracket). Values are separated by "," (comma).
      For example: {[{"key11": "value11", "key12": "value12"}, {"key21": "value21"}, {"key31": "value31"}]}

  • Json parsing class
    • JSONObject: Json object, which can complete the conversion between Json string and Java object
    • JSONArray: Json array, which can complete the conversion between Json string and Java collection or object
    • JSONStringer: JSON text construction class. This class can help create JSON text quickly and conveniently. Each JSONStringer entity can only create one JSON text
    • JSONTokener: Json parsing class
    • JSONException: Json exception

1.2 JSON data parsing

Code example:
JSON data: test.json

       {"id":1, "ide":"Eclipse", "name":"Java"},
       {"id":2, "ide":"XCode", "name":"Swift"},
       {"id":3, "ide":"Visual Studio", "name":"C#"}

Data analysis:

try {
            InputStreamReader inputStreamReader = new InputStreamReader(getAssets().open("test.json"), "UTF-8");
            BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
            String line;
            StringBuilder stringBuilder = new StringBuilder();
            while((line = bufferedReader.readLine()) != null) {
            JSONObject jsonObject = new JSONObject(stringBuilder.toString());
            JSONArray jsonArray = jsonObject.getJSONArray("language");
            for (int i = 0; i < jsonArray.length(); i++) {
                JSONObject object = jsonArray.getJSONObject(i);
                Log.i("testjson: ", "id=" + object.getInt("id"));
                Log.i("testjson: ", "name=" + object.getString("name"));
                Log.i("testjson: ", "ide=" + object.getString("ide"));
        } catch (UnsupportedEncodingException e) {
        } catch (IOException e) {
        } catch (JSONException e) {

Keywords: Android JSON xml

Added by cwarn23 on Tue, 26 Oct 2021 06:06:38 +0300