Map.Entry接口的

Question

​​我所知是public static interface在java.util包 回報地圖的集合視圖，但據我現在很困惑與靜態接口 並且因爲它是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

是的，它是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(); 
    } 

---

有關接口的詳細信息，請參閱Interfaces教程，這Static Nested Interfaces文章。

Answer 4

實施例：

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

酒吧是嵌套接口。嵌套接口，默認情況下靜態的，所以你可以和寫：

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

現在，是什麼意思靜在這種情況下是該接口是一個靜態成員，即類的一個成員。

你可以用類也這麼做：

public class Tree { 
    private static class Node { 

    } 
} 

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

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

Answer 5

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

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

Bohemian's answer地址如何使用Map.Entry。

Answer 6

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

可以有內界面，如下所示：

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

    } 



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

    } 

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

例如，

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