Vérifier si une clé existe ou non dans une étude JSON

Je suis coincé dans une situation où j'ai besoin de vérifier si une clé existe dans un imbriquée objet JSON. Par imbriquée Objet JSON que je vais avoir un objet JSON à l'intérieur de la mère d'objet JSON que la valeur de l'un de ses clés. J'ai donc besoin de vérifier si cette clé existe dans l'ensemble de l'objet JSON. Je suis au-dessous de données comme un String objet. Je sais que je peux analyser ce String objet pour obtenir l'objet JSON.

{
"claim_loss_type_cd": "TEL",
"claim_type": "002",
"claim_reason": "001",
"policy_number": "1234kk3366ff664",
"info": {
    "ApplicationContext": {
        "country": "US"
    }
  }
}

J'ai utilisé containsKey() méthode de vérification de la clé de l'existence dans le principal objet JSON et il fonctionne. Mais pour la vérification de tous les internes objet JSON comme "info" j'ai besoin d'analyser cette Object encore pour objet JSON, puis vérifiez à nouveau la touche.

        String jsonString = "My JSON String here";
        JSONObject finalResponse = new JSONObject(jsonString);
        finalResponse.containsKey("country"); //will return false
        JSONObject intermediateResponse = (JSONObject)finalResponse.get("info");
        intermediateResponse.containsKey("country"); //will return true

Si il ya une meilleure façon, une API ou une méthode qui peut vérifier à l'intérieur de tous les internes objet JSON aussi bien sans la nécessité de l'analyse de l'interne de l'objet JSON. Je suis à l'aide de com.ibm.json.java.JSONObject.JSONObject() natif IBM bibliothèque de Websphere Application Server et Aucune autre JSON analyseurs je suis à l'aide.

En considérant JSON, comme "claim_type" est une des clés de parents d'objet JSON, mais "d'infos", en soi, un objet JSON.
Donc, ce que j'ai à faire est de vérifier si une clé existe dans complet JSON, que ce soit dans la société mère ou de son enfant objet JSON clés comme "pays" ici en exemple.

EDIT:

Grâce à @chsdk je suis arrivé à une solution. Mais si quelqu'un d'autre est venu à la solution à l'aide d'une autre API, s'il vous plaît répondre, parce que ci-dessous la solution est de prendre la récursivité en compte & pourrait avoir un grand Espace/Temps de la Complexité.

public static boolean checkKey(JSONObject object, String searchedKey) {
    boolean exists = object.containsKey(searchedKey);
    if(!exists) {      
         Set<String> keys = object.keySet();
         for(String key : keys){
             if ( object.get(key) instanceof JSONObject ) {
                    exists = checkKey((JSONObject)object.get(key), searchedKey);
            }
         }
    }
    return exists;
}

avez-vous utilisé l'un parser JSON comme jakson etc ?
Les gars, JSON (le mot) n'est pas du code, de ne pas les mettre en forme dans un bloc de code..
quelqu'un m'a suggéré que JSON de mak comme le Code, j'ai donc accepté cette suggestion pour modifier
Si vous avez le JSON sous la forme d'une chaîne brute, peut-il être vérifié par rapport à la regex \"country\"\s*: ?
non, je ne suis pas à l'aide de toutes les analyseurs supplémentaires

InformationsquelleAutor Ankit Nigam | 2015-06-25

java json

4

Vous pouvez utiliser JSONObject pour analyser votre json et l'utilisation de son a(String key) méthode pour vérifier si une clé existe dans ce Json ou pas:
```
 String str="{\"claim_loss_type_cd\": \"TEL\",\"claim_type\":\"002\",\"claim_reason\": \"001\",\"policy_number\":\"1234kk3366ff664\",\"info\": {\"ApplicationContext\":{\"country\": \"US\"}}}";
 Object obj=JSONValue.parse(str);
 JSONObject json = (JSONObject) obj;
 //Then use has method to check if this key exists or not
 System.out.println(json.has("claim_type")); //Returns true
```
EDIT:

