Java Iterators. How to inspect the Iterator?

Question

I want to know if there is a way to inspect the iterator object. Is it a kind of map?

Also, is there a a better way to take the contents of the iterator object and put them in mapC?

Here is my code:

import java.util.HashMap;
import java.util.TreeMap;
import java.util.Map;
import java.util.Iterator;

public class Maps {
  public static void main(String[] args) {
    Map mapA = new HashMap();
    Map mapB = new TreeMap();

    mapA.put("key1", "element 1");
    mapA.put("key2", "element 2");
    mapA.put("key3", "element 3");

    // The three put() calls maps a string value to a string key. You can then
    // obtain the value using the key. To do that you use the get() method like this:

    String element1 = (String) mapA.get("key1");
    // why do I need the type cast on the right?
    System.out.println(element1);

    // Lets iterate through the keys of this map:

    Iterator iterator = mapA.keySet().iterator();
    System.out.println(iterator);  // How to inspect this? Is it a kind of map?

    Map mapC = new HashMap();
    while(iterator.hasNext()){
      Object key   = iterator.next();
      Object value = mapA.get(key);
      mapC.put(key,value);
    } // Is there a better way to take the contents of the iterator and put them in a new map?
    System.out.println(mapC);
  }
}

Answer 1

The only thing you can do with an iterator is to call its hasNext(), next(), and remove() methods. The iterator implementations for every different type of collection (and collection view) are likely to be different in every case; there's nothing else you can do with them.

As stated elsewhere, you can use mapC.putAll(mapA) to copy over all contents from mapA. You should generally use generics instead of raw types, though.

Answer 2

1. Iterator is an interface, which has has no implementation for you to inspect. You have to know the concrete class that implements the interface if you want to have any hope of "inspecting" it. Be aware, though, that there are multiple implementations of the Java API (and implementations evolve over time), so in general you cannot predict which concrete class will be used.

2. You do not need to use an Iterator at all to create a copy of a HashMap. There is a copy constructor HashMap(Map m) that can be used instead.

Answer 3

Using a Java decompiler, some IDEs have one. For example, IntelliJ IDEA and Android Studio bundle one, which enables you to see into classes that otherwise you wouldn't be able to see into.

Or you can actually check the source for public Java APIs because the Java source is bundled with the JDK, it's in your installation folder in src.zip.

Anyhow, here's the iterator implementation for a HashMap.

private abstract class HashIterator {
    int nextIndex;
    HashMapEntry<K, V> nextEntry = entryForNullKey;
    HashMapEntry<K, V> lastEntryReturned;
    int expectedModCount = modCount;

    HashIterator() {
        if (nextEntry == null) {
            HashMapEntry<K, V>[] tab = table;
            HashMapEntry<K, V> next = null;
            while (next == null && nextIndex < tab.length) {
                next = tab[nextIndex++];
            }
            nextEntry = next;
        }
    }

    public boolean hasNext() {
        return nextEntry != null;
    }

    HashMapEntry<K, V> nextEntry() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        if (nextEntry == null)
            throw new NoSuchElementException();

        HashMapEntry<K, V> entryToReturn = nextEntry;
        HashMapEntry<K, V>[] tab = table;
        HashMapEntry<K, V> next = entryToReturn.next;
        while (next == null && nextIndex < tab.length) {
            next = tab[nextIndex++];
        }
        nextEntry = next;
        return lastEntryReturned = entryToReturn;
    }

    public void remove() {
        if (lastEntryReturned == null)
            throw new IllegalStateException();
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        HashMap.this.remove(lastEntryReturned.key);
        lastEntryReturned = null;
        expectedModCount = modCount;
    }
}

private final class KeyIterator extends HashIterator
        implements Iterator<K> {
    public K next() { return nextEntry().key; }
}

private final class KeySet extends AbstractSet<K> {
    public Iterator<K> iterator() {
        return newKeyIterator();
    }
    public int size() {
        return size;
    }
    public boolean isEmpty() {
        return size == 0;
    }
    public boolean contains(Object o) {
        return containsKey(o);
    }
    public boolean remove(Object o) {
        int oldSize = size;
        HashMap.this.remove(o);
        return size != oldSize;
    }
    public void clear() {
        HashMap.this.clear();
    }
}

As for copying contents of one Map to another, there are questions about that kind of thing, but you can do it with a single putAll() method call.