public JSONObject() 
{
        this.myHashMap = new LinkedHashMap();
}

Construct an empty JSONObject.

 public JSONObject(JSONTokener x) throws JSONException 
{
        this();
        char c;
        String key;
        if (x.nextClean() != '{') {
            throw x.syntaxError("A JSONObject text must begin with '{'");
        }
        for (;;) {
            c = x.nextClean();
            switch (c) {
            case 0:
                throw x.syntaxError("A JSONObject text must end with '}'");
            case '}':
                return;
            default:
                x.back();
                key = x.nextValue().toString();
            }
            /*
             * The key is followed by ':'. We will also tolerate '=' or '= >'.
             */
            c = x.nextClean();
            if (c == '=') {
                if (x.next() != ' >') {
                    x.back();
                }
            } else if (c != ':') {
                throw x.syntaxError("Expected a ':' after a key");
            }
            put(key, x.nextValue());
            /*
             * Pairs are separated by ','. We will also tolerate ';'.
             */
            switch (x.nextClean()) {
            case ';':
            case ',':
                if (x.nextClean() == '}') {
                    return;
                }
                x.back();
                break;
            case '}':
                return;
            default:
                throw x.syntaxError("Expected a ',' or '}'");
            }
        }
}

Construct a JSONObject from a JSONTokener.

Parameters:

x - A JSONTokener object containing the source string.

Throws:

JSONException - If there is a syntax error in the source string.

 public JSONObject(Map map) 
{
        this.myHashMap = (map == null) ?
                new LinkedHashMap() :
                new LinkedHashMap(map);
}

Construct a JSONObject from a Map.

Parameters:

map - A map object that can be used to initialize the contents of the JSONObject.

 public JSONObject(String string) throws JSONException 
{
        this(new JSONTokener(string));
}

Construct a JSONObject from a string. This is the most commonly used JSONObject constructor.

Parameters:

string - A string beginning with { (left brace) and ending with } (right brace).

Throws:

JSONException - If there is a syntax error in the source string.

exception: JSONException - If there is a syntax error in the source string.

 public JSONObject(JSONObject jo,
    String[] sa) throws JSONException 
{
        this();
        for (int i = 0; i <  sa.length; i += 1) {
            putOpt(sa[i], jo.opt(sa[i]));
        }
}

Construct a JSONObject from a subset of another JSONObject. An array of strings is used to identify the keys that should be copied. Missing keys are ignored.

Parameters:

jo - A JSONObject.

sa - An array of strings.

Throws:

JSONException - If a value is a non-finite number.

exception: JSONException - If a value is a non-finite number.

 public JSONObject(Object object,
    String[] names) 
{
        this();
        Class c = object.getClass();
        for (int i = 0; i <  names.length; i += 1) {
                try {
                        String name = names[i];
                        Field field = c.getField(name);
                        Object value = field.get(object);
                        this.put(name, value);
                } catch (Exception e) {
                        /* forget about it */
                }
        }
}

Construct a JSONObject from an Object, using reflection to find the public members. The resulting JSONObject's keys will be the strings from the names array, and the values will be the field values associated with those keys in the object. If a key is not found or not visible, then it will not be copied into the new JSONObject.

Parameters:

object - An object that has fields that should be used to make a JSONObject.

names - An array of strings, the names of the fields to be used from the object.

 public JSONObject accumulate(String key,
    Object value) throws JSONException 
{
        testValidity(value);
        Object o = opt(key);
        if (o == null) {
            put(key, value);
        } else if (o instanceof JSONArray) {
            ((JSONArray)o).put(value);
        } else {
            put(key, new JSONArray().put(o).put(value));
        }
        return this;
}

Accumulate values under a key. It is similar to the put method except that if there is already an object stored under the key then a JSONArray is stored under the key to hold all of the accumulated values. If there is already a JSONArray, then the new value is appended to it. In contrast, the put method replaces the previous value.

 public JSONObject append(String key,
    Object value) throws JSONException 
{
        testValidity(value);
        Object o = opt(key);
        if (o == null) {
            put(key, new JSONArray().put(value));
        } else if (!(o instanceof JSONArray)){
            throw new JSONException("JSONObject[" + key + 
                        "] is not a JSONArray.");
        } else {
            put(key, new JSONArray().put(o).put(value));
        }
        return this;
}

