Log.e( "ssss" , str1.hashCode() + ":" + str1); try { JSONObject obj = new JSONObject (str1); String str2 = obj.toString(); Log.e( "ssss" , str2.hashCode() + ":" + str2); } catch (JSONException e) { e.printStackTrace();

打印结果：

E/ssss: -1703691961:{"id":"1/2"}
E/ssss: -1233361487:{"id":"1\/2"}
可以发现前后两个String不一样了，经过JSON后/多了一个\，所以hashcode也一样。在某些情况下就会造成一定的困扰，比如加密后传输然后解密。
那么为什么会出现这种情况？一定是JSONObject的toString方法中有一些处理，我们来看一下：
@Override @NonNull public String toString() {
    try {
        JSONStringer stringer = new JSONStringer();
        writeTo(stringer);
        return stringer.toString();
    } catch (JSONException e) {
        return null;
可以看到创建一个JSONStringer，然后调用writeTo函数：
void writeTo(JSONStringer stringer) throws JSONException {
    stringer.object();
    for (Map.Entry<String, Object> entry : nameValuePairs.entrySet()) {
        stringer.key(entry.getKey()).value(entry.getValue());
    stringer.endObject();
这里将JSON的键值对对应放入JSONStringer对象，然后我们看看value函数：
public JSONStringer value(Object value) throws JSONException {
    if (stack.isEmpty()) {
        throw new JSONException("Nesting problem");
    if (value instanceof JSONArray) {
        ((JSONArray) value).writeTo(this);
        return this;
    } else if (value instanceof JSONObject) {
        ((JSONObject) value).writeTo(this);
        return this;
    beforeValue();
    if (value == null
            || value instanceof Boolean
            || value == JSONObject.NULL) {
        out.append(value);
    } else if (value instanceof Number) {
        out.append(JSONObject.numberToString((Number) value));
    } else {
        string(value.toString());
    return this;
可以看到如果value是JSONObject或JSONArray，那么又执行writeTo一层一层的解析。直到value不是JSON类型，这时候如果不是null，boolean或number类型，就会调用string函数来处理value.toString()。所以可以看到不是简单的toString，那么string函数又作了什么？
private void string(String value) {
    out.append("\"");
    for (int i = 0, length = value.length(); i < length; i++) {
        char c = value.charAt(i);
         * From RFC 4627, "All Unicode characters may be placed within the
         * quotation marks except for the characters that must be escaped:
         * quotation mark, reverse solidus, and the control characters
         * (U+0000 through U+001F)."
        switch (c) {
            case '"':
            case '\\':
            case '/':
                out.append('\\').append(c);
                break;
            case '\t':
                out.append("\\t");
                break;
            case '\b':
                out.append("\\b");
                break;
            case '\n':
                out.append("\\n");
                break;
            case '\r':
                out.append("\\r");
                break;
            case '\f':
                out.append("\\f");
                break;
            default:
                if (c <= 0x1F) {
                    out.append(String.format("\\u%04x", (int) c));
                } else {
                    out.append(c);
                break;
    out.append("\"");
可以看到处理的基本都是特殊符号，如\t，\n这类的，其中也处理了/，在它前面加了\\转义字符，这实际上就是将/变成了\/。
这里我们找到根源了，但是还比较诱惑，JSON为什么要这么做？在字符串中“/”并不会出现问题，为什么一定要转换一下？
在百度百科“转义字符”这里可以看到，国际上并没有规定“/”需要转义。
在json的官网中（www.json.org/ ），可以看到是有这一项：
escape
    'u' hex hex hex hex
说明这是JSON自己规定的，那么JSON为什么单独规定这么一条？
根据网上的说法，是为了防止干扰标签<></>（如<script></script>），因为一个字符串中如果出现</就会被解析成标签，这样很容易出现问题，所以将“/”进行了转义。
再看看几种情况
1、如果是多个“/”，比如{\"id\":\"1////2\"}，执行结果
E/ssss: -1134829468:{"id":"1////2"}
E/ssss: 1868680280:{"id":"1\/\/\/\/2"}
所以无论有几个，都会转
2、如果本身就是\/呢？如{\"id\":\"1\\/2\"}
E/ssss: -1233361487:{"id":"1\/2"}
E/ssss: -1233361487:{"id":"1\/2"}
可以看到就不会转义了
3、{\"id\":\"1\\//2\"}，结果是
E/ssss: 420422874:{"id":"1\//2"}
E/ssss: 189688958:{"id":"1\/\/2"}
所以，我们可以得出结论，如果是\/就不会再转义，否则都会将/转成\/。
但是！！！JS
在js中使用JSON.stringify()函数却不会将/自动转成\/，这样就造成了问题，因为js和java两端处理并不一致。
那么我们怎么避免这种情况？防止两端不一致？
如果在JSONObject.toString之后，替换\/为/呢，显然不行，因为如果本来字符串中就有"/"的话，也会被替换成"/"，这样前后依然不一致。
比较好的处理方法是，在最开始将字符串中不是\/的/都转成\/。