Guide: Android: Parsing JSON Files with Gson and Native Objects:

I see a lot of questions as for how to parse JSON object in android, So I decides to write
a small guide to demonstrate how it’s done. Android platform has build-in tools for dealing
with those parsing tasks so I going to talk about those today. I also going to
show you a basic use of Google’s Gson library.

When we talk about JSON files, important to say that JSON (stand for JavaScript Object Notation) is, and I quote Wikipedia:

“a text-based open standard designed for human-readable data interchange. It is
derived from the JavaScript scripting language for representing simple data structures
and associative arrays, called objects.”

So JSON standard was basically designed to interchange data between different devices
over the internet. There are actually two main structures in JSON files which are Objects and
Arrays. Those will be the objects we will use in our code in order to parse those files.
Lets dive into an example:

Say we received a JSON file that represents a class and a list of students with their grades,
and this file looks like this:

{
    "Class":{
        "Class_Id": "A2",
        "Class_Type": "Science",
        "Class_Student_Count": 23,
        "Class_Studens": [
            {
                "Student_Id": "123456789",
                "Student_Name": "DavStudent_Id",
                "Student_Age": 23,
                "Student_Grades": [
                    { "Course_Name": "Mathematics", "Course_Grade": 95},
                    { "Course_Name": "Biology", "Course_Grade": 80},
                    { "Course_Name": "English", "Course_Grade": 86}
                ]
            },
            {
                "Student_Id": "987654321",
                "Student_Name": "Dan",
                "Student_Age": 25,
                "Student_Grades": [
                    { "Course_Name": "Mathematics", "Course_Grade": 95},
                    { "Course_Name": "Biology", "Course_Grade": 80},
                    { "Course_Name": "English", "Course_Grade": 86}
                ]
            },
            {
                "Student_Id": "123789456",
                "Student_Name": "Smith",
                "Student_Age": 30,
                "Student_Grades": [
                    { "Course_Name": "Mathematics", "Course_Grade": 95},
                    { "Course_Name": "Biology", "Course_Grade": 80},
                    { "Course_Name": "English", "Course_Grade": 86}
                ]
            },
            {
                "Student_Id": "987321654",
                "Student_Name": "Jhon",
                "Student_Age": 18,
                "Student_Grades": [
                    { "Course_Name": "Mathematics", "Course_Grade": 95},
                    { "Course_Name": "Biology", "Course_Grade": 80},
                    { "Course_Name": "English", "Course_Grade": 86}
                ]
            },
            {
                "Student_Id": "789123456",
                "Student_Name": "Leon",
                "Student_Age": 19,
                "Student_Grades": [
                    { "Course_Name": "Mathematics", "Course_Grade": 95},
                    { "Course_Name": "Biology", "Course_Grade": 80},
                    { "Course_Name": "English", "Course_Grade": 86}
                ]
            },
            {
                "Student_Id": "654987321",
                "Student_Name": "Philip",
                "Student_Age": 22,
                "Student_Grades": [
                    { "Course_Name": "Mathematics", "Course_Grade": 95},
                    { "Course_Name": "Biology", "Course_Grade": 80},
                    { "Course_Name": "English", "Course_Grade": 86}
                ]
            }
        ]
    }
}

As you can see this JSON file describes a students class with class details. In addition it
contains a list of class’s students while each one of them contains a list as well with the
student’s related course grades. It’s a fairly simple valid JSON file and at the moment I will
parse only the students list part, but before that I would like to share the following service
with you: http://jsonlint.com/. It will allow you to validate your JSON file and make
sure that what you receive from any web service is in fact a valid JSON file.

1. First we will create the relevant classes for parsing:
Student Class:

public class Student 
{
    private String studentId;
    private String studentName;
    private int studentAge;
    private List<Grade> studentGrades;
     
	public Student() {
		super();
		this.studentGrades = new ArrayList<Grade>();
	}
	public String getStudentId() {
		return studentId;
	}
	public void setStudentId(String studentId) {
		this.studentId = studentId;
	}
	public String getStudentName() {
		return studentName;
	}
	public void setStudentName(String studentName) {
		this.studentName = studentName;
	}
	public int getStudentAge() {
		return studentAge;
	}
	public void setStudentAge(int studentAge) {
		this.studentAge = studentAge;
	}
	public List<Grade> getStudentGrades() {
		return studentGrades;
	}
	public void setStudentGrades(List<Grade> studentGrades) {
		this.studentGrades = studentGrades;
	}
    
	public void addGradeToGradesList(Grade grade)
	{
		this.studentGrades.add(grade);
	}
	@Override
	public String toString() {
		return "Student [studentId=" + studentId + ", studentName="
				+ studentName + ", studentAge=" + studentAge
				+ ", studentGrades=" + studentGrades + "]";
	}	
}

Grade Class:

public class Grade 
{
	private String course;
	private int courseGrade;
	