Append values to the array under a key. If the key does not exist in the JSONObject, then the key is put in the JSONObject with its value being a JSONArray containing the value parameter. If the key was already associated with a JSONArray, then the value parameter is appended to it.

 public static String doubleToString(double d) 
{
        if (Double.isInfinite(d) || Double.isNaN(d)) {
                return "null";
        }
// Shave off trailing zeros and decimal point, if possible.
        String s = Double.toString(d);
        if (s.indexOf('.')  > 0 && s.indexOf('e') <  0 && s.indexOf('E') <  0) {
            while (s.endsWith("0")) {
                s = s.substring(0, s.length() - 1);
            }
            if (s.endsWith(".")) {
                s = s.substring(0, s.length() - 1);
            }
        }
        return s;
}

Produce a string from a double. The string "null" will be returned if the number is not finite.

 public Object get(String key) throws JSONException 
{
        Object o = opt(key);
        if (o == null) {
            throw new JSONException("JSONObject[" + quote(key) +
                    "] not found.");
        }
        return o;
}

Get the value object associated with a key.

 public boolean getBoolean(String key) throws JSONException 
{
        Object o = get(key);
        if (o.equals(Boolean.FALSE) ||
                (o instanceof String &&
                ((String)o).equalsIgnoreCase("false"))) {
            return false;
        } else if (o.equals(Boolean.TRUE) ||
                (o instanceof String &&
                ((String)o).equalsIgnoreCase("true"))) {
            return true;
        }
        throw new JSONException("JSONObject[" + quote(key) +
                "] is not a Boolean.");
}

Get the boolean value associated with a key.

 public double getDouble(String key) throws JSONException 
{
        Object o = get(key);
        try {
            return o instanceof Number ?
                ((Number)o).doubleValue() : 
                Double.valueOf((String)o).doubleValue();
        } catch (Exception e) {
            throw new JSONException("JSONObject[" + quote(key) +
                "] is not a number.");
        }
}

Get the double value associated with a key.

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

Get the int value associated with a key. If the number value is too large for an int, it will be clipped.

 public JSONArray getJSONArray(String key) throws JSONException 
{
        Object o = get(key);
        if (o instanceof JSONArray) {
            return (JSONArray)o;
        }
        throw new JSONException("JSONObject[" + quote(key) +
                "] is not a JSONArray.");
}

Get the JSONArray value associated with a key.

 public JSONObject getJSONObject(String key) throws JSONException 
{
        Object o = get(key);
        if (o instanceof JSONObject) {
            return (JSONObject)o;
        }
        throw new JSONException("JSONObject[" + quote(key) +
                "] is not a JSONObject.");
}

Get the JSONObject value associated with a key.

 public long getLong(String key) throws JSONException 
{
        Object o = get(key);
        return o instanceof Number ?
                ((Number)o).longValue() : (long)getDouble(key);
}

Get the long value associated with a key. If the number value is too long for a long, it will be clipped.

 public String getString(String key) throws JSONException 
{
        return get(key).toString();
}

Get the string associated with a key.

 public boolean has(String key) 
{
        return this.myHashMap.containsKey(key);
}

Determine if the JSONObject contains a specific key.

 public boolean isNull(String key) 
{
        return JSONObject.NULL.equals(opt(key));
}

Determine if the value associated with the key is null or if there is no value.

 public Iterator keys() 
{
        return this.myHashMap.keySet().iterator();
}

Get an enumeration of the keys of the JSONObject.

 public int length() 
{
        return this.myHashMap.size();
}

Get the number of keys stored in the JSONObject.

 public JSONArray names() 
{
        JSONArray ja = new JSONArray();
        Iterator  keys = keys();
        while (keys.hasNext()) {
            ja.put(keys.next());
        }
        return ja.length() == 0 ? null : ja;
}

