根据json的key获取到对应的value

前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站。

项目中偶尔会用到解析json，然后获取某个key的值的问题，这个有两个办法，一个是通过json创建一个对象出来，然后通过json转对象，然后通过对象获取对应的value，第二个是通过JsonObject获取对应key的value，但是只能从顶级一层一层的获取你想要的值。
如果json简单，两种方法都可以。如果json复杂一点，两种方法都挺麻烦的，所以就打算自己写一个工具类，通过传进去一个key就能直接获取到value了。
但是有个问题就是如果key有多个重复的话就只能获取到第一个key了，不过这个问题也可以解决，先获取重复key外层的key对应的value，然后获取到的json再多次获取就可以了。
talk is cheap，show you my code.
json解析用的是fastjson

public class JsonUtil {

    /**
     *  json字符串 转对象
     * @param jsonString
     * @param <T>
     * @return
     */
    public static <T> T toObject(String jsonString , Class<T> clz){
        if (StringUtils.isNotEmpty(jsonString)) {
            return JSON.parseObject(jsonString , clz);
        }
        return null;
    }

    /**
     *  jsonString 转list
     * @param jsonString
     * @param clz
     * @param <T>
     * @return
     */
    public static <T> List<T> toList(String jsonString , Class<T> clz){
        if (StringUtils.isNotEmpty(jsonString)) {
            return JSON.parseArray(jsonString, clz);
        }
        return Collections.emptyList();
    }

    /**
     *  对象转json字符串
     * @param object
     * @return
     */
    public static String toJsonString(Object object){
        if (object != null) {
            return JSON.toJSONString(object);
        }
        return null;
    }

    /**
     *  根据json 中的可以 获取对应value，只会获取第一个被匹配到的值
     * @param json json 字符串
     * @param key
     * @return 返回结果类型可能是 JSONObject、String、JSONArray
     */
    public static Object getJsonValue(String json , String key){
        if (StringUtils.isNotEmpty(json) && StringUtils.isNotEmpty(key)) {
            Object object = JSON.parse(json);
            if (object != null) {
                if (object instanceof JSONObject) {
                    return getJsonValue((JSONObject) object, key);
                }else if (object instanceof  JSONArray){
                    return getJsonValue((JSONArray) object, key);
                }
            }
            return object;
        }
        throw new IllegalArgumentException("param json or key cannot be empty.");
    }


    /**
     *  根据json 中的可以 获取对应value，只会获取第一个被匹配到的值
     * @param jsonObject
     * @param key
     * @return 返回结果类型可能是 JSONObject、String、JSONArray
     */
    public static Object getJsonValue(JSONObject jsonObject , String key) {
        if (jsonObject != null && StringUtils.isNotEmpty(key)) {
            for (Map.Entry<String, Object> entry : jsonObject.entrySet()) {
                String entryKey = entry.getKey();
                Object value = entry.getValue();
                if (key.equals(entryKey)) {
                    return value;
                } else {
                    if (value != null) {
                        String s = value.toString();
                        if (StringUtils.isNotEmpty(s)) {
                            Object jsonValue = getJsonValue(value, key);
                            if (jsonValue != null) {
                                return jsonValue;
                            }
                        }
                    }
                }
            }
            return null;
        }
        throw new IllegalArgumentException("param jsonObject or key cannot by empty.");
    }

    public static Object getJsonValue(Object object , String key){
        if (object != null && StringUtils.isNotEmpty(key)) {
            if (object instanceof JSONObject) {
                return getJsonValue((JSONObject) object, key);
            }else if (object instanceof JSONArray){
                return getJsonValue((JSONArray) object, key);
            }
        }
        return null;
    }

    public static Object getJsonValue(JSONArray jsonArray , String key) {
        if (jsonArray != null && StringUtils.isNotEmpty(key)) {
            for (Object next : jsonArray) {
                if (next != null) {
                    return getJsonValue(next, key);
                }
            }
        }
        return null;
    }
}

测试：
json 如下：

{
   "results" : [
      {
         "access_points" : [],
         "address_components" : [
            {
               "long_name" : "1600",
               "short_name" : "1600",
               "types" : [ "street_number" ]
            },
            {
               "long_name" : "Amphitheatre Parkway",
               "short_name" : "Amphitheatre Pkwy",
               "types" : [ "route" ]
            },
            {
               "long_name" : "Mountain View",
               "short_name" : "Mountain View",
               "types" : [ "locality", "political" ]
            },
            {
               "long_name" : "Santa Clara County",
               "short_name" : "Santa Clara County",
               "types" : [ "administrative_area_level_2", "political" ]
            },
            {
               "long_name" : "California",
               "short_name" : "CA",
               "types" : [ "administrative_area_level_1", "political" ]
            },
            {
               "long_name" : "美国",
               "short_name" : "US",
               "types" : [ "country", "political" ]
            },
            {
               "long_name" : "94043",
               "short_name" : "94043",
               "types" : [ "postal_code" ]
            }
         ],
         "formatted_address" : "1600 Amphitheatre Pkwy, Mountain View, CA 94043美国",
         "geometry" : {
            "location" : {
               "lat" : 37.4223097,
               "lng" : -122.0846245
            },
            "location_type" : "ROOFTOP",
            "viewport" : {
               "northeast" : {
                  "lat" : 37.4236586802915,
                  "lng" : -122.0832755197085
               },
               "southwest" : {
                  "lat" : 37.4209607197085,
                  "lng" : -122.0859734802915
               }
            }
         },
         "place_id" : "ChIJtYuu0V25j4ARwu5e4wwRYgE",
         "plus_code" : {
            "compound_code" : "CWC8+W5 美国 California, 山景城",
            "global_code" : "849VCWC8+W5"
         },
         "types" : [ "street_address" ]
      }
   ],
   "status" : "OK"
}

Object content = JsonUtil.getJsonValue(json, "northeast");

结果：

{"lng":-122.0832755197085,"lat":37.4236586802915}

通过fastjson源码可以看到，json解析用的是map，所以获取的时候也是根据map的特性来获取的。
可以看到能够获取到对应key的value，但是前面也说了，重复的key的话只能获取到第一个value。
如果用对象的或者一层一层获取的话不会存在这个问题。

能力有限，水平一般，如果有更好的方法请评论告诉我。