Android Parsing Json And Xml Complete Guide

 Last Update:2025-06-22T00:00:00     .NET School AI Teacher - SELECT ANY TEXT TO EXPLANATION.    11 mins read      Difficulty-Level: beginner

Understanding the Core Concepts of Android Parsing JSON and XML

Android Parsing JSON and XML: A Detailed Explanation with Important Info

JSON Parsing in Android

1. Overview of JSON

  • JSON is a lightweight data-interchange format that represents data as key-value pairs or arrays.
  • It is easy for humans to read and write and easy for machines to parse and generate.
  • JSON is language-independent and utilizes text formats that are completely language-independent but uses conventions familiar to programmers of the C-family of languages.

2. Android Libraries for JSON Parsing

  • JSONObject and JSONArray: Provided by Android SDK.
  • Gson: A Java library by Google to convert Java Objects into their JSON representation and vice versa.
  • Jackson: Fast Java JSON parser/generator for JSON, BSON.
  • Moshi: An efficient JSON serialization library by Square.
  • JSON Simple: A simple JSON encoder/decoder library for Java.

3. Example using JSONObject

String jsonString = "{ \"name\": \"John\", \"age\": 30 }";
JSONObject jsonObject = new JSONObject(jsonString);
String name = jsonObject.getString("name");
int age = jsonObject.getInt("age");

4. Example using Gson

String jsonString = "{ \"name\": \"John\", \"age\": 30 }";
Gson gson = new Gson();
Person person = gson.fromJson(jsonString, Person.class);

XML Parsing in Android

1. Overview of XML

  • XML is a markup language that defines a set of rules for encoding documents in a format that is both human-readable and machine-readable.
  • XML is often used for storing and transporting data and is widely used in web services.

2. Android Libraries for XML Parsing

  • DOM (Document Object Model): Parses an entire XML document and loads it into memory, building a tree structure.
  • SAX (Simple API for XML): A stream-based, event-driven API for parsing XML documents.
  • StAX (Streaming API for XML): A more efficient alternative to SAX, providing an iterator-based API.
  • Retrofit: A type-safe HTTP client for Android and Java. It can be configured to parse XML using simple annotations.

3. Example using DOM Parsing

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.parse(is);
NodeList nodeList = doc.getElementsByTagName("name");
String name = nodeList.item(0).getTextContent();

4. Example using Retrofit with XML Converter

Retrofit retrofit = new Retrofit.Builder()
     .baseUrl("http://example.com/")
     .addConverterFactory(SimpleXmlConverterFactory.create())
     .build();

ExampleService service = retrofit.create(ExampleService.class);
Call<Person> call = service.getPerson();
call.enqueue(new Callback<Person>() {
    @Override
    public void onResponse(Call<Person> call, Response<Person> response) {
        // Handle response
    }

    @Override
    public void onFailure(Call<Person> call, Throwable t) {
        // Handle failure
    }
});

Important Considerations

  1. Network Operations: Parsing should be done on a background thread to avoid blocking the UI thread. Use AsyncTask, IntentService, or Executors for this purpose.

  2. Error Handling: Implement robust error handling to manage network failures, malformed responses, or unexpected data types.

  3. Performance: Choose the right parsing method and library based on the complexity and size of the data. For large XML files, prefer SAX or StAX over DOM to avoid memory overhead.

  4. Security: Validate and sanitize inputs to prevent security vulnerabilities like XML External Entity (XXE) attacks.

  5. Testing and Validation: Thoroughly test parsing logic to ensure correct data extraction and handling of edge cases.

Online Code run

🔔 Note: Select your programming language to check or run code at

💻 Run Code Compiler

Step-by-Step Guide: How to Implement Android Parsing JSON and XML

Android Parsing JSON

Step 1: Set Up Your Project

  1. Open Android Studio and create a new project.
  2. Choose an appropriate name (e.g., JsonParsingExample) and ensure the language is set to Java or Kotlin.

Step 2: Add Required Permissions

Add the following permission in your AndroidManifest.xml to allow internet access:

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

Step 3: Fetch JSON Data from URL

Let's assume you fetch JSON data from a URL.

Java Version:

import android.os.AsyncTask;
import android.os.Bundle;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class MainActivity extends AppCompatActivity {
    private TextView textView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        textView = findViewById(R.id.text_view);
        new FetchData().execute("https://api.example.com/data");
    }

    private class FetchData extends AsyncTask<String, Void, String> {
        @Override
        protected String doInBackground(String... urls) {
            HttpURLConnection urlConnection = null;
            BufferedReader reader = null;
            String jsonResult = null;

            try {
                URL url = new URL(urls[0]);
                urlConnection = (HttpURLConnection) url.openConnection();
                urlConnection.setRequestMethod("GET");

                InputStream inputStream = urlConnection.getInputStream();
                reader = new BufferedReader(new InputStreamReader(inputStream));
                StringBuilder builder = new StringBuilder();
                String line;

                while ((line = reader.readLine()) != null) {
                    builder.append(line);
                }
                if (builder.length() > 0) {
                    jsonResult = builder.toString();
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (urlConnection != null) urlConnection.disconnect();
                if (reader != null) try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return jsonResult;
        }

        @Override
        protected void onPostExecute(String result) {
            // Parse the JSON result
            try {
                JSONArray jsonArray = new JSONArray(result);
                StringBuilder finalOutput = new StringBuilder();

                for (int i = 0; i < jsonArray.length(); i++) {
                    JSONObject jsonObject = jsonArray.getJSONObject(i);
                    String name = jsonObject.getString("name");
                    int age = jsonObject.getInt("age");
                    finalOutput.append("Name: ").append(name).append(", Age: ").append(age).append("\n");
                }

                textView.setText(finalOutput.toString());
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }
    }
}

Kotlin Version:

import android.os.AsyncTask
import android.os.Bundle
import android.widget.TextView
import androidx.appcompat.app.AppCompatActivity
import org.json.JSONArray
import org.json.JSONException
import java.io.BufferedReader
import java.io.IOException
import java.io.InputStream
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL

class MainActivity : AppCompatActivity() {

    private lateinit var textView: TextView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        textView = findViewById(R.id.text_view)
        FetchData().execute("https://api.example.com/data")
    }

    private inner class FetchData : AsyncTask<String, Void, String>() {
        override fun doInBackground(vararg urls: String?): String? {
            var urlConnection: HttpURLConnection? = null
            var reader: BufferedReader? = null
            var jsonResult: String? = null

            try {
                val url = URL(urls[0])
                urlConnection = url.openConnection() as HttpURLConnection
                urlConnection.requestMethod = "GET"

                val inputStream: InputStream = urlConnection.inputStream
                reader = BufferedReader(InputStreamReader(inputStream))
                val builder = StringBuilder()

                var line: String?
                while (reader.readLine().also { line = it } != null) {
                    builder.append(line)
                }
                if (builder.isNotEmpty()) {
                    jsonResult = builder.toString()
                }
            } catch (e: IOException) {
                e.printStackTrace()
            } finally {
                urlConnection?.disconnect()
                if (reader != null) try {
                    reader.close()
                } catch (e: IOException) {
                    e.printStackTrace()
                }
            }
            return jsonResult
        }

        override fun onPostExecute(result: String?) {
            // Parse the JSON result
            try {
                val jsonArray = JSONArray(result)
                val finalOutput = StringBuilder()

                for (i in 0 until jsonArray.length()) {
                    val jsonObject = jsonArray.getJSONObject(i)
                    val name = jsonObject.getString("name")
                    val age = jsonObject.getInt("age")
                    finalOutput.append("Name: ").append(name).append(", Age: ").append(age).append("\n")
                }
                textView.text = finalOutput.toString()
            } catch (e: JSONException) {
                e.printStackTrace()
            }
        }
    }
}

Step 4: Design Layout (activity_main.xml)

Create a simple layout with a TextView to display the parsed data.

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:id="@+id/text_view"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textSize="18sp"
        android:padding="16dp"
        android:layout_centerInParent="true"/>
</RelativeLayout>

Android Parsing XML

Step 1: Set Up Your Project

  1. Open Android Studio and create a new project.
  2. Choose an appropriate name (e.g., XmlParsingExample) and ensure the language is set to Java or Kotlin.

Step 2: Add Required Permissions

Just like in the JSON example, add the permission in your AndroidManifest.xml:

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

Step 3: Fetch XML Data from URL

Assume you fetch XML data from the same URL structure.

Java Version:

import android.os.AsyncTask;
import android.os.Bundle;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class MainActivity extends AppCompatActivity {
    private TextView textView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        textView = findViewById(R.id.text_view);
        new FetchData().execute("https://api.example.com/data.xml");
    }

    private class FetchData extends AsyncTask<String, Void, String> {
        @Override
        protected String doInBackground(String... urls) {
            HttpURLConnection urlConnection = null;
            InputStream inputStream = null;
            StringBuilder stringBuilder = new StringBuilder();

            try {
                URL url = new URL(urls[0]);
                urlConnection = (HttpURLConnection) url.openConnection();
                urlConnection.setRequestMethod("GET");

                inputStream = urlConnection.getInputStream();

                DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
                DocumentBuilder builder = factory.newDocumentBuilder();
                Document document = builder.parse(inputStream);

                NodeList nodeList = document.getElementsByTagName("item");
                for (int i = 0; i < nodeList.getLength(); i++) {
                    Node node = nodeList.item(i);
                    if (node.getNodeType() == Node.ELEMENT_NODE) {
                        Element element = (Element) node;
                        String name = getElementValue(element, "name");
                        int age = Integer.parseInt(getElementValue(element, "age"));
                        stringBuilder.append("Name: ").append(name).append(", Age: ").append(age).append("\n");
                    }
                }
            } catch (IOException | ParserConfigurationException | SAXException e) {
                e.printStackTrace();
            } finally {
                if (urlConnection != null) urlConnection.disconnect();
                if (inputStream != null) {
                    try {
                        inputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return stringBuilder.toString();
        }

        @Override
        protected void onPostExecute(String result) {
            textView.setText(result);
        }

        private String getElementValue(Element item, String nodeName) {
            NodeList nodes = item.getElementsByTagName(nodeName);
            return this.getFirstTagValue(nodes);
        }

        private String getFirstTagValue(NodeList nodes) {
            if (nodes.getLength() <= 0) return "";
            Element element = (Element) nodes.item(0);
            if (element == null) return "";
            Node node = element.getFirstChild();
            return node != null ? node.getNodeValue() : "";
        }
    }
}

Kotlin Version:

import android.os.AsyncTask
import android.os.Bundle
import android.widget.TextView
import androidx.appcompat.app.AppCompatActivity
import org.w3c.dom.Document
import org.w3c.dom.Element
import org.w3c.dom.NodeList
import javax.xml.parsers.DocumentBuilder
import javax.xml.parsers.DocumentBuilderFactory
import java.io.InputStream
import java.net.HttpURLConnection
import java.net.URL

class MainActivity : AppCompatActivity() {

    private lateinit var textView: TextView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        textView = findViewById(R.id.text_view)
        FetchData().execute("https://api.example.com/data.xml")
    }

    private inner class FetchData : AsyncTask<String?, Void, String?>() {

        override fun doInBackground(vararg urls: String?): String? {
            val urlString = urls[0]
            var urlConnection: HttpURLConnection? = null
            var inputStream: InputStream? = null
            val stringBuilder = StringBuilder()

            try {
                val url = URL(urlString)
                urlConnection = url.openConnection() as HttpURLConnection
                urlConnection.requestMethod = "GET"

                inputStream = urlConnection.inputStream

                val factory = DocumentBuilderFactory.newInstance()
                val builder = factory.newDocumentBuilder()
                val doc: Document = builder.parse(inputStream)

                val nodeList: NodeList? = doc.getElementsByTagName("item")
                nodeList?.let { elements ->
                    for (i in 0 until elements.length) {
                        val node = elements.item(i)
                        if (node.nodeType == Node.ELEMENT_NODE) {
                            node as Element
                            val name = getElementValue(node, "name")
                            val age = getElementValue(node, "age").toInt()
                            stringBuilder.append("Name: ").append(name).append(", Age: ").append(age).append("\n")
                        }
                    }
                }
            } catch (e: IOException) {
                e.printStackTrace()
            } finally {
                urlConnection?.disconnect()
                inputStream?.close()
            }
            return stringBuilder.toString()
        }

        override fun onPostExecute(result: String?) {
            textView.text = result
        }

        private fun getElementValue(item: Element, nodeName: String): String {
            val nodes: NodeList? = item.getElementsByTagName(nodeName)
            return nodes?.let { getFirstTagValue(it) } ?: ""
        }

        private fun getFirstTagValue(nodes: NodeList): String {
            if (nodes.length <= 0) return ""
            val node = nodes.item(0)!!
            node as Element

            return node.firstChild?.nodeValue ?: ""
        }
    }
}

Step 4: Design Layout (activity_main.xml)

Use the same simple layout from the JSON example.

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:id="@+id/text_view"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textSize="18sp"
        android:padding="16dp"
        android:layout_centerInParent="true"/>
</RelativeLayout>

Explanation of Both Examples:

  1. Permissions: Both examples require internet access.
  2. Fetching Data: They asynchronously fetch data from a provided URL using an AsyncTask.
  3. Parsing XML: The FetchData task reads the XML response and uses DocumentBuilderFactory and DocumentBuilder classes to parse it into Nodes and Elements.
  4. Parsing JSON: The FetchData task reads the JSON response and uses standard JSON parsing techniques via JSONArray and JSONObject classes.
  5. Displaying Results: Once data is parsed, they display the values in a TextView.

Note:

  • It's recommended to use libraries such as OkHttp, Retrofit, or Gson for more complex applications instead of plain AsyncTask and built-in parsing classes.
  • Also, make sure you replace "https://api.example.com/data" and "https://api.example.com/data.xml" with actual URLs providing JSON/XML data.

Top 10 Interview Questions & Answers on Android Parsing JSON and XML

  1. What is JSON parsing in Android?

    Answer: JSON (JavaScript Object Notation) parsing in Android involves converting a JSON formatted string into native Java objects that you can use within your application. Android developers commonly utilize libraries such as org.json or third-party libraries like GSON and Jackson to simplify the process of parsing JSON data.

  2. How do I parse a JSON string using org.json in Android?

    Answer: You can start by importing the necessary classes from the org.json package, then use JSONObject and JSONArray classes to parse the string. Here’s a simple code snippet:

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

String json = "{\"name\": \"John\", \"email\": \"john@example.com\", \"phoneNumbers\": [{\"type\": \"home\", \"number\": \"1234567890\"},{\"type\": \"mobile\", \"number\": \"0987654321\"}]}";

try {
    JSONObject jsonObject = new JSONObject(json);

    String name = jsonObject.getString("name");
    String email = jsonObject.getString("email");

    JSONArray jsonArray = jsonObject.getJSONArray("phoneNumbers");
    for (int i = 0; i < jsonArray.length(); i++) {
        JSONObject phoneNo = jsonArray.getJSONObject(i);
        String type = phoneNo.getString("type");
        String number = phoneNo.getString("number");
        Log.d("Phone Number", "Type: " + type + ", Number: " + number);
    }
} catch (JSONException e) {
    e.printStackTrace();
}

  3. What are the advantages and disadvantages of using GSON over org.json in Android applications?

    Advantages:

    • Ease of Use: Directly convert JSON strings into Java objects with fromJson() method.
    • Annotations: Customizable with annotations (@SerializedName, @Expose).

    Disadvantages:

    • Overhead: Requires additional dependencies and might add size to the APK.
    • Less Control: Less control over the parsing process compared to org.json.

  4. Can you describe how to parse XML in Android using the XmlPullParser?

    Answer: XmlPullParser provides an efficient way to parse XML documents with a small footprint. Below is an example of parsing XML:

    import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserFactory;

InputStream inputStream = getResources().openRawResource(R.raw.sample);
XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
XmlPullParser xmlPullParser = factory.newPullParser();

xmlPullParser.setInput(inputStream, null);
int eventType = xmlPullParser.getEventType();  
while(eventType != XmlPullParser.END_DOCUMENT){
    if((eventType == XmlPullParser.START_TAG) && 
      xmlPullParser.getName().equals("item")){  
        Log.e("ID", xmlPullParser.getAttributeValue(null, "id"));  
    }else if(eventType == XmlPullParser.TEXT){  
        Log.e("Text", xmlPullParser.getText());  
    }else if(eventType == XmlPullParser.END_TAG){  
    }
    eventType = xmlPullParser.next();
}

  5. How do I handle large XML files efficiently in an Android app?

    Answer: Utilize streaming APIs like SAXParser or XmlPullParser. These APIs read and parse large files incrementally, which helps avoid memory overflow issues often encountered when loading all the content at once using DOM-style parsers.

  6. When should I prefer parsing JSON over XML in Android apps?

    Answer: Prefer JSON when dealing with lightweight web services or where speed is more critical, as JSON is generally quicker to parse and serialize than XML. Additionally, JSON has cleaner syntax and smaller file sizes.

  7. Can you explain the concept of a JSON object vs a JSON array in Android parsing?

    Answer: A JSON object in Android parsing is a collection of name-value pairs {name1:value2, name2:value2} accessible using their respective keys. A JSON array is an ordered list of values [value1, value2, value3] stored sequentially which can be accessed by index similar to a typical Java array but can hold mixed types.

  8. What is the difference between Jackson and Gson in parsing JSON?

    Answer: Both Jackson and Gson are popular third-party libraries for parsing JSON into Java objects. The key differences:

    • Jackson: Faster performance, more advanced features like view support, polymorphic deserialization.
    • Gson: Simpler, more straightforward API, built-in pretty printing feature for JSON serialization.

  9. How can I handle custom JSON formats during parsing in Kotlin Android apps?

    Answer: Use custom data classes along with annotations provided by Gson (@SerializedName to rename JSON fields, etc.). Alternatively, you can create a custom deserializer by implementing JsonDeserializer interface if needed. This approach allows Kotlin Android developers precise control over the parsing mechanism.

  10. What best practices should I follow for effective JSON/XML parsing in Android?

Answer:

  • Error Handling: Always include error handling in your parsing logic to manage unexpected data gracefully.
  • Background Thread: Perform network calls and parsing tasks off the main UI thread to prevent freezing and improve the app's responsiveness.
  • Efficiency: Choose the most efficient library and parser based on the complexity and size of the data being handled.
  • Security: Validate the data to protect against injection attacks and other vulnerabilities.
  • Update Mechanism: Implement mechanisms to update your data parsing logic as the format of data changes over time.

You May Like This Related .NET Topic

📥 Download Code ▶️ Watch Online 📖 Read Description

Login to post a comment.