Produce a JSONArray containing the names of the elements of this JSONObject.

 public static String numberToString(Number n) throws JSONException 
{
        if (n == null) {
            throw new JSONException("Null pointer");
        }
        testValidity(n);
// Shave off trailing zeros and decimal point, if possible.
        String s = n.toString();
        if (s.indexOf('.')  > 0 && s.indexOf('e') <  0 && s.indexOf('E') <  0) {
            while (s.endsWith("0")) {
                s = s.substring(0, s.length() - 1);
            }
            if (s.endsWith(".")) {
                s = s.substring(0, s.length() - 1);
            }
        }
        return s;
}

Produce a string from a Number.

 public Object opt(String key) 
{
        return key == null ? null : this.myHashMap.get(key);
}

Get an optional value associated with a key.

 public boolean optBoolean(String key) 
{
        return optBoolean(key, false);
}

Get an optional boolean associated with a key. It returns false if there is no such key, or if the value is not Boolean.TRUE or the String "true".

 public boolean optBoolean(String key,
    boolean defaultValue) 
{
        try {
            return getBoolean(key);
        } catch (Exception e) {
            return defaultValue;
        }
}

Get an optional boolean associated with a key. It returns the defaultValue if there is no such key, or if it is not a Boolean or the String "true" or "false" (case insensitive).

 public double optDouble(String key) 
{
        return optDouble(key, Double.NaN);
}

Get an optional double associated with a key, or NaN if there is no such key or if its value is not a number. If the value is a string, an attempt will be made to evaluate it as a number.

 public double optDouble(String key,
    double defaultValue) 
{
        try {
            Object o = opt(key);
            return o instanceof Number ? ((Number)o).doubleValue() :
                new Double((String)o).doubleValue();
        } catch (Exception e) {
            return defaultValue;
        }
}

Get an optional double associated with a key, or the defaultValue if there is no such key or if its value is not a number. If the value is a string, an attempt will be made to evaluate it as a number.

 public int optInt(String key) 
{
        return optInt(key, 0);
}

Get an optional int value associated with a key, or zero if there is no such key or if the value is not a number. If the value is a string, an attempt will be made to evaluate it as a number.

 public int optInt(String key,
    int defaultValue) 
{
        try {
            return getInt(key);
        } catch (Exception e) {
            return defaultValue;
        }
}

Get an optional int value associated with a key, or the default if there is no such key or if the value is not a number. If the value is a string, an attempt will be made to evaluate it as a number.

 public JSONArray optJSONArray(String key) 
{
        Object o = opt(key);
        return o instanceof JSONArray ? (JSONArray)o : null;
}

Get an optional JSONArray associated with a key. It returns null if there is no such key, or if its value is not a JSONArray.

 public JSONObject optJSONObject(String key) 
{
        Object o = opt(key);
        return o instanceof JSONObject ? (JSONObject)o : null;
}

Get an optional JSONObject associated with a key. It returns null if there is no such key, or if its value is not a JSONObject.

 public long optLong(String key) 
{
        return optLong(key, 0);
}

Get an optional long value associated with a key, or zero if there is no such key or if the value is not a number. If the value is a string, an attempt will be made to evaluate it as a number.

 public long optLong(String key,
    long defaultValue) 
{
        try {
            return getLong(key);
        } catch (Exception e) {
            return defaultValue;
        }
}

Get an optional long value associated with a key, or the default if there is no such key or if the value is not a number. If the value is a string, an attempt will be made to evaluate it as a number.

 public String optString(String key) 
{
        return optString(key, "");
}

Get an optional string associated with a key. It returns an empty string if there is no such key. If the value is not a string and is not null, then it is coverted to a string.

 public String optString(String key,
    String defaultValue) 
{
        Object o = opt(key);
        return o != null ? o.toString() : defaultValue;
}

Get an optional string associated with a key. It returns the defaultValue if there is no such key.

 public JSONObject put(String key,
    Collection value) throws JSONException 
{
        put(key, new JSONArray(value));
        return this;
}

Put a key/value pair in the JSONObject, where the value will be a JSONArray which is produced from a Collection.

 public JSONObject put(String key,
    boolean value) throws JSONException 
{
        put(key, value ? Boolean.TRUE : Boolean.FALSE);
        return this;
}

