return new Iterator()
return new Iterator<K>()
  public Set<K> keySet()  {    if (keys == null)      keys = new AbstractSet<K>()      {	/**	 * Retrieves the number of keys in the backing map.	 *	 * @return The number of keys.	 */        public int size()        {          return AbstractMap.this.size();        }	/**	 * Returns true if the backing map contains the	 * supplied key.	 *	 * @param key The key to search for.	 * @return True if the key was found, false otherwise. 	 */        public boolean contains(Object key)        {          return containsKey(key);        }	/**	 * Returns an iterator which iterates over the keys	 * in the backing map, using a wrapper around the	 * iterator returned by <code>entrySet()</code>.	 *	 * @return An iterator over the keys.	 */        public Iterator<K> iterator()        {          return new Iterator()          {	    /**	     * The iterator returned by <code>entrySet()</code>.	     */            private final Iterator<Map.Entry<K, V>> map_iterator	      = entrySet().iterator();	    /**	     * Returns true if a call to <code>next()</code> will	     * return another key.	     *	     * @return True if the iterator has not yet reached	     *         the last key.	     */            public boolean hasNext()            {              return map_iterator.hasNext();            }	    /**	     * Returns the key from the next entry retrieved	     * by the underlying <code>entrySet()</code> iterator.	     *	     * @return The next key.	     */            public K next()            {              return map_iterator.next().getKey();            }	    /**	     * Removes the map entry which has a key equal	     * to that returned by the last call to	     * <code>next()</code>.	     *	     * @throws UnsupportedOperationException if the	     *         map doesn't support removal.	     */            public void remove()            {              map_iterator.remove();            }          };        }      };    return keys;  }