When you are working with JSON data in Android, you would use JSONArray to parse JSON which starts with the array brackets. Arrays in JSON are used to organize a collection of related items (Which could be JSON objects).
For example: [{"name":"item 1"},{"name": "item2"} ]
On the other hand, you would use JSONObject when dealing with JSON that begins with curly braces. A JSON object is typically used to contain key/value pairs related to one item.
For example: {"name": "item1", "description": "a JSON object"}
Of course, JSON arrays and objects may be nested inside one another. One common example of this is an API that returns a JSON object containing some metadata alongside an array of the items matching your query:
{"startIndex": 0, "data": [{"name": "item 1"},{"name": "item2"} ]}
When you are working with JSON data in Android, you would use JSONArray to parse JSON which starts with the array brackets. Arrays in JSON are used to organize a collection of related items (Which could be JSON objects).
For example: [{"name":"item 1"},{"name": "item2"} ]
On the other hand, you would use JSONObject when dealing with JSON that begins with curly braces. A JSON object is typically used to contain key/value pairs related to one item.
For example: {"name": "item1", "description": "a JSON object"}
Of course, JSON arrays and objects may be nested inside one another. One common example of this is an API that returns a JSON object containing some metadata alongside an array of the items matching your query:
{"startIndex": 0, "data": [{"name": "item 1"},{"name": "item2"} ]}
The difference is the same as a (Hash)Map vs List.
JSONObject:
- Contains named values (key->value pairs, tuples or whatever you want to call them)
- like
{ID : 1}
- like
- Order of elements is not important
- a JSONObject of
{id: 1, name: 'B'}is equal to{name: 'B', id: 1}.
- a JSONObject of
JSONArray:
- Contains only series values
- like
[1, 'value']
- like
- Order of values is important
- array of
[1,'value']is not the same as['value',1]
- array of
Example
JSON Object --> { "":""}
JSON Array --> [ , , , ]
{"employees":[
{"firstName":"John", "lastName":"Doe"},
{"firstName":"Anna", "lastName":"Smith"},
{"firstName":"Peter", "lastName":"Jones"}
]}
Videos
The difference between an array and an object is that
Objects are set up using a key and value like:
person.age = 15;
If the key value is a variable, then one could access it like:
var key = "age";
alert(person[key]);
Arrays use an integer[1] index and take a value.
player[1].score += 1000;
[1] Yes, I know, in JavaScript the integer index is really turned into a string behind the scenes. Ignore that. Think of arrays taking an integer value ESPECIALLY when you think of JSON.
Objects- key and value, Arrays- integer. When do you use this or that?
I think of arrays and objects as "is a/an" and "has a" respectively. Lets use "Fruit" as example.
Every item in fruit array is a type of fruit.
array fruit : [orange, mango, banana]
. Arrays can contain objects,strings, numbers, arrays, but lets deal with only objects and arrays.
array fruit : [orange:[], mango:{}, banana:{}]
. You can see that orange is an array too. It implies any item that goes int orange is a type of orange, say: bitter_orange, mandarin, sweet_orange.
for fruit object, any item in it is an attribute of fruit. thus the fruit has a
object fruit :{seed:{}, endocarp:{},flesh:{}}
This also implies that anything within the seed object should be property of seed, say: colour,
I found better way to determine:
String data = "{ ... }";
Object json = new JSONTokener(data).nextValue();
if (json instanceof JSONObject)
//you have an object
else if (json instanceof JSONArray)
//you have an array
tokenizer is able to return more types: http://developer.android.com/reference/org/json/JSONTokener.html#nextValue()
There are a couple ways you can do this:
- You can check the character at the first position of the String (after trimming away whitespace, as it is allowed in valid JSON). If it is a
{, you are dealing with aJSONObject, if it is a[, you are dealing with aJSONArray. - If you are dealing with JSON (an
Object), then you can do aninstanceofcheck.yourObject instanceof JSONObject. This will return true if yourObject is a JSONObject. The same applies to JSONArray.
Bit late, but I wanted to share my opinion on this.
I faced this problem recently when I found a Java project with both libraries and they were used at the same time.
I think that org.json is easier to read and to use, for 2 main reasons (for my needs):
JsonObject is immutable. You can't add new key/value pairs to an already existing JsonObject (reference here: javax.json: Add new JsonNumber to existing JsonObject)
It takes a few lines to pretty print a JsonObject or JsonArray, while it only takes 1 line to do it with JSONObject or JSONArray. Example:
StringWriter sw = new StringWriter(); Map<String, Object> properties = new HashMap<>(); properties.put(JsonGenerator.PRETTY_PRINTING, true); JsonWriterFactory writerFactory = Json.createWriterFactory(properties); JsonWriter jsonWriter = writerFactory.createWriter(sw); jsonWriter.writeObject(jsonObject); //JsonObject created before jsonWriter.close(); String prettyPrintedJSON = sw.toString();
That is the code I use to get an indented JSON to write to a file. And with org.json I only need jsonObject.toString(4).
Another difference is the constructors. You will need a JsonObjectBuilder to create a JSON with javax.json. One step more that can be avoided.
I'm sure there are more differences (not sure if it's possible to create a JsonObject from a String) but these are my thoughts.
JSONObject, as mentioned, is provided by android's API. JsonObject is specifically used for Java EE development which is essentially for web applications and networking capabilities among other things.
The reason Android does not prepackage JsonObject from Oracle Java EE package is because alot of the things javax can do, are not allowed within android like accessing the internet without permission. This means importing the entire jars files of javax would conflict with Android.
If you plan to build your own backend with Java EE, I would highly suggest using JsonObject over JSONObject. On the other hand, if you know a prebuilt rest service or something similar that supports Android's JSON even better.