Put a key/boolean pair in the JSONObject.

 public JSONObject put(String key,
    double value) throws JSONException 
{
        put(key, new Double(value));
        return this;
}

Put a key/double pair in the JSONObject.

 public JSONObject put(String key,
    int value) throws JSONException 
{
        put(key, new Integer(value));
        return this;
}

Put a key/int pair in the JSONObject.

 public JSONObject put(String key,
    long value) throws JSONException 
{
        put(key, new Long(value));
        return this;
}

Put a key/long pair in the JSONObject.

 public JSONObject put(String key,
    Map value) throws JSONException 
{
        put(key, new JSONObject(value));
        return this;
}

Put a key/value pair in the JSONObject, where the value will be a JSONObject which is produced from a Map.

 public JSONObject put(String key,
    Object value) throws JSONException 
{
        if (key == null) {
            throw new JSONException("Null key.");
        }
        if (value != null) {
            testValidity(value);
            this.myHashMap.put(key, value);
        } else {
            remove(key);
        }
        return this;
}

Put a key/value pair in the JSONObject. If the value is null, then the key will be removed from the JSONObject if it is present.

 public JSONObject putOpt(String key,
    Object value) throws JSONException 
{
        if (key != null && value != null) {
            put(key, value);
        }
        return this;
}

Put a key/value pair in the JSONObject, but only if the key and the value are both non-null.

 public static String quote(String string) 
{
        if (string == null || string.length() == 0) {
            return "\"\"";
        }
        char         c = 0;
        int          i;
        int          len = string.length();
        StringBuffer sb = new StringBuffer(len + 4);
        String       t;
        sb.append('"');
        for (i = 0; i <  len; i += 1) {
            c = string.charAt(i);
            switch (c) {
            case '\\':
            case '"':
                sb.append('\\');
                sb.append(c);
                break;
            case '/':
//                if (b == '< ') {
                    sb.append('\\');
//                }
                sb.append(c);
                break;
            case '\b':
                sb.append("\\b");
                break;
            case '\t':
                sb.append("\\t");
                break;
            case '\n':
                sb.append("\\n");
                break;
            case '\f':
                sb.append("\\f");
                break;
            case '\r':
                sb.append("\\r");
                break;
            default:
                if (c <  ' ') {
                    t = "000" + Integer.toHexString(c);
                    sb.append("\\u" + t.substring(t.length() - 4));
                } else {
                    sb.append(c);
                }
            }
        }
        sb.append('"');
        return sb.toString();
}

Produce a string in double quotes with backslash sequences in all the right places. A backslash will be inserted within

 public Object remove(String key) 
{
        return this.myHashMap.remove(key);
}

Remove a name and its value, if present.

 static  void testValidity(Object o) throws JSONException 
{
        if (o != null) {
            if (o instanceof Double) {
                if (((Double)o).isInfinite() || ((Double)o).isNaN()) {
                    throw new JSONException(
                        "JSON does not allow non-finite numbers");
                }
            } else if (o instanceof Float) {
                if (((Float)o).isInfinite() || ((Float)o).isNaN()) {
                    throw new JSONException(
                        "JSON does not allow non-finite numbers.");
                }
            }
        }
}

Throw an exception if the object is an NaN or infinite number.

 public JSONArray toJSONArray(JSONArray names) throws JSONException 
{
        if (names == null || names.length() == 0) {
            return null;
        }
        JSONArray ja = new JSONArray();
        for (int i = 0; i <  names.length(); i += 1) {
            ja.put(this.opt(names.getString(i)));
        }
        return ja;
}

Produce a JSONArray containing the values of the members of this JSONObject.

 public String toString() 
{
        try {
            Iterator     keys = keys();
            StringBuffer sb = new StringBuffer("{");
            while (keys.hasNext()) {
                if (sb.length()  > 1) {
                    sb.append(',');
                }
                Object o = keys.next();
                sb.append(quote(o.toString()));
                sb.append(':');
                sb.append(valueToString(this.myHashMap.get(o)));
            }
            sb.append('}');
            return sb.toString();
        } catch (Exception e) {
            return null;
        }
}

