java中的Map.Entry接口

Question

据我所知，java.util.Map.Entry是java.util包中的公共静态接口 返回地图的集合视图，但到目前为止我对静态接口感到困惑 因为它是 Map.Entry 它是一个内部接口如果是的话我们如何在java中拥有内部静态接口

Answer 1

Entry 的定义恰好位于 Map 的定义内（java 允许）。 静态意味着您不需要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 成为公共类呢？因为封装比较好。首先，节点是树的实现细节，因此您不希望它可见。其次，如果您通过公共 API 公开 Node，某些客户端（程序员）可以在他的代码中使用它。现在，他对这个班级已经产生了严重的依赖。如果在某个时候您想要更改树的表示形式，并且更改/删除 Node 类，则客户端代码可能会中断。最后但并非最不重要的一点是，您的公共 API 变得更小，这也是可取的。

那么，什么时候使用静态成员类/接口呢？大多数情况下，如果您构建某种复合对象（如树或链接列表），或者该类仅在外部类的上下文中有意义。

Answer 4

Java 允许嵌套接口。您可以将它们嵌套到类或接口中。例如，Map.Entry 是在Map 接口中定义的嵌套接口。

Map 实现（TreeMap、HashMap）提供 Map.Entry 的私有实现，这些实现在类外部不可见。

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

Answer 5

是的，它是 < 的内部接口代码>地图界面。

---

   /**
     * 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()))  &&
         *     (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();
    }

---

有关接口的更多信息，请参阅接口教程和此< href="http://littletutorials.com/2008/03/06/static-nested-interfaces/" rel="nofollow">静态嵌套接口一文。

Answer 6

内部接口是隐式公共和静态的。

你可以有内部接口，如下所示：

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

     }



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

     }

你可以通过AB访问上面的内部接口(B)，其中A是一个类或一个接口，根据上述两种情况。

例如，

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