Determine whether JSON is a JSONObject or JSONArray

I am going to receive either a JSON Object or Array from server, but I have no idea which it will be. I need to work with the JSON, but to do so, I need to know if it is an Object or an Array.

I am working with Android.

Does any one have a good way of doing this?

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:

1. 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 a JSONObject, if it is a [, you are dealing with a JSONArray.
2. If you are dealing with JSON (an Object), then you can do an instanceof check. yourObject instanceof JSONObject. This will return true if yourObject is a JSONObject. The same applies to JSONArray.

This is the simple solution I'm using on Android:

JSONObject json = new JSONObject(jsonString);

if (json.has("data")) {
	
	JSONObject dataObject = json.optJSONObject("data");

	if (dataObject != null) {

		//Do things with object.

	} else {

		JSONArray array = json.optJSONArray("data");

		//Do things with array
	}
} else {
    // Do nothing or throw exception if "data" is a mandatory field
}

Presenting an another way :

if(server_response.trim().charAt(0) == '[') {
    Log.e("Response is : " , "JSONArray");
} else if(server_response.trim().charAt(0) == '{') {
    Log.e("Response is : " , "JSONObject");
}

Here server_response is a response String coming from server

A more fundamental way of doing this is the following.

JsonArray is inherently a List

JsonObject is inherently a Map

if (object instanceof Map){
	JSONObject jsonObject = new JSONObject();
	jsonObject.putAll((Map)object);
    ...
    ...
}
else if (object instanceof List){
	JSONArray jsonArray = new JSONArray();
	jsonArray.addAll((List)object);
    ...
    ...
}

instanceof

Object.getClass().getName()

For those tackling this issue in JavaScript, the following did the job for me (not sure how efficient it is).

if(object.length != undefined) {
   console.log('Array found. Length is : ' + object.length); 
} else {
 console.log('Object found.'); 
}

JsonNode jsonNode=mapper.readTree(patchBody);

jsonNode has two method:
isObject();
isArray();

My approach would be a total abstraction from this. Maybe someone finds this useful...

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Map;

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

public class SimpleJSONObject extends JSONObject {

	
	private static final String FIELDNAME_NAME_VALUE_PAIRS = "nameValuePairs";


	public SimpleJSONObject(String string) throws JSONException {
		super(string);
	}

	
	public SimpleJSONObject(JSONObject jsonObject) throws JSONException {
		super(jsonObject.toString());
	}

	
	@Override
	public JSONObject getJSONObject(String name) throws JSONException {
		
		final JSONObject jsonObject = super.getJSONObject(name);
		
		return new SimpleJSONObject(jsonObject.toString());
	}
	
	
	@Override
	public JSONArray getJSONArray(String name) throws JSONException {

		JSONArray jsonArray = null;
		
		try {
			
			final Map<String, Object> map = this.getKeyValueMap();
			
			final Object value = map.get(name);
			
			jsonArray = this.evaluateJSONArray(name, value);
	
		} catch (Exception e) {
			
			throw new RuntimeException(e);
			
		}
		
		return jsonArray;
	}


	private JSONArray evaluateJSONArray(String name, final Object value) throws JSONException {
		
		JSONArray jsonArray = null;
		
		if (value instanceof JSONArray) {
			
			jsonArray = this.castToJSONArray(value);
			
		} else if (value instanceof JSONObject) {
			
			jsonArray = this.createCollectionWithOneElement(value);
			
		} else {
			
			jsonArray = super.getJSONArray(name);
			
		}
		return jsonArray;
	}


	private JSONArray createCollectionWithOneElement(final Object value) {

		final Collection<Object> collection = new ArrayList<Object>();
		collection.add(value);
		
		return (JSONArray) new JSONArray(collection);
	}


	private JSONArray castToJSONArray(final Object value) {
		return (JSONArray) value;
	}


	private Map<String, Object> getKeyValueMap() throws NoSuchFieldException, IllegalAccessException {
		
		final Field declaredField = JSONObject.class.getDeclaredField(FIELDNAME_NAME_VALUE_PAIRS);
		declaredField.setAccessible(true);
		
		@SuppressWarnings("unchecked")
		final Map<String, Object> map = (Map<String, Object>) declaredField.get(this);
		
		return map;
	}
	

}

And now get rid of this behaviour forever...

...
JSONObject simpleJSONObject = new SimpleJSONObject(jsonObject);
...