java中的Map.Entry接口

Question

我知道java.util.Map.Entry是java.util包中的一個public static interface ，它返回一個map的集合視圖但是到目前為止我對靜態接口很困惑，因為它是Map.Entry它是一個內部接口如果是這樣，我們如何在java中使用內部靜態接口

看看我很困惑的人請以任何可能的方式幫助我。

Answer 1

Entry的定義恰好存在於Map的定義中（java允許）。 static意味着您不需要Map實例來引用Entry 。

通過示例演示如何使用Map.Entry是最簡單的。 以下是迭代地圖的方法

Map<Integer, String> map = new HashMap<Integer, String>();

for (Map.Entry<Integer, String> entry : map.entrySet()) {
    Integer key = entry.getKey();
    String value = entry.getValue();
    // do something with key and/or value etc
    // you may also alter the entry's value inside this loop via entry.setValue()
}

Answer 2

沒有什么可以混淆的。

是的，Java允許接口成為類或其他接口的成員。

不，這並不意味着什么特別的。 它完全沒有改變你如何使用這樣的界面或你可以用它做什么。

它只更改該接口的名稱，並在它與其封閉類型之間創建一個強大的概念鏈接。 在這種情況下， Map.Entry表示Map的條目。 API的設計者顯然認為通過使其成為成員類型來強調這種聯系是有意義的。

Answer 3

例：

public class Outer {
    public interface Bar {
        Bar get();
    }
}

Bar是一個嵌套的界面。 嵌套接口默認是靜態的，所以你也可以寫：

public class Outer {
    public static interface Bar {
        Bar get();
    }
}

現在，這個上下文中的靜態意味着接口是靜態成員，即類的成員。

您也可以使用類來完成此操作：

public class Tree {
    private static class Node {

    }
}

在這里，Node甚至是私有的，這意味着它只在Tree中可見。 那么，這有什么好處呢？ 為什么不讓Node成為公共類？ 因為更好的封裝。 首先，Node是Tree的實現細節，因此您不希望它可見。 其次，如果您通過公共API公開Node，某些客戶端（程序員）可以在他的代碼中使用它。 現在，他對這門課有很大的依賴。 如果在某些時候您想要更改Tree的表示，並且您更改/刪除Node類，則客戶端代碼可能會中斷。 最后但並非最不重要的是，您的公共API變得更小，這也是可取的。

那么，何時使用靜態成員類/接口？ 大多數情況下，如果您構建某種類型的Composite對象（如樹或鏈接列表），或者該類僅在外部類的上下文中有意義。

Answer 4

內部接口是隱式公共和靜態的。

您可以使用以下內部接口：

1.   interface A {
             .....
             .....
             interface B {
                          ....
                          ....
             }

     }



2.   class A {
              ....
              ....
              interface B {
                            ....
                            ....
              }

     }

您可以通過AB訪問上述內部接口（B），其中A是根據上述兩種情況的類或接口。

例如，

class x implements A.B
{
         ....
         ....
}

Answer 5

是的，它是Map接口的內部接口。

---

   /**
     * A map entry (key-value pair).  The <tt>Map.entrySet</tt> method returns
     * a collection-view of the map, whose elements are of this class.  The
     * <i>only</i> way to obtain a reference to a map entry is from the
     * iterator of this collection-view.  These <tt>Map.Entry</tt> objects are
     * valid <i>only</i> for the duration of the iteration; more formally,
     * the behavior of a map entry is undefined if the backing map has been
     * modified after the entry was returned by the iterator, except through
     * the <tt>setValue</tt> operation on the map entry.
     *
     * @see Map#entrySet()
     * @since 1.2
     */
    interface Entry<K,V> {
        /**
     * Returns the key corresponding to this entry.
     *
     * @return the key corresponding to this entry
         * @throws IllegalStateException implementations may, but are not
         *         required to, throw this exception if the entry has been
         *         removed from the backing map.
     */
    K getKey();

        /**
     * Returns the value corresponding to this entry.  If the mapping
     * has been removed from the backing map (by the iterator's
     * <tt>remove</tt> operation), the results of this call are undefined.
     *
     * @return the value corresponding to this entry
         * @throws IllegalStateException implementations may, but are not
         *         required to, throw this exception if the entry has been
         *         removed from the backing map.
     */
    V getValue();

        /**
     * Replaces the value corresponding to this entry with the specified
     * value (optional operation).  (Writes through to the map.)  The
     * behavior of this call is undefined if the mapping has already been
     * removed from the map (by the iterator's <tt>remove</tt> operation).
     *
         * @param value new value to be stored in this entry
         * @return old value corresponding to the entry
         * @throws UnsupportedOperationException if the <tt>put</tt> operation
         *         is not supported by the backing map
         * @throws ClassCastException if the class of the specified value
         *         prevents it from being stored in the backing map
         * @throws NullPointerException if the backing map does not permit
         *         null values, and the specified value is null
         * @throws IllegalArgumentException if some property of this value
         *         prevents it from being stored in the backing map
         * @throws IllegalStateException implementations may, but are not
         *         required to, throw this exception if the entry has been
         *         removed from the backing map.
         */
    V setValue(V value);

    /**
     * Compares the specified object with this entry for equality.
     * Returns <tt>true</tt> if the given object is also a map entry and
     * the two entries represent the same mapping.  More formally, two
     * entries <tt>e1</tt> and <tt>e2</tt> represent the same mapping
     * if<pre>
         *     (e1.getKey()==null ?
         *      e2.getKey()==null : e1.getKey().equals(e2.getKey()))  &amp;&amp;
         *     (e1.getValue()==null ?
         *      e2.getValue()==null : e1.getValue().equals(e2.getValue()))
         * </pre>
     * This ensures that the <tt>equals</tt> method works properly across
     * different implementations of the <tt>Map.Entry</tt> interface.
     *
     * @param o object to be compared for equality with this map entry
     * @return <tt>true</tt> if the specified object is equal to this map
     *         entry
         */
    boolean equals(Object o);

    /**
     * Returns the hash code value for this map entry.  The hash code
     * of a map entry <tt>e</tt> is defined to be: <pre>
     *     (e.getKey()==null   ? 0 : e.getKey().hashCode()) ^
     *     (e.getValue()==null ? 0 : e.getValue().hashCode())
         * </pre>
     * This ensures that <tt>e1.equals(e2)</tt> implies that
     * <tt>e1.hashCode()==e2.hashCode()</tt> for any two Entries
     * <tt>e1</tt> and <tt>e2</tt>, as required by the general
     * contract of <tt>Object.hashCode</tt>.
     *
     * @return the hash code value for this map entry
     * @see Object#hashCode()
     * @see Object#equals(Object)
     * @see #equals(Object)
     */
    int hashCode();
    }

---

有關接口的更多信息，請參閱“ 接口”教程和“ 靜態嵌套接口”一文。

Answer 6

Java允許嵌套接口 。 您可以將它們嵌套到類或接口中。 例如， Map.Entry是Map接口中定義的嵌套接口。

Map實現（ TreeMap ， HashMap ）提供了Map.Entry私有實現，這些實現在類外部是不可見的。

Bohemian的答案解決了如何使用Map.Entry 。