Try to convert map object to JSONArray rather than JSON Object. It would give you JSONObject to work with directly.

public void getResult(Object result) {
        ObjectMapper mapper = new ObjectMapper();
        Object map = null;
        try {
            map = mapper.readValue((String) result, Object.class);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }

        JSONArray json = (JSONArray) map;
        for (int i=0; i < json.length(); i++) {
            JSONObject e = json.get(i);

            System.out.println(e);
        }
}

So, you want to return the indexes of first occurrences of distinct items?

Maps can be really cool for these things, and in this case, all you want to actually remember is when was the first occurrence of each distinct element.

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class DistinctValues {
    public static List<Integer> distinctIndexes(String[] strings) {

        // holds the mapping { string => index of first occurence of that string }
        Map<String, Integer> firstOccurenceMap = new HashMap<String, Integer>();

        // do a scan through all the items
        for (int i = 0; i < strings.length; i++) {
            // store the index position of a string only if you haven't encountered it before
            firstOccurenceMap.putIfAbsent(strings[i], i);
        }

        return new ArrayList<Integer>(firstOccurenceMap.values());
    }

    public static void main(String[] args) {
        String[] strings = new String[] { "1", "1", "3", "3", "3", "3", "3", "3" };

        System.out.println(distinctIndexes(strings));
    }
}

The output:

[0, 2]

Iterate through the prizeWinner keys (years). For each year, get the winners String array and convert it to a list, then call the contains method to see if the winners list contains the winner name passed as parameter. If it's the case, we stop looping and return the year as a String. If we went through all the years but didn't find the winner's name, we would return null

private HashMap<Integer, String[]> prizeWinners;

public PartsPortlet()
{
    prizeWinners = new HashMap<Integer, String[]>();
    prizeWinners.put(2009, new String[]{"Barack H. Obama"});
    prizeWinners.put(2008, new String[]{"Martti Ahtisaari"};
    prizeWinners.put(2007, new String[]{"IAEA", "Mohamed ElBaradei"});
    //and many more
}

public String getYearWon(String name) {
    for (int year : prizeWinners.keySet()) {
        if (Arrays.asList(prizeWinners.get(year)).contains(name)) {
            return String.valueOf(year);
        }
    }
    return null;
}

Java doesn't support associative arrays, however this could easily be achieved using a Map. E.g.,

Map<String, String> map = new HashMap<String, String>();
map.put("name", "demo");
map.put("fname", "fdemo");
// etc

map.get("name"); // returns "demo"

Even more accurate to your example (since you can replace String with any object that meet your needs) would be to declare:

List<Map<String, String>> data = new ArrayList<>();
data.add(0, map);
data.get(0).get("name"); 

See the official documentation for more information

The first time onChildAdded is called, there will be an exception because arraylist will only have 1 item, and you are accessing index 2 that requires 3 or more items in the list.

String specificIndexValue = arraylist.get(2);

We will need more info to solve your question it prints one value four times which lie on index "1".

It seems you might want to store in an ordered map instead of an array, with the key being the snapshot key and the value being the snapshot.

Try this to debug...

@Override
public void onChildAdded(DataSnapshot dataSnapshot, String s) {

    //add keys to arraylist
    String key=dataSnapshot.getKey();
    arraylist.add(key);

    if (arraylist.size() == 3){
       Log.i("Key: " arraylist.get(2), "Index: 2");
    }
}

var value = state[country[0][0]] [i][1];

If your data structure has many-to-one mapping between keys and values you should iterate over entries and pick all suitable keys:

public static <T, E> Set<T> getKeysByValue(Map<T, E> map, E value) {
    Set<T> keys = new HashSet<T>();
    for (Entry<T, E> entry : map.entrySet()) {
        if (Objects.equals(value, entry.getValue())) {
            keys.add(entry.getKey());
        }
    }
    return keys;
}

In case of one-to-one relationship, you can return the first matched key:

public static <T, E> T getKeyByValue(Map<T, E> map, E value) {
    for (Entry<T, E> entry : map.entrySet()) {
        if (Objects.equals(value, entry.getValue())) {
            return entry.getKey();
        }
    }
    return null;
}

In Java 8:

public static <T, E> Set<T> getKeysByValue(Map<T, E> map, E value) {
    return map.entrySet()
              .stream()
              .filter(entry -> Objects.equals(entry.getValue(), value))
              .map(Map.Entry::getKey)
              .collect(Collectors.toSet());
}

Also, for Guava users, BiMap may be useful. For example:

BiMap<Token, Character> tokenToChar = 
    ImmutableBiMap.of(Token.LEFT_BRACKET, '[', Token.LEFT_PARENTHESIS, '(');
Token token = tokenToChar.inverse().get('(');
Character c = tokenToChar.get(token);

You can do it with two loops, e.g.:

JSONObject object = new JSONObject(jsonString); //jsonString = String from the file
JSONArray array = object.getJSONArray("items");
Iterator<Object> iterator = array.iterator();
while(iterator.hasNext()){
    JSONObject jsonObject = (JSONObject) iterator.next();
    for(String key : jsonObject.keySet()){
        System.out.println(key + ":" + jsonObject.get(key));
    }
}

Update

Here's the full example with all the imports:

import java.util.Iterator;
import org.json.JSONArray;
import org.json.JSONObject;

public class Test {

    public static void main(String[] args) {

        JSONObject object = new JSONObject("{\"items\":[{\"index\":10}]}");
        JSONArray array = object.getJSONArray("items");
        Iterator<Object> iterator = array.iterator();

        while (iterator.hasNext()) {
            JSONObject jsonObject = (JSONObject) iterator.next();

            for (String key : jsonObject.keySet()) {
                System.out.println(key + ":" + jsonObject.get(key));
            }
        }

    }
}

assuming when you say key you mean value (as in values in an array),

final String PREFIX = "yourPrefix";
for(String value : valueList) {
    if(value.startwith(PREFIX)) {
        <do whatever...>
    }

here is the link to the java Doc http://docs.oracle.com/javase/7/docs/api/java/lang/String.html#startsWith(java.lang.String)

I mean you could achieve it that way, but it is much less efficient. Searching an array for a specific value will be of O(n) complexity while hashmaps only take O(1) in the best case scenario (with no chaining).