| Constructor: |
|---|
 public JSONObject() {
this.map = new HashMap();
}
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");
}
putOnce(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.
JSONException - If there is a syntax error in the source string
or a duplicated key.
|
public JSONObject(Map map) {
this.map = (map == null) ? new HashMap() : 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(Object bean) {
this();
populateInternalMap(bean, false);
} Construct a JSONObject from an Object using bean getters.
It reflects on all of the public methods of the object.
For each of the methods with no parameters and a name starting
with "get" or "is" followed by an uppercase letter,
the method is invoked, and a key and the value returned from the getter method
are put into the new JSONObject.
The key is formed by removing the "get" or "is" prefix. If the second remaining
character is not upper case, then the first
character is converted to lower case.
For example, if an object has a method named "getName", and
if the result of calling object.getName() is "Larry Fine",
then the JSONObject will contain "name": "Larry Fine". Parameters:
bean - An object that has getter methods that should be used
to make a JSONObject.
|
public JSONObject(String source) throws JSONException {
this(new JSONTokener(source));
} Construct a JSONObject from a source JSON text string.
This is the most commonly used JSONObject constructor. Parameters:
source - A string beginning
with { (left brace) and ending
with } (right brace).
JSONException - If there is a syntax error in the source
string or a duplicated key.
- exception:
JSONException - If there is a syntax error in the source
string or a duplicated key.
|
public JSONObject(JSONObject jo,
String[] names) throws JSONException {
this();
for (int i = 0; i < names.length; i += 1) {
putOnce(names[i], jo.opt(names[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.
names - An array of strings.
JSONException - If a value is a non-finite number or if a name is duplicated.
- exception:
JSONException - If a value is a non-finite number or if a name is duplicated.
|
public JSONObject(Map map,
boolean includeSuperClass) {
this.map = new HashMap();
if (map != null){
for (Iterator i = map.entrySet().iterator(); i.hasNext(); ) {
Map.Entry e = (Map.Entry)i.next();
this.map.put(e.getKey(), new JSONObject(e.getValue(), includeSuperClass));
}
}
} Construct a JSONObject from a Map.
Note: Use this constructor when the map contains . Parameters:
map - - A map with Key-Bean data.
includeSuperClass - - Tell whether to include the super class properties.
|
public JSONObject(Object bean,
boolean includeSuperClass) {
this();
populateInternalMap(bean, includeSuperClass);
} Construct JSONObject from the given bean. This will also create JSONObject
for all internal object (List, Map, Inner Objects) of the provided bean.
-- See Documentation of JSONObject(Object bean) also. Parameters:
bean - An object that has getter methods that should be used
to make a JSONObject.
includeSuperClass - - Tell whether to include the super class properties.
|
public JSONObject(Object object,
String[] names) {
this();
Class c = object.getClass();
for (int i = 0; i < names.length; i += 1) {
String name = names[i];
try {
putOpt(name, c.getField(name).get(object));
} 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 obtained
from the object.
|
| Method from org.apache.tomcat.util.json.JSONObject Detail: |
|---|
public JSONObject accumulate(String key,
Object value) throws JSONException {
testValidity(value);
Object o = opt(key);
if (o == null) {
put(key, value instanceof JSONArray ?
new JSONArray().put(value) :
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) {
put(key, ((JSONArray)o).put(value));
} else {
throw new JSONException("JSONObject[" + key +
"] is not a JSONArray.");
}
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 static String[] getNames(JSONObject jo) {
int length = jo.length();
if (length == 0) {
return null;
}
Iterator i = jo.keys();
String[] names = new String[length];
int j = 0;
while (i.hasNext()) {
names[j] = (String)i.next();
j += 1;
}
return names;
} Get an array of field names from a JSONObject. |
public static String[] getNames(Object object) {
if (object == null) {
return null;
}
Class klass = object.getClass();
Field[] fields = klass.getFields();
int length = fields.length;
if (length == 0) {
return null;
}
String[] names = new String[length];
for (int i = 0; i < length; i += 1) {
names[i] = fields[i].getName();
}
return names;
} Get an array of field names from an Object. |
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.map.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.map.keySet().iterator();
} Get an enumeration of the keys of the JSONObject. |
public int length() {
return this.map.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.map.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.map.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 putOnce(String key,
Object value) throws JSONException {
if (key != null && value != null) {
if (opt(key) != null) {
throw new JSONException("Duplicate key \"" + key + "\"");
}
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, and only if there is not already a member
with that name. |
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 b;
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) {
b = c;
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 < ' ' || (c >= '\u0080' && c < '\u00a0') ||
(c >= '\u2000' && c < '\u2100')) {
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.map.remove(key);
} Remove a name and its value, if present. |
public Iterator sortedKeys() {
return new TreeSet(this.map.keySet()).iterator();
} Get an enumeration of the keys of the JSONObject.
The keys will be sorted alphabetically. |
public static Object stringToValue(String s) {
if (s.equals("")) {
return s;
}
if (s.equalsIgnoreCase("true")) {
return Boolean.TRUE;
}
if (s.equalsIgnoreCase("false")) {
return Boolean.FALSE;
}
if (s.equalsIgnoreCase("null")) {
return JSONObject.NULL;
}
/*
* If it might be a number, try converting it. We support the 0- and 0x-
* conventions. If a number cannot be produced, then the value will just
* be a string. Note that the 0-, 0x-, plus, and implied string
* conventions are non-standard. A JSON parser is free to accept
* non-JSON forms as long as it accepts all correct JSON forms.
*/
char b = s.charAt(0);
if ((b >= '0' && b < = '9') || b == '.' || b == '-' || b == '+') {
if (b == '0') {
if (s.length() > 2 &&
(s.charAt(1) == 'x' || s.charAt(1) == 'X')) {
try {
return new Integer(Integer.parseInt(s.substring(2),
16));
} catch (Exception e) {
/* Ignore the error */
}
} else {
try {
return new Integer(Integer.parseInt(s, 8));
} catch (Exception e) {
/* Ignore the error */
}
}
}
try {
return new Integer(s);
} catch (Exception e) {
try {
return new Long(s);
} catch (Exception f) {
try {
return new Double(s);
} catch (Exception g) {
/* Ignore the error */
}
}
}
}
return s;
} Try to convert a string into a number, boolean, or null. If the string
can't be converted, return the string. |
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.map.get(o)));
}
sb.append('}');
return sb.toString();
} catch (Exception e) {
return null;
}
} |
public String toString(int indentFactor) throws JSONException {
return toString(indentFactor, 0);
} |
String toString(int indentFactor,
int indent) throws JSONException {
int j;
int n = length();
if (n == 0) {
return "{}";
}
Iterator keys = sortedKeys();
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.map.get(o), indentFactor,
indent));
} else {
while (keys.hasNext()) {
o = keys.next();
if (sb.length() > 1) {
sb.append(",\n");
} else {
sb.append('\n');
}
for (j = 0; j < newindent; j += 1) {
sb.append(' ');
}
sb.append(quote(o.toString()));
sb.append(": ");
sb.append(valueToString(this.map.get(o), indentFactor,
newindent));
}
if (sb.length() > 1) {
sb.append('\n');
for (j = 0; j < indent; j += 1) {
sb.append(' ');
}
}
}
sb.append('}');
return sb.toString();
} |
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();
}
if (value instanceof Map) {
return new JSONObject((Map)value).toString();
}
if (value instanceof Collection) {
return new JSONArray((Collection)value).toString();
}
if (value.getClass().isArray()) {
return new JSONArray(value).toString();
}
return quote(value.toString());
} |
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);
}
if (value instanceof Map) {
return new JSONObject((Map)value).toString(indentFactor, indent);
}
if (value instanceof Collection) {
return new JSONArray((Collection)value).toString(indentFactor, indent);
}
if (value.getClass().isArray()) {
return new JSONArray(value).toString(indentFactor, indent);
}
return quote(value.toString());
} |
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.map.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);
}
} |
org.apache.tomcat.util.json.JSONObject