	public String getCourse() {
		return course;
	}
	public void setCourse(String course) {
		this.course = course;
	}
	public int getCourseGrade() {
		return courseGrade;
	}
	public void setCourseGrade(int courseGrade) {
		this.courseGrade = courseGrade;
	}
	@Override
	public String toString() {
		return "Grade [course=" + course + ", courseGrade=" + courseGrade + "]";
	}	
}

Those classes are really self-explanatory so I’m not going to dwell on them much.

2. Second, I will create the JSON parsing class:

import java.util.ArrayList;
import java.util.List;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import android.util.Log;

public class JSONParsingClass 
{
	private static final String TAG = JSONParsingClass.class.getSimpleName();
	
	//static final String for parsed elements
	//Class elements
	public static final String STUDENTS_LIST_ELEMENT = "Class_Studens";
	
	//Student elements
	public static final String STUDENT_ID = "Student_Id";
	public static final String STUDENT_NAME = "Student_Name";
	public static final String STUDENT_AGE = "Student_Age";
	public static final String STUDENT_GRADE_LIST = "Student_Grades";
	public static final String CLASS = "Class";
	
	//Grade elements
	public static final String COURSE_NAME = "Course_Name";
	public static final String COURSE_GRADE = "Course_Grade";

	//Native method for parsing json file
	public static List<Student> NativeJsonParseMethodForStudents(String jsonString) {
		try{
			//Creating list object for storing the parsed students
			List<Student> studentsList = new ArrayList<Student>();
			
			//Creating JSON object from string
			JSONObject json = new JSONObject(jsonString);
			
			//Getting "Class" element from JSON file
			JSONObject classElement = json.getJSONObject(CLASS);

			//Making sure that students list array exists
			if (!classElement.isNull(STUDENTS_LIST_ELEMENT))
			{
				//Getting students array
				JSONArray array = classElement.getJSONArray(STUDENTS_LIST_ELEMENT);
				
				//Creating empty json object for students loop
				JSONObject currentStudent;
				
				//looping all the students and adding them parsed one by one to the list
				for (int i = 0 ; i < array.length() ; i ++){
					currentStudent = array.getJSONObject(i);
					
					//Method to parse students and add them to the list
					addCurrentStudentToStudentsList(currentStudent, studentsList);
				}
				//Returning parsed students list
				return studentsList;
			}
			else
			{
				Log.d(TAG, "Students List is Null");
				return null;
			}
		} catch (Exception e) {
		   	Log.e("EXC", "Error", e);
		   	return null;
		}
	}
	
	//Method to parse students and added them to the list
	private static void addCurrentStudentToStudentsList(JSONObject currentStudent, List<Student> studentsList) 
	{
		//Initializing Student Object
		Student student = new Student();
		
		//Creating empty list for student's grades.
		List<Grade> studentGrades = new ArrayList<Grade>();
		try {
			//Parsing student's details.
			student.setStudentId(currentStudent.getString(STUDENT_ID));
			student.setStudentName(currentStudent.getString(STUDENT_NAME));
			student.setStudentAge(currentStudent.getInt(STUDENT_AGE));	
			
			//Making sure that student's grades list array exists
			if (!currentStudent.isNull(STUDENT_GRADE_LIST))
			{
				//Getting grades array
				JSONArray array = currentStudent.getJSONArray(STUDENT_GRADE_LIST);
				
				//Creating empty json object for grades loop
				JSONObject currentGrade;
				
				//looping all the student's grades and adding them parsed one by one to the list
				for (int i = 0 ; i < array.length() ; i ++){
					currentGrade = array.getJSONObject(i);
					
					//Method to parse grades and add them to the list
					addCurrentGradeToGradesList(currentGrade, studentGrades);
				}
			}
			//Setting student's grades
			student.setStudentGrades(studentGrades);
			
			//Adding student to the list
			studentsList.add(student);
			Log.d(TAG, "Added student: "+ student.toString()); 
		} catch (JSONException e) {
			Log.e(TAG, "Exception thrown on adding student to students list: "+ e.toString());
			e.printStackTrace();
		}	
	}
	
	//Method to parse grades and add them to the list
	private static void addCurrentGradeToGradesList(JSONObject currentGrade, List<Grade> studentGrades) {
		Grade grade = new Grade();
		Log.d(TAG, "currentGrade object: " + currentGrade.toString());
		try 
		{
			//Parsing grade's details
			grade.setCourse(currentGrade.getString(COURSE_NAME));
			grade.setCourseGrade(currentGrade.getInt(COURSE_GRADE));
			
			//Adding grade to the list
			studentGrades.add(grade);
			
		} catch (JSONException e) {
		Log.e(TAG, "Exception thrown on adding grade to grades list: "+ e.toString());
		e.printStackTrace();
		}
	}	
}

I added a comment above each line of code, So this class should be more then understandable
as well. And basically you are done, you have a parsed list of all the students with their grades
from the JSON file. You can practice by creating the “Class” class and try to parse it and add
the students to it’s list.

Gson Library Usage:

In the next part of this guide I will show you a way to cut down on the written code for parsing
this simple file by using the Gson library, because lets admit it, it’s whole lot of code
for parsing such a simple file.

