When you iterate over a Map, if you need both the key and the value it's better to iterate over the entrySet rather than the keySet.

public static String getKeyFromValue(String value) {
    for (Map.Entry<String, List<String>> e : Server.entrySet()) {
        if (e.getValue().contains(value)) {
            return e.getKey();
        }
    }
    return null;
}

This should work, but there are 3 things I don't like about it (apart from Server beginning with a capital letter).

1. contains for many List implementations (including ArrayList and LinkedList) is slow, because it is a linear search. It may better to use HashSet instead.
2. If the value occurs in more than one list in the map, the returned key could be any of multiple answers. It may be better for the name of the method to indicate this (e.g. getAnyKeyForValue).
3. It may be preferable to return an Optional<String> rather than using null to mean that the value was not found.

A Java 8 solution, taking all of these points into consideration and taking advantage of parallelism would be

public static Optional<String> getAnyKeyForValue(String value) {
    return Server.entrySet()
                 .parallelStream()
                 .filter(e->e.getValue().contains(value))
                 .map(Map.Entry::getKey)
                 .findAny();
}

You can try this

First add the generic part <String, Integer> to the Map of List as below:

List<Map<String, Integer>> Items= new ArrayList<>();

And then:

for (Map<String, Integer> item : Items) {
    for (Map.Entry<String, Integer> entry: items.get(i).entrySet()) {
        // do what you want with the entry
    }
}

for (Entry<String, List<String>> entry : map.entrySet()) {
    if (entry.getValue().contains(animalYouSearch)) {
        System.out.println(animalYouSearch + " is in " + entry.getKey());
    }
}

Output if you search for "mammal":

mammal is in cat

mammal is in dog

If you'd like to be fancy, you could use Guava's BiMap.

Here's an example taken from baeldung:

@Test
public void givenBiMap_whenQueryByValue_shouldReturnKey() {
    BiMap<String, String> capitalCountryBiMap = HashBiMap.create();
    capitalCountryBiMap.put("New Delhi", "India");
    capitalCountryBiMap.put("Washington, D.C.", "USA");
    capitalCountryBiMap.put("Moscow", "Russia");

    String keyFromBiMap = capitalCountryBiMap.inverse().get("Russia");
    String valueFromBiMap = capitalCountryBiMap.get("Washington, D.C.");

    assertEquals("Moscow", keyFromBiMap);
    assertEquals("USA", valueFromBiMap);
}

You can keep the Map. The Map is designed to be looked up by key so I suggest you have a list of shuffled keys.

public Map<Integer, String> getQuestionOptionsMap() {
    Map<Integer, String> map = new HashMap<>();
    String[] answers = {null, answer1, answer2, answer3, answer4};
    for (int i = 1; i < answers.length; i++)
        if (answers[i] != null)
            map.put(i, answers[i]);
    List<Integer> order = new ArrayList<>(map.keySet());
    Collections.shuffle(order);
    Map<Integer, String> shuffled = new LinkedHashMap<>();
    for (Integer key : order)
        shuffled.put(key, map.get(key));
    return shuffled;
}

If you choose to use the Commons Collections library instead of the standard Java Collections framework, you can achieve this with ease.

The BidiMap interface in the Collections library is a bi-directional map, allowing you to map a key to a value (like normal maps), and also to map a value to a key, thus allowing you to perform lookups in both directions. Obtaining a key for a value is supported by the getKey() method.

There is a caveat though, bidi maps cannot have multiple values mapped to keys, and hence unless your data set has 1:1 mappings between keys and values, you cannot use bidi maps.

If you want to rely on the Java Collections API, you will have to ensure the 1:1 relationship between keys and values at the time of inserting the value into the map. This is easier said than done.

Once you can ensure that, use the entrySet() method to obtain the set of entries (mappings) in the Map. Once you have obtained the set whose type is Map.Entry, iterate through the entries, comparing the stored value against the expected, and obtain the corresponding key.

Support for bidi maps with generics can be found in Google Guava and the refactored Commons-Collections libraries (the latter is not an Apache project). Thanks to Esko for pointing out the missing generic support in Apache Commons Collections. Using collections with generics makes more maintainable code.

Since version 4.0 the official Apache Commons Collections™ library supports generics.

See the summary page of the "org.apache.commons.collections4.bidimap" package for the list of available implementations of the BidiMap, OrderedBidiMap and SortedBidiMap interfaces that now support Java generics.

You have to iterate over your list and look for the map that contains the key I guess:

Object value = null;
for(Map<String,Object> map : test) {
    if(map.containsKey("key1")) {
        value = map.get("key1");
        break;
    }
}

Your list actually contains elements of type Map.Entry<Integer, Integer>, so you can retrieve the each Entry as shown below:

Map<Integer, Integer> map = new HashMap<>();
//add the values to map here

//Always prefer to use generic types shown below (instead of raw List)
List<Map.Entry<Integer, Integer>> list = new ArrayList<>(map.entrySet());

Collections.sort(list, new Comparator<Map.Entry<Integer, Integer>>() {
  @Override
  public int compare(Map.Entry<Integer, Integer> a,
                  Map.Entry<Integer, Integer> b){
                       return a.getValue() - b.getValue();
    }
  });

  //loop over the list to retrieve the list elements
  for(Map.Entry<Integer, Integer> entry : list) {
        System.out.println(entry.getValue());
  }