net.sourceforge.jweb.json.JSONArray Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jweb-common Show documentation
Show all versions of jweb-common Show documentation
本项目主要弥补在使用mybatis3+springmvc+jquery easyui快速搭建web应用系统是遇到的框架不足.
主要工作包括：
1，扩展了ApplicationContextAware，通过单例注入spring容器，提供spring容器外的bean获取方法
2，扩展了apache shiro框架，统一了安全结构
3，扩展了mybatis3拦截器，在两个拦截器中自动完成分页注入，实现内存分页。
4，分页设计数据库方言
5，提供了一个easyuigrid的模型
6，提供了java泛型的jstl
7， xml工具包等一些小工具
The newest version!
package net.sourceforge.jweb.json;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.RandomAccess;
/**
* A JSONArray is an ordered sequence of values. Its external text form is a
* string wrapped in square brackets with commas separating the values. The
* internal form is an object having get and opt
* methods for accessing the values by index, and put methods for
* adding or replacing values. The values can be any of these types:
* Boolean, JSONArray, JSONObject,
* Number, String, or the
* JSONObject.NULL object.
*
* The constructor can convert a JSON text into a Java object. The
* toString method converts to JSON text.
*
* A get method returns a value if one can be found, and throws an
* exception if one cannot be found. An opt method returns a
* default value instead of throwing an exception, and so is useful for
* obtaining optional values.
*
* The generic get() and opt() methods return an
* object which you can cast or query for type. There are also typed
* get and opt methods that do type checking and type
* coersion for you.
*
* The texts produced by the toString methods strictly conform to
* JSON syntax rules. The constructors are more forgiving in the texts they will
* accept:
*
* - An extra
, (comma) may appear just
* before the closing bracket.
* - The
null value will be inserted when there is
* , (comma) elision.
* - Strings may be quoted with
' (single
* quote).
* - Strings do not need to be quoted at all if they do not begin with a quote
* or single quote, and if they do not contain leading or trailing spaces, and
* if they do not contain any of these characters:
*
{ } [ ] / \ : , = ; # and if they do not look like numbers and
* if they are not the reserved words true, false, or
* null.
* - Values can be separated by
; (semicolon) as
* well as by , (comma).
* - Numbers may have the
0- (octal) or
* 0x- (hex) prefix.
* - Comments written in the slashshlash, slashstar, and hash conventions will
* be ignored.
*
*
* @author JSON.org
* @version 2
*/
public class JSONArray extends JSONElement implements List, RandomAccess, Cloneable, java.io.Serializable {
private static final long serialVersionUID = 7714328354182154375L;
/**
* The arrayList where the JSONArray's properties are kept.
*/
private ArrayList myArrayList;
/**
* Construct an empty JSONArray.
*/
public JSONArray() {
myArrayList = new ArrayList();
}
/**
* Construct a JSONArray from a JSONTokener.
*
* @param x
* A JSONTokener
* @throws JSONException
* If there is a syntax error.
*/
public JSONArray(JSONTokener x) throws JSONException {
this();
if (x.nextClean() != '[') {
throw x.syntaxError("A JSONArray text must start with '['");
}
if (x.nextClean() == ']') {
return;
}
x.back();
for (;;) {
if (x.nextClean() == ',') {
x.back();
myArrayList.add(null);
} else {
x.back();
myArrayList.add(x.nextValue());
}
switch (x.nextClean()) {
case ';':
case ',':
if (x.nextClean() == ']') {
return;
}
x.back();
break;
case ']':
return;
default:
throw x.syntaxError("Expected a ',' or ']'");
}
}
}
/**
* Construct a JSONArray from a source sJSON text.
*
* @param string
* A string that begins with [ (left
* bracket) and ends with ] (right
* bracket).
* @throws JSONException
* If there is a syntax error.
*/
public JSONArray(String string) throws JSONException {
this(new JSONTokener(string));
}
/**
* Construct a JSONArray from a Collection.
*
* @param collection
* A Collection.
*/
public JSONArray(Collection collection) {
myArrayList = new ArrayList(collection);
}
/**
* Construct a JSONArray from a Java Array
*
* @param array
* an Array
*/
public JSONArray(Object[] array) {
myArrayList = new ArrayList(Arrays.asList(array));
}
/**
* Get the object value associated with an index.
*
* @param index
* The index must be between 0 and length() - 1.
* @return An object value.
* @throws IndexOutOfBoundsException
* If there is no value for the index.
*/
public Object get(int index) {
Object o = opt(index);
if (o == null) {
throw new IndexOutOfBoundsException("JSONArray[" + index + "] not found.");
}
return o;
}
/**
* Get the boolean value associated with an index. The string values "true" and
* "false" are converted to boolean.
*
* @param index
* The index must be between 0 and length() - 1.
* @return The truth.
* @throws JSONException
* If there is no value for the index or if the value is not
* convertable to boolean.
*/
public boolean getBoolean(int index) throws JSONException {
Object o = get(index);
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("JSONArray[" + index + "] is not a Boolean.");
}
/**
* Get the double value associated with an index.
*
* @param index
* The index must be between 0 and length() - 1.
* @return The value.
* @throws JSONException
* If the key is not found or if the value cannot be converted to a
* number.
*/
public double getDouble(int index) throws JSONException {
Object o = get(index);
try {
return o instanceof Number ? ((Number) o).doubleValue() : Double.parseDouble((String) o);
} catch (Exception e) {
throw new JSONException("JSONArray[" + index + "] is not a number.");
}
}
/**
* Get the int value associated with an index.
*
* @param index
* The index must be between 0 and length() - 1.
* @return The value.
* @throws JSONException
* If the key is not found or if the value cannot be converted to a
* number. if the value cannot be converted to a number.
*/
public int getInt(int index) throws JSONException {
Object o = get(index);
return o instanceof Number ? ((Number) o).intValue() : (int) getDouble(index);
}
/**
* Get the JSONArray associated with an index.
*
* @param index
* The index must be between 0 and length() - 1.
* @return A JSONArray value.
* @throws JSONException
* If there is no value for the index. or if the value is not a
* JSONArray
*/
public JSONArray getJSONArray(int index) throws JSONException {
Object o = get(index);
if (o instanceof JSONArray) {
return (JSONArray) o;
}
throw new JSONException("JSONArray[" + index + "] is not a JSONArray.");
}
/**
* Get the JSONObject associated with an index.
*
* @param index
* subscript
* @return A JSONObject value.
* @throws JSONException
* If there is no value for the index or if the value is not a
* JSONObject
*/
public JSONObject getJSONObject(int index) throws JSONException {
Object o = get(index);
if (o instanceof JSONObject) {
return (JSONObject) o;
}
throw new JSONException("JSONArray[" + index + "] is not a JSONObject.");
}
/**
* Get the long value associated with an index.
*
* @param index
* The index must be between 0 and length() - 1.
* @return The value.
* @throws JSONException
* If the key is not found or if the value cannot be converted to a
* number.
*/
public long getLong(int index) throws JSONException {
Object o = get(index);
return o instanceof Number ? ((Number) o).longValue() : (long) getDouble(index);
}
/**
* Get the string associated with an index.
*
* @param index
* The index must be between 0 and length() - 1.
* @return A string value.
* @throws JSONException
* If there is no value for the index.
*/
public String getString(int index) throws JSONException {
return get(index).toString();
}
/**
* Determine if the value is null.
*
* @param index
* The index must be between 0 and length() - 1.
* @return true if the value at the index is null, or if there is no value.
*/
public boolean isNull(int index) {
return JSONObject.NULL.equals(opt(index));
}
/**
* 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.
*
* @param separator
* A string that will be inserted between the elements.
* @return a string.
* @throws JSONException
* If the array contains an invalid number.
*/
public String join(String separator) throws JSONException {
int len = length();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < len; i += 1) {
if (i > 0) {
sb.append(separator);
}
Object item = myArrayList.get(i);
if (item instanceof String) {
sb.append(this.isQuotoValue() ? this.getQuotoString() : "").append(item.toString())
.append(this.isQuotoValue() ? this.getQuotoString() : "");
} else {
sb.append(item.toString());
}
}
return sb.toString();
}
/**
* Get the number of elements in the JSONArray, included nulls.
*
* @return The length (or size).
*/
public int length() {
return size();
}
/**
* Get the optional object value associated with an index.
*
* @param index
* The index must be between 0 and length() - 1.
* @return An object value, or null if there is no object at that index.
*/
public Object opt(int index) {
return (index < 0 || index >= length()) ? null : myArrayList.get(index);
}
/**
* Get the optional boolean value associated with an index. It returns false if
* there is no value at that index, or if the value is not Boolean.TRUE or the
* String "true".
*
* @param index
* The index must be between 0 and length() - 1.
* @return The truth.
*/
public boolean optBoolean(int index) {
return optBoolean(index, false);
}
/**
* Get the optional boolean value associated with an index. It returns the
* defaultValue if there is no value at that index or if it is not a Boolean or
* the String "true" or "false" (case insensitive).
*
* @param index
* The index must be between 0 and length() - 1.
* @param defaultValue
* A boolean default.
* @return The truth.
*/
public boolean optBoolean(int index, boolean defaultValue) {
try {
return getBoolean(index);
} catch (Exception e) {
return defaultValue;
}
}
/**
* Get the optional double value associated with an index. NaN is returned if
* there is no value for the index, or if the value is not a number and cannot
* be converted to a number.
*
* @param index
* The index must be between 0 and length() - 1.
* @return The value.
*/
public double optDouble(int index) {
return optDouble(index, Double.NaN);
}
/**
* Get the optional double value associated with an index. The defaultValue is
* returned if there is no value for the index, or if the value is not a number
* and cannot be converted to a number.
*
* @param index
* subscript
* @param defaultValue
* The default value.
* @return The value.
*/
public double optDouble(int index, double defaultValue) {
try {
return getDouble(index);
} catch (Exception e) {
return defaultValue;
}
}
/**
* Get the optional int value associated with an index. Zero is returned if
* there is no value for the index, or if the value is not a number and cannot
* be converted to a number.
*
* @param index
* The index must be between 0 and length() - 1.
* @return The value.
*/
public int optInt(int index) {
return optInt(index, 0);
}
/**
* Get the optional int value associated with an index. The defaultValue is
* returned if there is no value for the index, or if the value is not a number
* and cannot be converted to a number.
*
* @param index
* The index must be between 0 and length() - 1.
* @param defaultValue
* The default value.
* @return The value.
*/
public int optInt(int index, int defaultValue) {
try {
return getInt(index);
} catch (Exception e) {
return defaultValue;
}
}
/**
* Get the optional JSONArray associated with an index.
*
* @param index
* subscript
* @return A JSONArray value, or null if the index has no value, or if the value
* is not a JSONArray.
*/
public JSONArray optJSONArray(int index) {
Object o = opt(index);
return o instanceof JSONArray ? (JSONArray) o : null;
}
/**
* Get the optional JSONObject associated with an index. Null is returned if the
* key is not found, or null if the index has no value, or if the value is not a
* JSONObject.
*
* @param index
* The index must be between 0 and length() - 1.
* @return A JSONObject value.
*/
public JSONObject optJSONObject(int index) {
Object o = opt(index);
return o instanceof JSONObject ? (JSONObject) o : null;
}
/**
* Get the optional long value associated with an index. Zero is returned if
* there is no value for the index, or if the value is not a number and cannot
* be converted to a number.
*
* @param index
* The index must be between 0 and length() - 1.
* @return The value.
*/
public long optLong(int index) {
return optLong(index, 0);
}
/**
* Get the optional long value associated with an index. The defaultValue is
* returned if there is no value for the index, or if the value is not a number
* and cannot be converted to a number.
*
* @param index
* The index must be between 0 and length() - 1.
* @param defaultValue
* The default value.
* @return The value.
*/
public long optLong(int index, long defaultValue) {
try {
return getLong(index);
} catch (Exception e) {
return defaultValue;
}
}
/**
* Get the optional string value associated with an index. It returns an empty
* string if there is no value at that index. If the value is not a string and
* is not null, then it is coverted to a string.
*
* @param index
* The index must be between 0 and length() - 1.
* @return A String value.
*/
public String optString(int index) {
return optString(index, "");
}
/**
* Get the optional string associated with an index. The defaultValue is
* returned if the key is not found.
*
* @param index
* The index must be between 0 and length() - 1.
* @param defaultValue
* The default value.
* @return A String value.
*/
public String optString(int index, String defaultValue) {
Object o = opt(index);
return o != null ? o.toString() : defaultValue;
}
/**
* Append a boolean value. This increases the array's length by one.
*
* @param value
* A boolean value.
* @return this
*/
public JSONArray put(boolean value) {
put(value ? Boolean.TRUE : Boolean.FALSE);
return this;
}
/**
* Append a double value. This increases the array's length by one.
*
* @param value
* A double value.
* @throws JSONException
* if the value is not finite.
* @return this.
*/
public JSONArray put(double value) throws JSONException {
Double d = new Double(value);
JSONObject.testValidity(d);
put(d);
return this;
}
/**
* Append an int value. This increases the array's length by one.
*
* @param value
* An int value.
* @return this.
*/
public JSONArray put(int value) {
put(new Integer(value));
return this;
}
/**
* Append an long value. This increases the array's length by one.
*
* @param value
* A long value.
* @return this.
*/
public JSONArray put(long value) {
put(new Long(value));
return this;
}
/**
* Append an object value. This increases the array's length by one.
*
* @param value
* An object value. The value should be a Boolean, Double, Integer,
* JSONArray, JSObject, Long, or String, or the JSONObject.NULL
* object.
* @return this.
*/
public JSONArray put(Object value) {
add(value);
return this;
}
/**
* Put or replace a boolean 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.
*
* @param index
* The subscript.
* @param value
* A boolean value.
* @return this.
* @throws JSONException
* If the index is negative.
*/
public JSONArray put(int index, boolean value) throws JSONException {
put(index, Boolean.valueOf(value));
return this;
}
/**
* Put or replace a double value. If the index is greater than the length of the
* JSONArray, then null elements will be added as necessary to pad it out.
*
* @param index
* The subscript.
* @param value
* A double value.
* @return this.
* @throws JSONException
* If the index is negative or if the value is not finite.
*/
public JSONArray put(int index, double value) throws JSONException {
put(index, new Double(value));
return this;
}
/**
* Put or replace an int value. If the index is greater than the length of the
* JSONArray, then null elements will be added as necessary to pad it out.
*
* @param index
* The subscript.
* @param value
* An int value.
* @return this.
* @throws JSONException
* If the index is negative.
*/
public JSONArray put(int index, int value) throws JSONException {
put(index, new Integer(value));
return this;
}
/**
* Put or replace a long value. If the index is greater than the length of the
* JSONArray, then null elements will be added as necessary to pad it out.
*
* @param index
* The subscript.
* @param value
* A long value.
* @return this.
* @throws JSONException
* If the index is negative.
*/
public JSONArray put(int index, long value) throws JSONException {
put(index, new Long(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.
*
* @param index
* The subscript.
* @param value
* The value to put into the array.
* @return this.
* @throws JSONException
* If the index is negative or if the the value is an invalid
* number.
*/
public JSONArray put(int index, Object value) throws JSONException {
JSONObject.testValidity(value);
if (index < 0) {
throw new JSONException("JSONArray[" + index + "] not found.");
}
if (index < length()) {
myArrayList.set(index, value);
} else {
while (index != length()) {
put(null);
}
put(value);
}
return this;
}
/**
* Produce a JSONObject by combining a JSONArray of names with the values of
* this JSONArray.
*
* @param names
* A JSONArray containing a list of key strings. These will be paired
* with the values.
* @return A JSONObject, or null if there are no names or if this JSONArray has
* no values.
* @throws JSONException
* If any of the names are null.
*/
public JSONObject toJSONObject(JSONArray names) throws JSONException {
if (names == null || names.length() == 0 || length() == 0) {
return null;
}
JSONObject jo = new JSONObject();
for (int i = 0; i < names.length(); i += 1) {
jo.put(names.getString(i), opt(i));
}
return jo;
}
/**
* Make an 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.
*
* @return a printable, displayable, transmittable representation of the array.
*/
public String toString() {
try {
return '[' + join(",") + ']';
} catch (Exception e) {
return null;
}
}
public boolean add(Object o) {
return myArrayList.add(o);
}
public void add(int index, Object element) {
myArrayList.add(index, element);
}
public boolean addAll(Collection c) {
return myArrayList.add(c);
}
public boolean addAll(int index, Collection c) {
return myArrayList.addAll(index, c);
}
public void clear() {
myArrayList.clear();
}
public boolean contains(Object o) {
return myArrayList.contains(o);
}
public boolean containsAll(Collection c) {
return myArrayList.containsAll(c);
}
public int indexOf(Object o) {
return myArrayList.indexOf(o);
}
public boolean isEmpty() {
return myArrayList.isEmpty();
}
public Iterator iterator() {
return myArrayList.iterator();
}
public int lastIndexOf(Object o) {
return myArrayList.lastIndexOf(o);
}
public ListIterator listIterator() {
return myArrayList.listIterator();
}
public ListIterator listIterator(int index) {
return myArrayList.listIterator(index);
}
public boolean remove(Object o) {
return myArrayList.remove(o);
}
public Object remove(int index) {
return myArrayList.remove(index);
}
public boolean removeAll(Collection c) {
return myArrayList.removeAll(c);
}
public boolean retainAll(Collection c) {
return myArrayList.retainAll(c);
}
public Object set(int index, Object element) {
return myArrayList.set(index, element);
}
public int size() {
return myArrayList.size();
}
public List subList(int fromIndex, int toIndex) {
return myArrayList.subList(fromIndex, toIndex);
}
public Object[] toArray() {
return myArrayList.toArray();
}
public Object[] toArray(Object[] a) {
return myArrayList.toArray(a);
}
public Object clone() {
try {
JSONArray v = (JSONArray) super.clone();
v.myArrayList = (ArrayList) myArrayList.clone();
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError();
}
}
/**
* Returns true if this JSONArray is equal to the one passed in.
* The two arrays are considered equal if both arrays contain the same number of
* elements, and all corresponding pairs of elements in the two arrays are
* equal.
*
* @see java.lang.Object#equals(java.lang.Object)
*
* @param object
* The JSONArray to compare against
* @return true if the two arrays are equal
*/
public boolean equals(Object object) {
if (object == null) {
return false;
}
Object[] array1 = this.toArray();
Object[] array2 = ((JSONArray) object).toArray();
return (Arrays.equals(array1, array2));
}
/**
* Return a hashCode for the JSONArray. This returns the hashcode for the
* underlying Object[] that stores the array elements
*
* @see java.lang.Object#hashCode()
*
* @return a hash code value for this JSONArray.
*/
public int hashCode() {
return this.toArray().hashCode();
}
}