1. So the first step for using Gson library as with any other library is of course to download it,
head to Gson Download and download the latest version.

2. Next, as before we will have to create the class we are going to populate with the parsed
data, but this time with a small difference:

Student Class for Gson:

import com.google.gson.annotations.SerializedName;

public class Student 
{
    @SerializedName(JSONParsingClass.STUDENT_ID)
    private String studentId;
	
    @SerializedName(JSONParsingClass.STUDENT_NAME)
    private String studentName;
	
    @SerializedName(JSONParsingClass.STUDENT_AGE)
    private int studentAge;
	
    @SerializedName(JSONParsingClass.STUDENT_GRADE_LIST)
    private List<Grade> studentGrades;

    //Rest of code is unchanged...    

Grade Class for Gson:

import com.google.gson.annotations.SerializedName;

public class Grade 
{
    @SerializedName(JSONParsingClass.COURSE_NAME)
    private String course;
	
    @SerializedName(JSONParsingClass.COURSE_GRADE)
    private int courseGrade;
    
    //Rest of code is unchanged...

It possible to omit the Gson annotations if you use the same variable names for the class
parameters as they appear in the JSON file, but because this is not the case those annotations are necessary.

3. Now, I will added another method to my JSONParsingClass:

private static void addCurrentStudentToStudentsListUsingGson(JSONObject currentStudent, List<Student> studentsList) 
{
    Gson gson = new Gson();
    Student student = gson.fromJson(currentStudent.toString(), Student.class);
    studentsList.add(student);
}

4. Finally, I will replace this line of code:

addCurrentStudentToStudentsList(currentStudent, studentsList);

In the

public static List<Student> NativeJsonParseMethodForStudents(String jsonString)

Method, with this line of code:

addCurrentStudentToStudentsListUsingGson(currentStudent, studentsList);

So we basically replaced the two long parsing methods: addCurrentStudentToStudentsList
and addCurrentGradeToGradesList from the first part of this guide with this single 3 lines of
code method: addCurrentStudentToStudentsListUsingGson. And that’s it, Now you can
parse JSON files in your application in the native way or use the Gson library.

One last thing, during the writing of this post, I have created an Android project with all the source
code presented here. You can download this project from here.

Enjoy and stay tuned.

14 Responses to this entry

  • Pavan Says:

    Good Explanation and Good Example…………

    Posted on June 6th, 2013 at 9:20 am Reply | Quote
  • alvin Says:

    Thanks alot, it’s really helpful.

    Posted on July 10th, 2013 at 10:00 am Reply | Quote
  • Emil Adjiev Says:

    @alvin you welcome, have a nice coding : )

    Posted on July 10th, 2013 at 12:12 pm Reply | Quote
  • Hank Says:

    This is the best and most complete example of parsing json file with gson that I’ve come across, Real life examples, great job

    Posted on July 12th, 2013 at 9:32 pm Reply | Quote
  • Emil Adjiev Says:

    @Hank Thanks, I’m glad it was helpful to you : )

    Posted on July 16th, 2013 at 3:36 am Reply | Quote
  • senthilvel Says:

    It was so helpful…..need some more of these……….

    Posted on July 23rd, 2013 at 9:37 am Reply | Quote
  • Shaya Says:

    Excellent!!! thank you so much. covers everything pretty much

    Posted on December 25th, 2013 at 5:08 pm Reply | Quote
  • Emil Adjiev Says:

    @Shaya you welcome, glad it helped you : )

    Posted on December 25th, 2013 at 6:20 pm Reply | Quote
  • Junction Says:

    Helped me a lot, really complete example, best i found on web for the moment!

    Thanks!

    From Belgium

    Posted on December 27th, 2013 at 4:05 pm Reply | Quote
  • Aman Says:

    why you are using JSONArray and JSONObject when you are using Gson??? is it necessary? I am reading other posts (http://kylewbanks.com/blog/Tutorial-Android-Parsing-JSON-with-GSON) but they have not used Json with gson.. Please help

    P.S: I am totally new to Gson

    Posted on October 16th, 2014 at 3:34 pm Reply | Quote
  • Emil Adjiev Says:

    @Aman If you have read the post, you would know that the post presents two possible ways to approach this task, and show the difference between them. So for you question, I don’t use the standard JSONObject and array when I use Gson.

    Posted on October 30th, 2014 at 8:57 pm Reply | Quote
  • Sudipto Says:

    Thanks for sharing this tutorial of JSON Parsing with GSON with us. You explained everything very well and help me in understanding JSON clearly.

    Posted on December 22nd, 2014 at 2:39 pm Reply | Quote
  • Nason Says:

    Thanks. Gives clear understanding of using GSON.

    Posted on December 26th, 2014 at 4:57 pm Reply | Quote
  • mujaahid1996 Says:

    Hey Emil, many thanks for tutorial concept, especially nested JSON. My android with JSON project has been adapted it into AsyncTask.

    Posted on March 8th, 2016 at 7:08 pm Reply | Quote

Leave a comment