java.util.Map.Entry是public static interface个java.util包中的{{1}}
返回地图的集合视图，但到目前为止，我对静态界面感到困惑
因为它是Map.Entry它是一个内部接口，如果是这样我们如何在java
看看我很困惑的人请以任何可能的方式帮助我。
答案 0 :(得分：8)
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()
}
答案 1 :(得分：2)
没有什么可以混淆的。
是的，Java允许接口成为类或其他接口的成员。
不，这并不意味着什么特别的。它完全没有改变你如何使用这样的界面或你可以用它做什么。
它只更改该接口的名称，并在它与其封闭类型之间创建一个强大的概念链接。在这种情况下，Map.Entry表示Map的条目。 API的设计者显然认为通过使其成为成员类型来强调这种联系是有意义的。
答案 2 :(得分：2)
示例：
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对象（如树或链接列表），或者该类仅在外部类的上下文中有意义。
答案 3 :(得分：0)
是的，它是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())) &&
* (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文章。
答案 4 :(得分：0)
Java允许nested interfaces。您可以将它们嵌套到类或接口中。例如，Map.Entry是Map接口中定义的嵌套接口。
Map个实现（TreeMap，HashMap）提供了Map.Entry的私有实现，这些实现在类外是不可见的。
Bohemian's answer介绍了如何使用Map.Entry。
答案 5 :(得分：0)
内部接口隐式公开和静态。
您可以使用以下内部接口：
st=stations.objects.filter(station_id=sequence.objects.filter(route_id=rid))您可以通过A.B访问上述内部接口（B），其中A是根据上述两种情况的类或接口。
例如，
1. interface A {
.....
.....
interface B {
....
....
}
}
2. class A {
....
....
interface B {
....
....
}
}