From the comment:

private ArrayList<HashMap> alleAntwoorden;

This is the problem. You're using a raw type map, but you're trying to assign a single entry to the variable Map.Entry<String, Boolean>. This cannot work, because your current map is of type HashMap<Object, Object>. Change the variable alleAntwoorden to:

private List<Map<String, Boolean>> alleAntwoorden;

Mind, that I've also changed the types to their Interface type: Should you always Code To Interfaces In Java.

Try adding in a

System.out.println(cars.get("bmw"));

to check and see what exactly is in it (in the Map, and the ArrayList of cars).

for (Map.Entry<String, ArrayList<String>> entry : map.entrySet()) {
    String key = entry.getKey();
    ArrayList<String> value = entry.getValue();
    for(String aString : value){
        System.out.println("key : " + key + " value : " + aString);
    }
}

Simplest is to iterate over all the HashMaps in the ArrayList and then iterate over all the keys in the Map:

TextView view = (TextView) view.findViewById(R.id.view);

for (HashMap<String, String> map : data)
     for (Entry<String, String> entry : map.entrySet())
         view.append(entry.getKey() + " => " + entry.getValue());

Here is an example to iterate. I created dummy data to test the code

private void ArrayListAndHashMap()
    {
        ArrayList<HashMap<String, Integer>> myList = new ArrayList<HashMap<String, Integer>>();


        HashMap<String, Integer> data1 = new HashMap<String, Integer>();
         data1.put("0",new Integer(1));
         data1.put("1",new Integer(2));
         data1.put("2",new Integer(3));
         data1.put("3",new Integer(4));

        HashMap<String, Integer> data2 = new HashMap<String, Integer>();
        data1.put("10",new Integer(10));
         data1.put("11",new Integer(20));
         data1.put("12",new Integer(30));
         data1.put("13",new Integer(40));

         myList.add(data1);
         myList.add(data2);


        for (int a =0; a<myList.size();a++)
        {
            HashMap<String, Integer> tmpData = (HashMap<String, Integer>) myList.get(a);
            Set<String> key = tmpData.keySet();
            Iterator it = key.iterator();
            while (it.hasNext()) {
                String hmKey = (String)it.next();
                Integer hmData = (Integer) tmpData.get(hmKey);

                System.out.println("Key: "+hmKey +" & Data: "+hmData);
                it.remove(); // avoids a ConcurrentModificationException
            }

        }       
    }

Output is

Key: 3 & Data: 4
Key: 2 & Data: 3
Key: 10 & Data: 10
Key: 1 & Data: 2
Key: 0 & Data: 1
Key: 13 & Data: 40
Key: 11 & Data: 20
Key: 12 & Data: 30

If this is something that you've written, then I'd like to suggest an alternate data structure. Instead of Hashmap<String, ArrayList<String>>, use ArrayList<HashMap<String, String>>

so that you have

{Name:Sam,    Age:20, City:London},
{Name:Peter,  Age:17, City:London},
{Name:Andrea, Age:24, City:Munich},
{Name:Sandra, Age:40, City:London}

If the HashMap of Lists is not something that you've written, and you still need help to figure out how to iterate that, please show us what you have tried.

When you do

 Map.Entry me = (Map.Entry)i.next();

you're creating an untyped instance of Map.Entry, which is like doing

 Map.Entry<Object, Object> me = ...

Then, when you try to do

Iterator<Student> it = (me.getValue()).iterator(); 

this is the equivalent of trying to do

ArrayList<Object> objects;
Strudent s = objects.get(0);

which, obviously, you cannot do. Instead, you need to instantiate your Map.Entry object with the appropriate type:

 Map.Entry<YourKeyType, ArrayList<Student>> me =  
       (Map.Entry<YourKeyType, ArrayList<Student>>) i.next();

Note that you can avoid the cast there, and take full advantage of generic type safety, by making your iterator an Iterator<YourKeyType, ArrayList<Student>> rather than declaring it as a raw type.

It doesn't matter whether you use a for loop, forEach or the Stream API. In all cases, you are iterating over a Map to compare each key against a certain value, which is perverting the concept of maps, to associate the key with a value and provide (usually far better that linear) lookup methods.

Further, you should use a Map<String, List<String>> instead, not referring to an implementation type like ArrayList, and not letting it be null in the first place, instead of having it to check for null later-on.

If you follow theses advice, your code becomes

Map<String, List<String>> xhashMap;
// always initialize the map to a non-null reference

xhashMap.getOrDefault("ax", Collections.emptyList())
        .forEach(v -> method1(v, AA.class));
xhashMap.getOrDefault("bx", Collections.emptyList())
        .forEach(v -> method1(v, BB.class));

If the map is, as the variable name suggests, a hash map, the two lookups will have O(1) time complexity, but even a TreeMap with O(log(n)) complexity will be better than iterating over the map and compare all keys.

As long as the action consists of a sole method invocation with different parameters, there is not much gain in trying to re-use common code, as the sharing code would be much more complicated.