Map map=new HashMap();
Set set-=map.entrySet();
Interor it=set.interor();
while(it.hasNext()){
   Map.Entry entry=(Entry)it.next();//Map.Entry 类和Entry有什么区别
                                    //为什么在API文档中找不到类Entry
                                    //在我们以前学强制类型转换时左右
                                    //两边的类型不都一样吗
                                    //例如String str=(String)obj;
                                    //为什么Map.Entry和(Entry)不是同种类型
}

谢谢啊，有点明白了

大家一起来解决问题，真好

Map.Entry是Map内部定义的一个接口，专门用来保存key→value的内容。Map.Entry的定义如下：
public static interface Map.Entry<K,V>
Map.Entry是使用static关键字声明的内部接口，此接口可以由外部通过"外部类.内部类"的形式直接调用。
从之前的内容可以知道，在Map的操作中，所有的内容都是通过key→value的形式保存数据的，那么对于集合来讲，实际上是将key→value的数据保存在了Map.Entry的实例之后，再在Map集合中插入的是一个Map.Entry的实例化对象，如下图所示：

在一般的Map操作中（例如，增加或取出数据等操作）不用去管Map.Entry接口，但是在将Map中的数据全部输出时就必须使用Map.Entry接口.

李玉生 发表于 2012-10-3 08:45
java.util
接口 Map.Entry
所有已知实现类：

我说用API文档找不到Entry类。

java.util
接口 Map.Entry<K,V>
所有已知实现类：
AbstractMap.SimpleEntry, AbstractMap.SimpleImmutableEntry
正在封闭接口：
Map<K,V>

--------------------------------------------------------------------------------

public static interface Map.Entry<K,V>映射项（键-值对）。Map.entrySet 方法返回映射的 collection 视图，其中的元素属于此类。获得映射项引用的唯一 方法是通过此 collection 视图的迭代器来实现。这些 Map.Entry 对象仅 在迭代期间有效；更确切地讲，如果在迭代器返回项之后修改了底层映射，则某些映射项的行为是不确定的，除了通过 setValue 在映射项上执行操作之外。



从以下版本开始：
1.2
另请参见：
Map.entrySet()
顶楼的哥们，你是不是查的api是老版本的啊，我的是1.6版本的，就有这个

顶层的哥们是个新手，楼上的哥们你给他一大堆代码，我想对他没太多帮助

Map是一个接口~~Entry是Map接口里面的一个内部接口~~代表着Map里面的元素~~API里面找不到就去JDK源码里面找嘛~~

Map.Entry和Entry 我都试了下，都可以，前面加上Map. 应该是想告诉读者这个是Map里面的Entry接口~增加阅读性~

1. interface Entry<K,V> {
   
2.             /**
   
3.          * Returns the key corresponding to this entry.
   
4.          *
   
5.          * @return the key corresponding to this entry
   
6.          * @throws IllegalStateException implementations may, but are not
   
7.          *         required to, throw this exception if the entry has been
   
8.          *         removed from the backing map.
   
9.          */
   
10.         K getKey();
    
11. 
    
12.             /**
    
13.          * Returns the value corresponding to this entry.  If the mapping
    
14.          * has been removed from the backing map (by the iterator's
    
15.          * <tt>remove</tt> operation), the results of this call are undefined.
    
16.          *
    
17.          * @return the value corresponding to this entry
    
18.          * @throws IllegalStateException implementations may, but are not
    
19.          *         required to, throw this exception if the entry has been
    
20.          *         removed from the backing map.
    
21.          */
    
22.         V getValue();
    
23. 
    
24.             /**
    
25.          * Replaces the value corresponding to this entry with the specified
    
26.          * value (optional operation).  (Writes through to the map.)  The
    
27.          * behavior of this call is undefined if the mapping has already been
    
28.          * removed from the map (by the iterator's <tt>remove</tt> operation).
    
29.          *
    
30.          * @param value new value to be stored in this entry
    
31.          * @return old value corresponding to the entry
    
32.          * @throws UnsupportedOperationException if the <tt>put</tt> operation
    
33.          *         is not supported by the backing map
    
34.          * @throws ClassCastException if the class of the specified value
    
35.          *         prevents it from being stored in the backing map
    
36.          * @throws NullPointerException if the backing map does not permit
    
37.          *         null values, and the specified value is null
    
38.          * @throws IllegalArgumentException if some property of this value
    
39.          *         prevents it from being stored in the backing map
    
40.          * @throws IllegalStateException implementations may, but are not
    
41.          *         required to, throw this exception if the entry has been
    
42.          *         removed from the backing map.
    
43.          */
    
44.         V setValue(V value);
    
45. 
    
46.         /**
    
47.          * Compares the specified object with this entry for equality.
    
48.          * Returns <tt>true</tt> if the given object is also a map entry and
    
49.          * the two entries represent the same mapping.  More formally, two
    
50.          * entries <tt>e1</tt> and <tt>e2</tt> represent the same mapping
    
51.          * if<pre>
    
52.          *     (e1.getKey()==null ?
    
53.          *      e2.getKey()==null : e1.getKey().equals(e2.getKey()))  &&
    
54.          *     (e1.getValue()==null ?
    
55.          *      e2.getValue()==null : e1.getValue().equals(e2.getValue()))
    
56.          * </pre>
    
57.          * This ensures that the <tt>equals</tt> method works properly across
    
58.          * different implementations of the <tt>Map.Entry</tt> interface.
    
59.          *
    
60.          * @param o object to be compared for equality with this map entry
    
61.          * @return <tt>true</tt> if the specified object is equal to this map
    
62.          *         entry
    
63.          */
    
64.         boolean equals(Object o);
    
65. 
    
66.         /**
    
67.          * Returns the hash code value for this map entry.  The hash code
    
68.          * of a map entry <tt>e</tt> is defined to be: <pre>
    
69.          *     (e.getKey()==null   ? 0 : e.getKey().hashCode()) ^
    
70.          *     (e.getValue()==null ? 0 : e.getValue().hashCode())
    
71.          * </pre>
    
72.          * This ensures that <tt>e1.equals(e2)</tt> implies that
    
73.          * <tt>e1.hashCode()==e2.hashCode()</tt> for any two Entries
    
74.          * <tt>e1</tt> and <tt>e2</tt>, as required by the general
    
75.          * contract of <tt>Object.hashCode</tt>.
    
76.          *
    
77.          * @return the hash code value for this map entry
    
78.          * @see Object#hashCode()
    
79.          * @see Object#equals(Object)
    
80.          * @see #equals(Object)
    
81.          */
    
82.         int hashCode();
    
83.     }
    