Make a JSON text of this JSONObject. For compactness, no whitespace is added. If this would not result in a syntactically correct JSON text, then null will be returned instead.

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

 public String toString(int indentFactor) throws JSONException 
{
        return toString(indentFactor, 0);
}

Make a prettyprinted JSON text of this JSONObject.

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

 String toString(int indentFactor,
    int indent) throws JSONException 
{
        int          i;
        int          n = length();
        if (n == 0) {
            return "{}";
        }
        Iterator     keys = keys();
        StringBuffer sb = new StringBuffer("{");
        int          newindent = indent + indentFactor;
        Object       o;
        if (n == 1) {
            o = keys.next();
            sb.append(quote(o.toString()));
            sb.append(": ");
            sb.append(valueToString(this.myHashMap.get(o), indentFactor,
                    indent));
        } else {
            while (keys.hasNext()) {
                o = keys.next();
                if (sb.length()  > 1) {
                    sb.append(",\n");
                } else {
                    sb.append('\n');
                }
                for (i = 0; i <  newindent; i += 1) {
                    sb.append(' ');
                }
                sb.append(quote(o.toString()));
                sb.append(": ");
                sb.append(valueToString(this.myHashMap.get(o), indentFactor,
                        newindent));
            }
            if (sb.length()  > 1) {
                sb.append('\n');
                for (i = 0; i <  indent; i += 1) {
                    sb.append(' ');
                }
            }
        }
        sb.append('}');
        return sb.toString();
}

Make a prettyprinted JSON text of this JSONObject.

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

 static String valueToString(Object value) throws JSONException 
{
        if (value == null || value.equals(null)) {
            return "null";
        }
        if (value instanceof JSONString) {
                Object o;
                try {
                o = ((JSONString)value).toJSONString();
            } catch (Exception e) {
                throw new JSONException(e);
            }
            if (o instanceof String) {
                        return (String) o;
                }
            throw new JSONException("Bad value from toJSONString: " + o);
        }
        if (value instanceof Number) {
            return numberToString((Number) value);
        }
        if (value instanceof Boolean || value instanceof JSONObject ||
                value instanceof JSONArray) {
            return value.toString();
        }
        return quote(value.toString());
}

Make a JSON text of an Object value. If the object has an value.toJSONString() method, then that method will be used to produce the JSON text. The method is required to produce a strictly conforming text. If the object does not contain a toJSONString method (which is the most common case), then a text will be produced by the rules.

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

 static String valueToString(Object value,
    int indentFactor,
    int indent) throws JSONException 
{
        if (value == null || value.equals(null)) {
            return "null";
        }
        try {
                if (value instanceof JSONString) {
                        Object o = ((JSONString)value).toJSONString();
                        if (o instanceof String) {
                                return (String)o;
                        }
                }
        } catch (Exception e) {
                /* forget about it */
        }
        if (value instanceof Number) {
            return numberToString((Number) value);
        }
        if (value instanceof Boolean) {
            return value.toString();
        }
        if (value instanceof JSONObject) {
            return ((JSONObject)value).toString(indentFactor, indent);
        }
        if (value instanceof JSONArray) {
            return ((JSONArray)value).toString(indentFactor, indent);
        }
        return quote(value.toString());
}

Make a prettyprinted JSON text of an object value.

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

 public Writer write(Writer writer) throws JSONException 
{
        try {
            boolean  b = false;
            Iterator keys = keys();
            writer.write('{');
            while (keys.hasNext()) {
                if (b) {
                    writer.write(',');
                }
                Object k = keys.next();
                writer.write(quote(k.toString()));
                writer.write(':');
                Object v = this.myHashMap.get(k);
                if (v instanceof JSONObject) {
                    ((JSONObject)v).write(writer);
                } else if (v instanceof JSONArray) {
                    ((JSONArray)v).write(writer);
                } else {
                    writer.write(valueToString(v));
                }
                b = true;
            }
            writer.write('}');
            return writer;
        } catch (IOException e) {
            throw new JSONException(e);
        }
}

Write the contents of the JSONObject as JSON text to a writer. For compactness, no whitespace is added.

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