Ou mieux, vous pouvez simplement vérifier si la Chaîne JSON contient la valeur de cette clé, par exemple avec indexOf() méthode:
```
String str="{\"claim_loss_type_cd\": \"TEL\",\"claim_type\":\"002\",\"claim_reason\": \"001\",\"policy_number\":\"1234kk3366ff664\",\"info\": {\"ApplicationContext\":{\"country\": \"US\"}}}";
System.out.println(str.indexOf("claim_type")>-1); //Returns true
```
EDIT 2:

Prendre un coup d'oeil à cette méthode, il effectue une itération sur les objets imbriqués pour vérifier si la clé existe.
```
public boolean keyExists(JSONObject  object, String searchedKey) {
    boolean exists = object.has(searchedKey);
    if(!exists) {      
        Iterator<?> keys = object.keys();
        while( keys.hasNext() ) {
            String key = (String)keys.next();
            if ( object.get(key) instanceof JSONObject ) {
                    exists = keyExists(object.get(key), searchedKey);
            }
        }
    }
    return exists;
}

Object obj=JSONValue.parse(str);
JSONObject json = (JSONObject) obj;
System.out.println(keyExists(json, "country")); //Returns true
```
- J'ai édité ma question pour la bonne explication. Je ne veux pas de parser le JSON interne des objets. est-ce has() méthode permet de vérifier l'ensemble de l'json String et peut vérifier si une clé existe ou pas
- Non, il n'est pas de vérifier le JSONObjects, mais vous pouvez contrôler directement l'existence de la clé dans votre chaîne de caractères à partir du début.
- merci mais j'ai vraiment envie de vérifier, de toute JSON méthode plutôt que de manipuler avec de la Ficelle
- jetez un oeil à la méthode dans mon montage.
- oui ça a l'air prometteur & pour répondre à l'exigence, mais quel est le problème de performances, en l'appelant la méthode keyExists() de manière récursive
- Il n'y a pas de problème avec l'appelant récursivement, comme vous pouvez le voir si la clé sorties, il ne sera pas entrer dans la boucle depuis le début, et il sera appelé récursivement seulement avec imbriquée JSONObjects.
- Je vais vérifier & mise à jour que vous. J'ai modifié le code pour IBM JSONObject classe.
- Grâce chsdk Ça fonctionnait bien. Je l'ai changé en fonction de l'ibm JSONObject classe et des méthodes
- Super, content que ça aide.
InformationsquelleAutor cнŝdk

Un prêt-à-go méthode avec un bon casting de types:

/**
 * JSONObject contains the given key. Search is also done in nested 
 * objects recursively.
 *
 * @param json JSONObject to serach in.
 * @param key Key name to search for.
 * @return Key is found.
 */
public static boolean hasKey(
  JSONObject json,
  String key) {

  boolean exists = json.has(key);
  Iterator<?> keys;
  String nextKey;

  if (!exists) {

    keys = json.keys();

    while (keys.hasNext()) {
      nextKey = (String) keys.next();

      try {
        if (json.get(nextKey) instanceof JSONObject) {
          exists =
            hasKey(
              json.getJSONObject(nextKey),
              key);
        }
      } catch (JSONException e) {
        e.printStackTrace();
      }
    }
  }

  return exists;
}

InformationsquelleAutor Zon

Les deux solutions, qui propose à itérer la JsonObject de manière récursive, avoir un petit bug: ils ne se cassent pas le itération quand ils trouvent enfin la recherche de la clé. Donc, vous avez à briser le tout en boucle, sinon la boucle va continuer et si il y a une clé suivante, il va vérifier cette clé et ainsi de suite.
L'exemple de code, qui recherche le "pays"-la clé fonctionne uniquement parce que 'pays' est justement la dernière touche à son JsonObject.

Exemple:

 /* ... */
    while (keys.hasNext()) {
          nextKey = (String) keys.next();

          try {
            if (json.get(nextKey) instanceof JSONObject) {
              exists = hasKey(json.getJSONObject(nextKey), key);

              if(exists){
                  break;
              }

            }
          } catch (JSONException e) {
            e.printStackTrace();
          }
        }
    /* ... */

InformationsquelleAutor RuWi89

Vous devez vous connecter pour publier un commentaire.