jsonobject详解_object转json字符串

//版本可选择
<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.47</version>
</dependency>

public class JSONObject extends JSON 
	implements Map<String, Object>, Cloneable, Serializable, InvocationHandler

 	private static final long         serialVersionUID         = 1L;
    private static final int          DEFAULT_INITIAL_CAPACITY = 16;

    private final Map<String, Object> map;

ANY-ACCESS-MODIFIER static final long serialVersionUID = 1L;

	//构造容量为16个单位的HashMap作为JSONObject
	public JSONObject(){
		//调用public JSONObject(int initialCapacity, boolean ordered)
        this(DEFAULT_INITIAL_CAPACITY, false);
    }
	//构造自定义Map<String, Object> 容器类型的JSONObject
    public JSONObject(Map<String, Object> map){
        if (map == null) {
            throw new IllegalArgumentException("map is null.");
        }
        this.map = map;
    }
	//构造容量为16个单位JSONObject，可选择器容器是否有序：LinkedHashMap（true）、HashMap(false)
    public JSONObject(boolean ordered){
        this(DEFAULT_INITIAL_CAPACITY, ordered);
    }
	//构造自定义初始大小的HashMap类型的JSONObject
    public JSONObject(int initialCapacity){
        this(initialCapacity, false);
    }

    public JSONObject(int initialCapacity, boolean ordered){
        if (ordered) {
            map = new LinkedHashMap<String, Object>(initialCapacity);
        } else {
            map = new HashMap<String, Object>(initialCapacity);
        }
    }

	//构造容量为16个单位的HashMap作为JSONObject
    JSONObject jsonObject = new JSONObject();
    
    //构造容量为16个单位JSONObject，可选择器容器是否有序:LinkedHashMap（true）、HashMap(false)
    JSONObject jsonObject1 = new JSONObject(true);
    
     //构造自定义Map<String, Object> 容器类型的JSONObject
    Map<String,Object> map = new ConcurrentHashMap<>(16);
    JSONObject jsonObject2 = new JSONObject(map);
    
    //自定义
    JSONObject jsonObject3 = new JSONObject(32, false);

	public int size() {
        return map.size();
    }

    public boolean isEmpty() {
        return map.isEmpty();

    public boolean containsKey(Object key) {
        return map.containsKey(key);
    }
	
	//让我看看HashMap的底层实现：根据key的hash值和key取找，若找到返回该节点，如果没有，则为空
    public boolean containsKey(Object key) {
        return getNode(hash(key), key) != null;
    }
    
	final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

public boolean containsValue(Object value) {
    return map.containsValue(value);
}

//HashMap的实现：逐个遍历HashMap的桶中的每个个元素，如果值相等返回true，遍历了所有元素都没有则返回false.
public boolean containsValue(Object value) {
        Node<K,V>[] tab; V v;
        if ((tab = table) != null && size > 0) {
            for (int i = 0; i < tab.length; ++i) {
                for (Node<K,V> e = tab[i]; e != null; e = e.next) {
                    if ((v = e.value) == value ||
                        (value != null && value.equals(v)))
                        return true;
                }
            }
        }
        return false;
    }

	public Object get(Object key) {
        Object val = map.get(key);

        if (val == null && key instanceof Number) {
            val = map.get(key.toString());
        }

        return val;
    }
    
	看看HashMap的实现：如果e不为null，但他的映射值为null的话，e.value=null。所以返回值 null不一定表示该映射不包含键的映射，故需要继续判断 if (val == null && key instanceof Number)
	public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

	public JSONObject getJSONObject(String key) {
        Object value = map.get(key);

		//如果为JSONObject对象，则将结果强转为JSONObject
        if (value instanceof JSONObject) {
            return (JSONObject) value;
        }
        
		//如果为Map对象，则生成指定Map容器的JSONObject
        if (value instanceof Map) {
            return new JSONObject((Map) value);
        }

		//如果为Map对象，则生成指定Map容器的JSONObject
        if (value instanceof String) {
            return JSON.parseObject((String) value);
        }
		
		//返回JSONObject
        return (JSONObject) toJSON(value);
    }
    
	//toJSON是JSON类的方法
	//通过判断参数的各种类型，将指定的对象序列化为其参数等价表示的JavaObject
	public static Object toJSON(Object javaObject) {
        return toJSON(javaObject, SerializeConfig.globalInstance);
    }
	@SuppressWarnings("unchecked")
    public static Object toJSON(Object javaObject, SerializeConfig config) {
        if (javaObject == null) {
            return null;
        }

        if (javaObject instanceof JSON) {
            return javaObject;
        }

        if (javaObject instanceof Map) {
            Map<Object, Object> map = (Map<Object, Object>) javaObject;

            int size = map.size();

            Map innerMap;
            if (map instanceof LinkedHashMap) {
                innerMap = new LinkedHashMap(size);
            } else if (map instanceof TreeMap) {
                innerMap = new TreeMap();
            } else {
                innerMap = new HashMap(size);
            }

            JSONObject json = new JSONObject(innerMap);

            for (Map.Entry<Object, Object> entry : map.entrySet()) {
                Object key = entry.getKey();
                String jsonKey = TypeUtils.castToString(key);
                Object jsonValue = toJSON(entry.getValue(), config);
                json.put(jsonKey, jsonValue);
            }

            return json;
        }

	public JSONArray getJSONArray(String key) {
        Object value = map.get(key);

        if (value instanceof JSONArray) {
            return (JSONArray) value;
        }

        if (value instanceof List) {
            return new JSONArray((List) value);
        }

        if (value instanceof String) {
            return (JSONArray) JSON.parse((String) value);
        }

        return (JSONArray) toJSON(value);
    }

	public <T> T getObject(String key, Class<T> clazz) {
        Object obj = map.get(key);
        //通过TypeUtils工具类转化成对应的clazz类型
        return TypeUtils.castToJavaBean(obj, clazz);
    }
    /*
	public static <T> T castToJavaBean(Object obj, Class<T> clazz){
		//底层是判断clazz的类型，然后做出对应措施转成对应class对象
        return cast(obj, clazz, ParserConfig.getGlobalInstance());
    }

	*/
	//下面两个方法同理
    public <T> T getObject(String key, Type type) {
        Object obj = map.get(key);
        return TypeUtils.cast(obj, type, ParserConfig.getGlobalInstance());
    }

    public <T> T getObject(String key, TypeReference typeReference) {
        Object obj = map.get(key);
        if (typeReference == null) {
            return (T) obj;
        }
        return TypeUtils.cast(obj, typeReference.getType(), ParserConfig.getGlobalInstance());
    }

	public Boolean getBoolean(String key) {
Object value = get(key);
if (value == null) {
return null;
}
//使用的都是TypeUtils的方法，
return castToBoolean(value);
}
暂对getBoolean的 castToBoolean(value)做解析。
/*com.alibaba.fastjson.util.TypeUtils#castToBoolean:
public static Boolean castToBoolean(Object value){
//value为null则返回null
if(value == null){
return null;
}
//如果是Boolean类型则强转为Boolean
if(value instanceof Boolean){
return (Boolean) value;
}
//如果value是BigDecimal类型，
if(value instanceof BigDecimal){
//intValue先对BigDecimal的值进行判断,当scale在-100~100之间【如：19/100 = 0.19 则 integer=19, scale=2 】
//调用decimal.intValue()，反之调用decimal.intValueExact()，得到int的值, 当int类型的值为1返回true
return intValue((BigDecimal) value) == 1;
}
//如果为数值型【Number是基本类型的父类】，则调用对应包装类的intValue方法返回对应的值
if(value instanceof Number){
return ((Number) value).intValue() == 1;
}
//如果为字符串类型
if(value instanceof String){
//强转
String strVal = (String) value;
//null，NULL，length=0返回null
if(strVal.length() == 0 //
|| "null".equals(strVal) //
|| "NULL".equals(strVal)){
return null;
}
//如果是不区分大小写的"true"或者“1”,返回Boolean的TRUE字段
if("true".equalsIgnoreCase(strVal) //
|| "1".equals(strVal)){
// public static final Boolean TRUE = new Boolean(true);
return Boolean.TRUE;
}
//如果是不区分大小写的"false"或者“0”,返回Boolean的FALSE字段
if("false".equalsIgnoreCase(strVal) //
|| "0".equals(strVal)){
return Boolean.FALSE;
}
//"Y","T","y"返回TRUE
if("Y".equalsIgnoreCase(strVal) //
|| "T".equals(strVal)){
return Boolean.TRUE;
}
//"F","N","f"返回FALSE
if("F".equalsIgnoreCase(strVal) //
|| "N".equals(strVal)){
return Boolean.FALSE;
}
}
//都不满足则抛出异常
throw new JSONException("can not cast to boolean, value : " + value);
}
*/
public byte[] getBytes(String key) {
Object value = get(key);
if (value == null) {
return null;
}
return castToBytes(value);
}
public boolean getBooleanValue(String key) {
Object value = get(key);
Boolean booleanVal = castToBoolean(value);
if (booleanVal == null) {
return false;
}
return booleanVal.booleanValue();
}
public Byte getByte(String key) {
Object value = get(key);
return castToByte(value);
}
public byte getByteValue(String key) {
Object value = get(key);
Byte byteVal = castToByte(value);
if (byteVal == null) {
return 0;
}
return byteVal.byteValue();
}
public Short getShort(String key) {
Object value = get(key);
return castToShort(value);
}
public short getShortValue(String key) {
Object value = get(key);
Short shortVal = castToShort(value);
if (shortVal == null) {
return 0;
}
return shortVal.shortValue();
}
public Integer getInteger(String key) {
Object value = get(key);
return castToInt(value);
}
public int getIntValue(String key) {
Object value = get(key);
Integer intVal = castToInt(value);
if (intVal == null) {
return 0;
}
return intVal.intValue();
}
public Long getLong(String key) {
Object value = get(key);
return castToLong(value);
}
public long getLongValue(String key) {
Object value = get(key);
Long longVal = castToLong(value);
if (longVal == null) {
return 0L;
}
return longVal.longValue();
}
public Float getFloat(String key) {
Object value = get(key);
return castToFloat(value);
}
public float getFloatValue(String key) {
Object value = get(key);
Float floatValue = castToFloat(value);
if (floatValue == null) {
return 0F;
}
return floatValue.floatValue();
}
public Double getDouble(String key) {
Object value = get(key);
return castToDouble(value);
}
public double getDoubleValue(String key) {
Object value = get(key);
Double doubleValue = castToDouble(value);
if (doubleValue == null) {
return 0D;
}
return doubleValue.doubleValue();
}
public BigDecimal getBigDecimal(String key) {
Object value = get(key);
return castToBigDecimal(value);
}
public BigInteger getBigInteger(String key) {
Object value = get(key);
return castToBigInteger(value);
}
public String getString(String key) {
Object value = get(key);
if (value == null) {
return null;
}
return value.toString();
}
public Date getDate(String key) {
Object value = get(key);
return castToDate(value);
}
public java.sql.Date getSqlDate(String key) {
Object value = get(key);
return castToSqlDate(value);
}
public java.sql.Timestamp getTimestamp(String key) {
Object value = get(key);
return castToTimestamp(value);
}

	//新增一个key-value
public Object put(String key, Object value) {
return map.put(key, value);
}
//像流一样新增可新增key-value,因为其返回一个JSONObject 对象，可以继续调用JSONObject其他   方法，比如继续新增fluentPut
public JSONObject fluentPut(String key, Object value) {
map.put(key, value);
return this;
}
//将map的所有key-value添加到JSONObject中
public void putAll(Map<? extends String, ? extends Object> m) {
map.putAll(m);
}
//像流一样新增可新增多个map
public JSONObject fluentPutAll(Map<? extends String, ? extends Object> m) {
map.putAll(m);
return this;
}

	//清空所有key-value
public void clear() {
map.clear();
}
//清空所有key-value,并继续JSONObject 其他操作
public JSONObject fluentClear() {
map.clear();
return this;
}
//删除指定的key的对象
public Object remove(Object key) {
return map.remove(key);
}
/*HashMap的实现：通过removeNode找到并删除key-value
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
*/
//删除所有key-value,并继续JSONObject 其他操作
public JSONObject fluentRemove(Object key) {
map.remove(key);
return this;
}

	public Set<String> keySet() {
return map.keySet();
}

	public Set<Map.Entry<String, Object>> entrySet() {
return map.entrySet();
}

	@Override
public Object clone() {
return new JSONObject(map instanceof LinkedHashMap //
? new LinkedHashMap<String, Object>(map) //
: new HashMap<String, Object>(map)
);
}

	public boolean equals(Object obj) {
return this.map.equals(obj);
}
//hashmap底层实现，如果是同一个对象，则equals为true。如果是Map类型，则迭代每一个元素，判断值是否一样。
public final boolean equals(Object o) {
if (o == this)
return true;
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}

	public int hashCode() {
return this.map.hashCode();
}

	public <T> T toJavaObject(Class<T> clazz) {
//如果为Map,则直接强转为指定类型T
if (clazz == Map.class) {
return (T) this;
}
//当为Object对象并且不包含@type这个keys，也强转为指定类型T
if (clazz == Object.class && !containsKey(JSON.DEFAULT_TYPE_KEY)) {
return (T) this;
}
//通过TypeUtils工具类转换
return TypeUtils.castToJavaBean(this, clazz, ParserConfig.getGlobalInstance());
}
//根据 不同的ParserConfig转化成指定java对象
public <T> T toJavaObject(Class<T> clazz, ParserConfig config, int features) {
if (clazz == Map.class) {
return (T) this;
}
if (clazz == Object.class && !containsKey(JSON.DEFAULT_TYPE_KEY)) {
return (T) this;
}
return TypeUtils.castToJavaBean(this, clazz, config);
}