How to iterate over a JSONObject?

Maybe this will help:

JSONObject jsonObject = new JSONObject(contents.trim());
Iterator<String> keys = jsonObject.keys();
while(keys.hasNext()) {
 String key = keys.next();
 if (jsonObject.get(key) instanceof JSONObject) {
 // do something with jsonObject here 
 }
}

for my case i found iterating the names() works well

for(int i = 0; i<jobject.names().length(); i++){
 Log.v(TAG, "key = " + jobject.names().getString(i) + " value = " + jobject.get(jobject.names().getString(i)));
}

I will avoid iterator as they can add/remove object during iteration, also for clean code use for loop. it will be simply clean & fewer lines.

Using Java 8 and Lamda [Update 4/2/2019]

import org.json.JSONObject;
public static void printJsonObject(JSONObject jsonObj) {
 jsonObj.keySet().forEach(keyStr ->
 {
 Object keyvalue = jsonObj.get(keyStr);
 System.out.println("key: "+ keyStr + " value: " + keyvalue);
 //for nested objects iteration if required
 //if (keyvalue instanceof JSONObject)
 // printJsonObject((JSONObject)keyvalue);
 });
}

Using old way [Update 4/2/2019]

import org.json.JSONObject;
public static void printJsonObject(JSONObject jsonObj) {
 for (String keyStr : jsonObj.keySet()) {
 Object keyvalue = jsonObj.get(keyStr);
 //Print key and value
 System.out.println("key: "+ keyStr + " value: " + keyvalue);
 //for nested objects iteration if required
 //if (keyvalue instanceof JSONObject)
 // printJsonObject((JSONObject)keyvalue);
 }
}

Original Answer

import org.json.simple.JSONObject;
public static void printJsonObject(JSONObject jsonObj) {
 for (Object key : jsonObj.keySet()) {
 //based on you key types
 String keyStr = (String)key;
 Object keyvalue = jsonObj.get(keyStr);
 //Print key and value
 System.out.println("key: "+ keyStr + " value: " + keyvalue);
 //for nested objects iteration if required
 if (keyvalue instanceof JSONObject)
 printJsonObject((JSONObject)keyvalue);
 }
}

Can't believe that there is no more simple and secured solution instead of using an iterator in this answers...

JSONObject names () method returns a JSONArray of the JSONObject keys, so you can simply walk though it in loop:

JSONObject object = new JSONObject ();
JSONArray keys = object.names ();
for (int i = 0; i < keys.length (); i++) {
 
 String key = keys.getString (i); // Here's your key
 String value = object.getString (key); // Here's your value
 
}

Iterator<JSONObject> iterator = jsonObject.values().iterator();
while (iterator.hasNext()) {
 jsonChildObject = iterator.next();
 // Do whatever you want with jsonChildObject 
 String id = (String) jsonChildObject.get("id");
}

org.json.JSONObject now has a keySet() method which returns a Set<String> and can easily be looped through with a for-each.

for(String key : jsonObject.keySet())

Most of the answers here are for flat JSON structures, in case you have a JSON which might have nested JSONArrays or Nested JSONObjects, the real complexity arises. The following code snippet takes care of such a business requirement. It takes a hash map, and hierarchical JSON with both nested JSONArrays and JSONObjects and updates the JSON with the data in the hash map

public void updateData(JSONObject fullResponse, HashMap<String, String> mapToUpdate) {
 fullResponse.keySet().forEach(keyStr -> {
 Object keyvalue = fullResponse.get(keyStr);
 if (keyvalue instanceof JSONArray) {
 updateData(((JSONArray) keyvalue).getJSONObject(0), mapToUpdate);
 } else if (keyvalue instanceof JSONObject) {
 updateData((JSONObject) keyvalue, mapToUpdate);
 } else {
 // System.out.println("key: " + keyStr + " value: " + keyvalue);
 if (mapToUpdate.containsKey(keyStr)) {
 fullResponse.put(keyStr, mapToUpdate.get(keyStr));
 }
 }
 });
}

You have to notice here that the return type of this is void, but sice objects are passed as refernce this change is refelected to the caller.

First put this somewhere:

private <T> Iterable<T> iteratorToIterable(final Iterator<T> iterator) {
 return new Iterable<T>() {
 @Override
 public Iterator<T> iterator() {
 return iterator;
 }
 };
}

Or if you have access to Java8, just this:

private <T> Iterable<T> iteratorToIterable(Iterator<T> iterator) {
 return () -> iterator;
}

Then simply iterate over the object's keys and values:

for (String key : iteratorToIterable(object.keys())) {
 JSONObject entry = object.getJSONObject(key);
 // ...

I made a small recursive function that goes through the entire json object and saves the key path and its value.

// My stored keys and values from the json object
HashMap<String,String> myKeyValues = new HashMap<String,String>();
// Used for constructing the path to the key in the json object
Stack<String> key_path = new Stack<String>();
// Recursive function that goes through a json object and stores 
// its key and values in the hashmap 
private void loadJson(JSONObject json){
 Iterator<?> json_keys = json.keys();
 while( json_keys.hasNext() ){
 String json_key = (String)json_keys.next();
 try{
 key_path.push(json_key);
 loadJson(json.getJSONObject(json_key));
 }catch (JSONException e){
 // Build the path to the key
 String key = "";
 for(String sub_key: key_path){
 key += sub_key+".";
 }
 key = key.substring(0,key.length()-1);
 System.out.println(key+": "+json.getString(json_key));
 key_path.pop();
 myKeyValues.put(key, json.getString(json_key));
 }
 }
 if(key_path.size() > 0){
 key_path.pop();
 }
}

With Java 8 and lambda, cleaner:

JSONObject jObject = new JSONObject(contents.trim());
jObject.keys().forEachRemaining(k ->
{
});

https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html#forEachRemaining-java.util.function.Consumer-

I once had a json that had ids that needed to be incremented by one since they were 0-indexed and that was breaking Mysql auto-increment.

So for each object I wrote this code - might be helpful to someone:

public static void incrementValue(JSONObject obj, List<String> keysToIncrementValue) {
 Set<String> keys = obj.keySet();
 for (String key : keys) {
 Object ob = obj.get(key);
 if (keysToIncrementValue.contains(key)) {
 obj.put(key, (Integer)obj.get(key) + 1);
 }
 if (ob instanceof JSONObject) {
 incrementValue((JSONObject) ob, keysToIncrementValue);
 }
 else if (ob instanceof JSONArray) {
 JSONArray arr = (JSONArray) ob;
 for (int i=0; i < arr.length(); i++) {
 Object arrObj = arr.get(0);
 if (arrObj instanceof JSONObject) {
 incrementValue((JSONObject) arrObj, keysToIncrementValue);
 }
 }
 }
 }
 }

usage:

JSONObject object = ....
incrementValue(object, Arrays.asList("id", "product_id", "category_id", "customer_id"));

this can be transformed to work for JSONArray as parent object too

We used below set of code to iterate over JSONObject fields

Iterator iterator = jsonObject.entrySet().iterator();
while (iterator.hasNext()) {
 Entry<String, JsonElement> entry = (Entry<String, JsonElement>) iterator.next();
 processedJsonObject.add(entry.getKey(), entry.getValue());
}

I made my small method to log JsonObject fields, and get some stings. See if it can be usefull.

object JsonParser {
val TAG = "JsonParser"
 /**
 * parse json object
 * @param objJson
 * @return Map<String, String>
 * @throws JSONException
 */
@Throws(JSONException::class)
fun parseJson(objJson: Any?): Map<String, String> {
 val map = HashMap<String, String>()
 // If obj is a json array
 if (objJson is JSONArray) {
 for (i in 0 until objJson.length()) {
 parseJson(objJson[i])
 }
 } else if (objJson is JSONObject) {
 val it: Iterator<*> = objJson.keys()
 while (it.hasNext()) {
 val key = it.next().toString()
 // If you get an array
 when (val jobject = objJson[key]) {
 is JSONArray -> {
 Log.e(TAG, " JSONArray: $jobject")
 parseJson(jobject)
 }
 is JSONObject -> {
 Log.e(TAG, " JSONObject: $jobject")
 parseJson(jobject)
 }
 else -> {
 Log.e(TAG, " adding to map: $key $jobject")
 map[key] = jobject.toString()
 }
 }
 }
 }
 return map
}
}

Below code worked fine for me. Please help me if tuning can be done. This gets all the keys even from the nested JSON objects.

public static void main(String args[]) {
 String s = ""; // Sample JSON to be parsed
 JSONParser parser = new JSONParser();
 JSONObject obj = null;
 try {
 obj = (JSONObject) parser.parse(s);
 @SuppressWarnings("unchecked")
 List<String> parameterKeys = new ArrayList<String>(obj.keySet());
 List<String> result = null;
 List<String> keys = new ArrayList<>();
 for (String str : parameterKeys) {
 keys.add(str);
 result = this.addNestedKeys(obj, keys, str);
 }
 System.out.println(result.toString());
 } catch (ParseException e) {
 e.printStackTrace();
 }
}
public static List<String> addNestedKeys(JSONObject obj, List<String> keys, String key) {
 if (isNestedJsonAnArray(obj.get(key))) {
 JSONArray array = (JSONArray) obj.get(key);
 for (int i = 0; i < array.length(); i++) {
 try {
 JSONObject arrayObj = (JSONObject) array.get(i);
 List<String> list = new ArrayList<>(arrayObj.keySet());
 for (String s : list) {
 putNestedKeysToList(keys, key, s);
 addNestedKeys(arrayObj, keys, s);
 }
 } catch (JSONException e) {
 LOG.error("", e);
 }
 }
 } else if (isNestedJsonAnObject(obj.get(key))) {
 JSONObject arrayObj = (JSONObject) obj.get(key);
 List<String> nestedKeys = new ArrayList<>(arrayObj.keySet());
 for (String s : nestedKeys) {
 putNestedKeysToList(keys, key, s);
 addNestedKeys(arrayObj, keys, s);
 }
 }
 return keys;
}
private static void putNestedKeysToList(List<String> keys, String key, String s) {
 if (!keys.contains(key + Constants.JSON_KEY_SPLITTER + s)) {
 keys.add(key + Constants.JSON_KEY_SPLITTER + s);
 }
}
private static boolean isNestedJsonAnObject(Object object) {
 boolean bool = false;
 if (object instanceof JSONObject) {
 bool = true;
 }
 return bool;
}
private static boolean isNestedJsonAnArray(Object object) {
 boolean bool = false;
 if (object instanceof JSONArray) {
 bool = true;
 }
 return bool;
}

This is is another working solution to the problem:

public void test (){
 Map<String, String> keyValueStore = new HasMap<>();
 Stack<String> keyPath = new Stack();
 JSONObject json = new JSONObject("thisYourJsonObject");
 keyValueStore = getAllXpathAndValueFromJsonObject(json, keyValueStore, keyPath);
 for(Map.Entry<String, String> map : keyValueStore.entrySet()) {
 System.out.println(map.getKey() + ":" + map.getValue());
 } 
}
public Map<String, String> getAllXpathAndValueFromJsonObject(JSONObject json, Map<String, String> keyValueStore, Stack<String> keyPath) {
 Set<String> jsonKeys = json.keySet();
 for (Object keyO : jsonKeys) {
 String key = (String) keyO;
 keyPath.push(key);
 Object object = json.get(key);
 if (object instanceof JSONObject) {
 getAllXpathAndValueFromJsonObject((JSONObject) object, keyValueStore, keyPath);
 }
 if (object instanceof JSONArray) {
 doJsonArray((JSONArray) object, keyPath, keyValueStore, json, key);
 }
 if (object instanceof String || object instanceof Boolean || object.equals(null)) {
 String keyStr = "";
 for (String keySub : keyPath) {
 keyStr += keySub + ".";
 }
 keyStr = keyStr.substring(0, keyStr.length() - 1);
 keyPath.pop();
 keyValueStore.put(keyStr, json.get(key).toString());
 }
 }
 if (keyPath.size() > 0) {
 keyPath.pop();
 }
 return keyValueStore;
}
public void doJsonArray(JSONArray object, Stack<String> keyPath, Map<String, String> keyValueStore, JSONObject json,
 String key) {
 JSONArray arr = (JSONArray) object;
 for (int i = 0; i < arr.length(); i++) {
 keyPath.push(Integer.toString(i));
 Object obj = arr.get(i);
 if (obj instanceof JSONObject) {
 getAllXpathAndValueFromJsonObject((JSONObject) obj, keyValueStore, keyPath);
 }
 if (obj instanceof JSONArray) {
 doJsonArray((JSONArray) obj, keyPath, keyValueStore, json, key);
 }
 if (obj instanceof String || obj instanceof Boolean || obj.equals(null)) {
 String keyStr = "";
 for (String keySub : keyPath) {
 keyStr += keySub + ".";
 }
 keyStr = keyStr.substring(0, keyStr.length() - 1);
 keyPath.pop();
 keyValueStore.put(keyStr , json.get(key).toString());
 }
 }
 if (keyPath.size() > 0) {
 keyPath.pop();
 }
}

The easiest way is to use a for-each loop over the set of keys. Given you have a String value of JSON called "text":

JSONObject jsonObject = new JSONObject(text);
for (String key : jsonObject.keySet()) {
 // Print out each value to verify this code
 System.out.println(jsonObject.get(key));
}

• java
• json