public JSONArray() 
{

}

Construct an empty JSONArray.

 public JSONArray(String text) 
{
        JSONTokener tokener = new JSONTokener(text);
        parse(tokener);
}

 public JSONArray(Object values) 
{
        for (Object value : values) put(value);
}

 JSONArray(JSONTokener tokenizer) 
{
        assert tokenizer != null;
        parse(tokenizer);
}

Construct a JSONArray from a JSONTokener.

Parameters:

tokenizer - A JSONTokener

Throws:

RuntimeException - If there is a syntax error.

 public boolean equals(Object obj) 
{
        if (obj == null) return false;
        if (!(obj instanceof JSONArray)) return false;
        JSONArray other = (JSONArray) obj;
        return list.equals(other.list);
}

 public Object get(int index) 
{
        return list.get(index);
}

Get the object value associated with an index.

 public boolean getBoolean(int index) 
{
        Object value = get(index);
        if (value instanceof Boolean)
        {
            return (Boolean) value;
        }
        if (value instanceof String)
        {
            String asString = (String) value;
            if (asString.equalsIgnoreCase("false")) return false;
            if (asString.equalsIgnoreCase("true")) return true;
        }
        throw new RuntimeException("JSONArray[" + index + "] is not a Boolean.");
}

Get the boolean value associated with an index. The string values "true" and "false" are converted to boolean.

 public double getDouble(int index) 
{
        Object value = get(index);
        try
        {
            if (value instanceof Number) return ((Number) value).doubleValue();
            return Double.valueOf((String) value);
        }
        catch (Exception e)
        {
            throw new IllegalArgumentException("JSONArray[" + index + "] is not a number.");
        }
}

Get the double value associated with an index.

 public int getInt(int index) 
{
        Object o = get(index);
        return o instanceof Number ? ((Number) o).intValue() : (int) getDouble(index);
}

Get the int value associated with an index.

 public JSONArray getJSONArray(int index) 
{
        Object o = get(index);
        if (o instanceof JSONArray)
        {
            return (JSONArray) o;
        }
        throw new RuntimeException("JSONArray[" + index + "] is not a JSONArray.");
}

Get the JSONArray associated with an index.

 public JSONObject getJSONObject(int index) 
{
        Object o = get(index);
        if (o instanceof JSONObject)
        {
            return (JSONObject) o;
        }
        throw new RuntimeException("JSONArray[" + index + "] is not a JSONObject.");
}

Get the JSONObject associated with an index.

 public long getLong(int index) 
{
        Object o = get(index);
        return o instanceof Number ? ((Number) o).longValue() : (long) getDouble(index);
}

Get the long value associated with an index.

 public String getString(int index) 
{
        return get(index).toString();
}

Get the string associated with an index.

 public boolean isNull(int index) 
{
        return get(index) == JSONObject.NULL;
}

Determine if the value is null.

 public String join(String separator) 
{
        int len = length();
        StringBuilder buffer = new StringBuilder();
        for (int i = 0; i <  len; i += 1)
        {
            if (i  > 0) buffer.append(separator);
            buffer.append(JSONObject.valueToString(list.get(i)));
        }
        return buffer.toString();
}

Make a string from the contents of this JSONArray. The separator string is inserted between each element. Warning: This method assumes that the data structure is acyclical.

 public int length() 
{
        return list.size();
}

Get the number of elements in the JSONArray, included nulls.

 public JSONArray put(Object value) 
{
        assert value != null;
        JSONObject.testValidity(value);
        list.add(value);
        return this;
}

Append an object value. This increases the array's length by one.

 public JSONArray put(int index,
    Object value) 
{
        assert value != null;
        if (index <  0)
        {
            throw new RuntimeException("JSONArray[" + index + "] not found.");
        }
        JSONObject.testValidity(value);
        if (index <  length())
        {
            list.set(index, value);
        }
        else
        {
            while (index != length()) list.add(JSONObject.NULL);
            list.add(value);
        }
        return this;
}

Put or replace an object value in the JSONArray. If the index is greater than the length of the JSONArray, then null elements will be added as necessary to pad it out.

 Object[] toArray() 
{
        return list.toArray();
}

 public String toString() 
{
        try
        {
            return '[' + join(",") + ']';
        }
        catch (Exception e)
        {
            return null;
        }
}

Make a JSON text of this JSONArray. For compactness, no unnecessary whitespace is added. If it is not possible to produce a syntactically correct JSON text then null will be returned instead. This could occur if the array contains an invalid number.

Warning: This method assumes that the data structure is acyclical.