84. 
    
85.     // Comparison and hashing
    
86. 
    
87.     /**
    
88.      * Compares the specified object with this map for equality.  Returns
    
89.      * <tt>true</tt> if the given object is also a map and the two maps
    
90.      * represent the same mappings.  More formally, two maps <tt>m1</tt> and
    
91.      * <tt>m2</tt> represent the same mappings if
    
92.      * <tt>m1.entrySet().equals(m2.entrySet())</tt>.  This ensures that the
    
93.      * <tt>equals</tt> method works properly across different implementations
    
94.      * of the <tt>Map</tt> interface.
    
95.      *
    
96.      * @param o object to be compared for equality with this map
    
97.      * @return <tt>true</tt> if the specified object is equal to this map
    
98.      */
    
99.     boolean equals(Object o);
    
100. 
     
101.     /**
     
102.      * Returns the hash code value for this map.  The hash code of a map is
     
103.      * defined to be the sum of the hash codes of each entry in the map's
     
104.      * <tt>entrySet()</tt> view.  This ensures that <tt>m1.equals(m2)</tt>
     
105.      * implies that <tt>m1.hashCode()==m2.hashCode()</tt> for any two maps
     
106.      * <tt>m1</tt> and <tt>m2</tt>, as required by the general contract of
     
107.      * {@link Object#hashCode}.
     
108.      *
     
109.      * @return the hash code value for this map
     
110.      * @see Map.Entry#hashCode()
     
111.      * @see Object#equals(Object)
     
112.      * @see #equals(Object)
     
113.      */
     
114.     int hashCode();
     
115. }

复制代码

Map的实现类里面一般都实现了Entry这个接口~比如说HashMap

1. static class Entry<K,V> implements Map.Entry<K,V> {
   
2.         final K key;
   
3.         V value;
   
4.         Entry<K,V> next;
   
5.         final int hash;
   
6. 
   
7.         /**
   
8.          * Creates new entry.
   
9.          */
   
10.         Entry(int h, K k, V v, Entry<K,V> n) {
    
11.             value = v;
    
12.             next = n;
    
13.             key = k;
    
14.             hash = h;
    
15.         }
    
16. 
    
17.         public final K getKey() {
    
18.             return key;
    
19.         }
    
20. 
    
21.         public final V getValue() {
    
22.             return value;
    
23.         }
    
24. 
    
25.         public final V setValue(V newValue) {
    
26.             V oldValue = value;
    
27.             value = newValue;
    
28.             return oldValue;
    
29.         }
    
30. 
    
31.         public final boolean equals(Object o) {
    
32.             if (!(o instanceof Map.Entry))
    
33.                 return false;
    
34.             Map.Entry e = (Map.Entry)o;
    
35.             Object k1 = getKey();
    
36.             Object k2 = e.getKey();
    
37.             if (k1 == k2 || (k1 != null && k1.equals(k2))) {
    
38.                 Object v1 = getValue();
    
39.                 Object v2 = e.getValue();
    
40.                 if (v1 == v2 || (v1 != null && v1.equals(v2)))
    
41.                     return true;
    
42.             }
    
43.             return false;
    
44.         }
    
45. 
    
46.         public final int hashCode() {
    
47.             return (key==null   ? 0 : key.hashCode()) ^
    
48.                    (value==null ? 0 : value.hashCode());
    
49.         }
    
50. 
    
51.         public final String toString() {
    
52.             return getKey() + "=" + getValue();
    
53.         }
    
54. 
    
55.         /**
    
56.          * This method is invoked whenever the value in an entry is
    
57.          * overwritten by an invocation of put(k,v) for a key k that's already
    
58.          * in the HashMap.
    
59.          */
    
60.         void recordAccess(HashMap<K,V> m) {
    
61.         }
    
62. 
    
63.         /**
    
64.          * This method is invoked whenever the entry is
    
65.          * removed from the table.
    
66.          */
    
67.         void recordRemoval(HashMap<K,V> m) {
    
68.         }
    
69.     }

复制代码