javamap的底层

1. java中,map分为哪些种类

您好，提问者：
Map：HashMap、TreeMap、Hashtable。
1、HashMap：线程不安全，键、值不允许为null。
2、Hashtable：线程安全，键、值允许为null。
3、TreeMap：线程不安全、键、值不允许为null，底层二叉树。

2. java里map底层是通过什么实现的队列和键值有什么区别

它的实现原理有些类似于二维数组,但是新的HashMap集合,是采用异步方式来实现的,它的效率较高!老的TableMap是同步实现的的,所以现在不推荐用这个，有时间可以看看底层代码，一看就明白了，很简单的

3. java中，HashMap底层数据结构是什么

jdk1.8以前是数组+连表,jdk1.8以后是数组+连散局渗表+红黑树,数组长度超过8会变成红黑腊派树,小于8依然是冲脊数组+连表

4. JAVA中的HASHSET和HASHMap的底层实现是怎样的大致讲一下。

HASHMAP是根据HASH算法储存数据的集合类，每一个存入其中的对象都有一个特定的哈希值！当我们新建一个HashMap对象，如果不给定它的大小，其默认为16，就相当与下面新建了编号为0到15的数组(链表数组)。以默认HashMap为例，put一个对象时，首先得到他的哈希值，在与十五相除得到余埋差指数，找到与余数相同编号的数组插入其中！HASHSET就是没有value值的HASHMAP，你可以新建一个HASHSET,插入弯配0到15，绝对以0到15的顺序打印庆清。

5. Java中HashMap和TreeMap的区别深入理解

首先介绍一下什么是Map。在数组中我们是通过数组下标来对其内容索引的，而在Map中我们通过对象来对对象进行索引，用来索引的对象叫做key，其对应的对象叫做value

首先介绍一下什么是Map。在数组中我们是通过数组下标来对其内容索引的，而在Map中我们通过对象来对对象进行索引，用来索引的对象叫做key，其对应的对象叫做value。这就是我们平时说的键值对。

HashMap通过hashcode对其内容进行快速查找，而
TreeMap中所有的元素都保持着某种固定的顺序，如果你需要得到一个有序的结果你就应该使用TreeMap（HashMap中元素的排列顺序是不固定的）。

HashMap 非线程安全 TreeMap 非线程安全

线程安全

在Java里，线程安全一般体现在两个方面：

1、多个thread对同一个java实例的访问（read和modify）不会相互干扰，它主要体现在关键字synchronized。如ArrayList和Vector，HashMap和Hashtable

（后者每个方法前都有synchronized关键字）。如果你在interator一个List对象时，其它线程remove一个element，问题就出现了。

2、每个线程都有自己的字段，而不会在多个线程之间共享。它主要体现在java.lang.ThreadLocal类，而没有Java关键字支持，如像static、transient那样。

1.AbstractMap抽象类和SortedMap接口

AbstractMap抽象类：(HashMap继承AbstractMap)覆盖了equals()和hashCode()方法以确保两个相等映射返回相同的哈希码。如果两个映射大小相等、包含同样的键且每个键在这两个映射中对应的值都相同，则这两个映射相等。映射的哈希码是映射元素哈希码的总和，其中每个元素是Map.Entry接口的一个实现。因此，不论映射内部顺序如何，两个相等映射会报告相同的哈希码。

SortedMap接口：（TreeMap继承自SortedMap）它用来保持键的有序顺序。SortedMap接口为映像的视图(子集)，包括两个端点提供了访问方法。除了排序是作用于映射的键以外，处理SortedMap和处理SortedSet一样。添加到SortedMap实现类的元素必须实现Comparable接口，否则您必须给它的构造函数提供一个Comparator接口的实现。TreeMap类是它的唯一一份实现。

2.两种常规Map实现

HashMap：基于哈希表实现。使用HashMap要求添加的键类明确定义了hashCode()和equals()[可以重写hashCode()和equals()]，为了优化HashMap空间的使用，您可以调优初始容量和负载因子。

(1)HashMap(): 构建一个空的哈希映像
(2)HashMap(Map m): 构建一个哈希映像，并且添加映像m的所有映射

(3)HashMap(int initialCapacity): 构建一个拥有特定容量的空的哈希映像
(4)HashMap(int
initialCapacity, float loadFactor): 构建一个拥有特定容量和加载因子的空的哈希映像

TreeMap：基于红黑树实现。TreeMap没有调优选项，因为该树总处于平衡状态。
(1)TreeMap():构建一个空的映像树

(2)TreeMap(Map m): 构建一个映像树，并且添加映像m中所有元素
(3)TreeMap(Comparator c):
构建一个映像树，并且使用特定的比较器对关键字进行排序
(4)TreeMap(SortedMap s):
构建一个映像树，添加映像树s中所有映射，并且使用与有序映像s相同的比较器排序

3.两种常规Map性能

HashMap：适用于在Map中插入、删除和定位元素。
Treemap：适用于按自然顺序或自定义顺序遍历键(key)。

4.总结

HashMap通常比TreeMap快一点(树和哈希表的数据结构使然)，建议多使用HashMap，在需要排序的Map时候才用TreeMap。

复制代码
代码如下:

import java.util.HashMap;
import
java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;

import java.util.TreeMap;
public class HashMaps {
public static void
main(String[] args) {
Map<String, String> map = new HashMap<String,
String>();
map.put("a", "aaa");
map.put("b", "bbb");
map.put("c",
"ccc");
map.put("d", "ddd");
Iterator<String> iterator =
map.keySet().iterator();
while (iterator.hasNext()) {
Object key =
iterator.next();
System.out.println("map.get(key) is :" + map.get(key));

}
// 定义HashTable,用来测试
Hashtable<String, String> tab = new
Hashtable<String, String>();
tab.put("a", "aaa");
tab.put("b",
"bbb");
tab.put("c", "ccc");
tab.put("d", "ddd");

Iterator<String> iterator_1 = tab.keySet().iterator();
while
(iterator_1.hasNext()) {
Object key = iterator_1.next();

System.out.println("tab.get(key) is :" + tab.get(key));
}

TreeMap<String, String> tmp = new TreeMap<String, String>();

tmp.put("a", "aaa");
tmp.put("b", "bbb");
tmp.put("c", "ccc");

tmp.put("d", "cdc");
Iterator<String> iterator_2 =
tmp.keySet().iterator();
while (iterator_2.hasNext()) {
Object key =
iterator_2.next();
System.out.println("tmp.get(key) is :" + tmp.get(key));

}
}
}

运行结果如下：
map.get(key) is :ddd

map.get(key) is :bbb
map.get(key) is :ccc
map.get(key) is :aaa

tab.get(key) is :bbb
tab.get(key) is :aaa
tab.get(key) is :ddd

tab.get(key) is :ccc
tmp.get(key) is :aaa
tmp.get(key) is :bbb

tmp.get(key) is :ccc
tmp.get(key) is :cdc

HashMap的结果是没有排序的，而TreeMap输出的结果是排好序的。
下面就要进入本文的主题了。先举个例子说明一下怎样使用HashMap:

复制代码
代码如下:

import java.util.*;
public class Exp1 {

public static void main(String[] args){
HashMap h1=new HashMap();

Random r1=new Random();
for (int i=0;i<1000;i++){
Integer t=new
Integer(r1.nextInt(20));
if (h1.containsKey(t))

((Ctime)h1.get(t)).count++;
else
h1.put(t, new Ctime());
}

System.out.println(h1);
}
}
class Ctime{
int count=1;

public String toString(){
return Integer.toString(count);
}
}

在HashMap中通过get()来获取value，通过put()来插入value，ContainsKey()则用来检验对象是否已经存在。可以看出，和ArrayList的操作相比，HashMap除了通过key索引其内容之外，别的方面差异并不大。

前面介绍了，HashMap是基于HashCode的，在所有对象的超类Object中有一个HashCode()方法，但是它和equals方法一样，并不能适用于所有的情况，这样我们就需要重写自己的HashCode()方法。下面就举这样一个例子：

复制代码
代码如下:

import java.util.*;
public class Exp2 {

public static void main(String[] args){
HashMap h2=new HashMap();

for (int i=0;i<10;i++)
h2.put(new Element(i), new Figureout());

System.out.println("h2:");
System.out.println("Get the result for
Element:");
Element test=new Element(5);
if (h2.containsKey(test))

System.out.println((Figureout)h2.get(test));
else

System.out.println("Not found");
}
}
class Element{
int
number;
public Element(int n){
number=n;
}
}
class
Figureout{
Random r=new Random();
boolean
possible=r.nextDouble()>0.5;
public String toString(){
if (possible)

return "OK!";
else
return "Impossible!";
}
}

在这个例子中，Element用来索引对象Figureout,也即Element为key，Figureout为value。在Figureout中随机生成一个浮点数，如果它比0.5大，打印"OK!"，否则打印"Impossible!"。之后查看Element(3)对应的Figureout结果如何。

结果却发现，无论你运行多少次，得到的结果都是"Not found"。也就是说索引Element(3)并不在HashMap中。这怎么可能呢？

原因得慢慢来说：Element的HashCode方法继承自Object，而Object中的HashCode方法返回的HashCode对应于当前的地址，也就是说对于不同的对象，即使它们的内容完全相同，用HashCode（）返回的值也会不同。这样实际上违背了我们的意图。因为我们在使用
HashMap时，希望利用相同内容的对象索引得到相同的目标对象，这就需要HashCode()在此时能够返回相同的值。在上面的例子中，我们期望 new
Element(i) (i=5)与
Elementtest=newElement(5)是相同的，而实际上这是两个不同的对象，尽管它们的内容相同，但它们在内存中的地址不同。因此很自然的，上面的程序得不到我们设想的结果。下面对Element类更改如下：

复制代码
代码如下:

class Element{
int number;
public
Element(int n){
number=n;
}
public int hashCode(){
return
number;
}
public boolean equals(Object o){
return (o instanceof
Element) && (number==((Element)o).number);
}
}

在这里Element覆盖了Object中的hashCode()和equals()方法。覆盖hashCode()使其以number的值作为
hashcode返回，这样对于相同内容的对象来说它们的hashcode也就相同了。而覆盖equals()是为了在HashMap判断两个key是否相等时使结果有意义（有关重写equals()的内容可以参考我的另一篇文章《重新编写Object类中的方法》）。修改后的程序运行结果如下：

h2:
Get the result for Element:
Impossible!

请记住：如果你想有效的使用HashMap，你就必须重写在其的HashCode()。
还有两条重写HashCode()的原则：

[list=1]

不必对每个不同的对象都产生一个唯一的hashcode，只要你的HashCode方法使get()能够得到put()放进去的内容就可以了。即"不为一原则"。

生成hashcode的算法尽量使hashcode的值分散一些，不要很多hashcode都集中在一个范围内，这样有利于提高HashMap的性能。即"分散原则"。至于第二条原则的具体原因，有兴趣者可以参考Bruce
Eckel的《Thinking in Java》，在那里有对HashMap内部实现原理的介绍，这里就不赘述了。

掌握了这两条原则，你就能够用好HashMap编写自己的程序了。不知道大家注意没有，java.lang.Object中提供的三个方法：clone()，equals()和hashCode()虽然很典型，但在很多情况下都不能够适用，它们只是简单的由对象的地址得出结果。这就需要我们在自己的程序中重写它们，其实java类库中也重写了千千万万个这样的方法。利用面向对象的多态性——覆盖，Java的设计者很优雅的构建了Java的结构，也更加体现了Java是一门纯OOP语言的特性。

6. java里面的map是什么

java为数据结构中的映射定义了一个接口java.util.Map
Map主要用于存储健值对，根据键得到值，因此不允许键重复(重复了覆盖了),但允许值重复。

7. Java 中Map与数组的比较

1、数组特点高效、保存基本类型，集合带array的底层由数组实现，还有一部分由链表或者树
2、数组大小固定（巨大缺点，内存中一定连续），集合各种实现吧！
3、数组只能放一种类型，集合不考虑泛型可以存很多类型。
4、集合放原始类型其实是通过装箱拆箱来实现的，说白了以前原生类型只能用数组，现在集合也可以了。因为这个改进，所以现在基本上除了性能外，均推荐使用集合。

8. Java中HashMap和TreeMap的区别深入理解

HashMap底层是用数组做的，TreeMap是基于树做的
这么做的结果就是HashMap的数据在不停的添加的时候效率会比较低，而对于查找的效率是比较快的，TreeMap对于添加的效率是比较高的但是对于查找的效率要相对比较低一些

这里简单从底层说一下，我就不从具体的实现上说，只从数据结构和大致的原理上来补充一下我的答案。
HashMap这个类在存储的时候，首先根据key来计算机将要存储的key-value映射对存储在数组的什么位置上，当计算出位置后就把这个映射对存储到这个位置上。当读取的时候，首先根据key来计算出一个位置来，到数组的相应的位置上去读取数据，如果没有数据，则表示此Map中不存在该映射对，若存在则直接返回。说到这里就可以解释一下为什么对于不停地存储的效率相对比较低了，首先在初始化的时候对于数组的长度给了一个初始的长度，当往这里面添加数据达到一定的程度的时候就没法继续添加数据了，继续添加数据的冲突就会增大，或者没法添加数据（这里有一个衡量的量就是装填因子，是指这个数组中的添加的数据的个数和数组长度的比值，在java中比较合理的装填因子数是0.75），当数据添加到这个程度的时候不能不让用户继续添加数据吧，总得解决继续添加数据的问题啊，于是提出了解决方案，即开一个更大的数组，把当前上的每一个数据重新在更大的数组上计算位置，并把数据复制过去，这样完成的数组的扩大，看完这个我们知道，这个过程是很耗时的，所以说对于不停的存储数据时效率是比较低的。这里有没有一个稍微好一点的解决方案或者说不需要进行数组的扩大吗，我们能不能一开始在初始化的时候就把数组的空间开辟的足够大，这样就不用在存储的过程进行复制了，可以吗，答案是肯定的，java给我们提供了这个在初始化的时候的方式。但是，也是有问题的那就是我们的数据不够多，就会造成空间的浪费。有没有一个速度即快又不浪费空间的方式呢，解决方案也有一个，那就是在开始的时候我们就能很好的预测数据的规模，这样我们在开始的时候按照相应的规模进行初始化，这样就很好了，实际中我们是不能很好的预测这个规模的。于是对于这种情况提出了下一个解决方案TreeMap。
TreeMap是一个基于树的存储结构，学过数据结构的应该知道，树的实现方式是基于指针实现的，在Java中是用引用模拟实现的，这里大家都知道，其实树的读取效率并不低，这里是相对于数组的顺序查找来说的，但是与HashMap的查找方式相比就有了差距，HashMap是上来先问你在哪，直接就去取数据了，TreeMap需要遍历，也就是需要挨个询问你是我要的东西吗，对比一下，是就返回，不是就继续查找，于是查找的效率就低了，但是它解决了HashMap数组扩大的时候的效率问题，就是新添加的数据可以往里面添加，不会出现复制的情况，这里就是由于模拟的指针的缘故实现的。
其实从总体来说这两个各有利弊，我们在使用的时候需要根据实际的需要来选择相应的类。

9. java中的Map有什么用呢

Map的接口Map－－－实现Map
Map.Entry－－Map的内部类，描述Map中的按键/数值对。
SortedMap---扩展Map，使按键保持升序排列
下面以HashMap为例。
public static void main(String args[]){HashMap hashmap = new HashMap();
hashmap.put("Item0", "Value0");
hashmap.put("Item1", "Value1");
hashmap.put("Item2", "Value2");
hashmap.put("Item3", "Value3");
Set set = hashmap.entrySet();
Iterator iterator = set.iterator();
while (iterator.hasNext(){Map.Entry mapentry = (Map.Entry) iterator.next();
System.out.println(mapentry.getkey() + "/" + mapentry.getValue());}}注意，这里Map的按键必须是唯一的，比如说不能有两个按键都为null。
如果用过它，就会知道它的用处了。
资料:java.util 中的集合类包含 Java 中某些最常用的类。 最常用的集合类是 List 和 Map。 List 的具体实现包括 ArrayList 和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。 List 适用于按数值索引访问元素的情形。Map 提供了一个更通用的元素存储方法。 Map 集合类用于存储元素对（称作“键”和“值”），其中每个键映射到一个值。 从概念上而言，您可以将 List 看作是具有数值键的 Map。 而实际上，除了 List 和 Map 都在定义 java.util 中外，两者并没有直接的联系。本文将着重介绍核心 Java 发行套件中附带的 Map，同时还将介绍如何采用或实现更适用于您应用程序特定数据的专用 Map。了解Map 接口和方法Java 核心类中有很多预定义的 Map 类。 在介绍具体实现之前，我们先介绍一下 Map 接口本身，以便了解所有实现的共同点。 Map 接口定义了四种类型的方法，每个 Map 都包含这些方法。 下面，我们从两个普通的方法（表1）开始对这些方法加以介绍。表1： 覆盖的方法。 我们将这 Object 的这两个方法覆盖，以正确比较 Map 对象的等价性。equals(Object o)比较指定对象与此 Map 的等价性hashCode()返回此 Map 的哈希码Map 构建Map 定义了几个用于插入和删除元素的变换方法（表2）。表2： Map 更新方法： 可以更改 Map 内容。clear()从Map 中删除所有映射remove(Object key)从Map 中删除键和关联的值put(Object key, Object value)将指定值与指定键相关联clear()从Map 中删除所有映射putAll(Map t)将指定 Map 中的所有映射复制到此 map尽管您可能注意到，纵然假设忽略构建一个需要传递给 putAll() 的 Map 的开销，使用 putAll() 通常也并不比使用大量的 put() 调用更有效率，但 putAll() 的存在一点也不稀奇。 这是因为，putAll() 除了迭代 put() 所执行的将每个键值对添加到 Map 的算法以外，还需要迭代所传递的 Map 的元素。 但应注意，putAll() 在添加所有元素之前可以正确调整 Map 的大小，因此如果您未亲自调整 Map 的大小（我们将对此进行简单介绍），则 putAll() 可能比预期的更有效。查看Map迭代Map 中的元素不存在直接了当的方法。 如果要查询某个 Map 以了解其哪些元素满足特定查询，或如果要迭代其所有元素（无论原因如何），则您首先需要获取该 Map 的“视图”。 有三种可能的视图（参见表3）所有键值对 — 参见 entrySet()所有键 — 参见 keySet()所有值 — 参见 values()前两个视图均返回 Set 对象，第三个视图返回 Collection 对象。 就这两种情况而言，问题到这里并没有结束，这是因为您无法直接迭代 Collection 对象或 Set 对象。要进行迭代，您必须获得一个 Iterator 对象。 因此，要迭代 Map 的元素，必须进行比较烦琐的编码Iterator keyValuePairs = aMap.entrySet().iterator();Iterator keys = aMap.keySet().iterator();Iterator values = aMap.values().iterator();值得注意的是，这些对象（Set、Collection 和 Iterator）实际上是基础 Map 的视图，而不是包含所有元素的副本。 这使它们的使用效率很高。 另一方面，Collection 或 Set 对象的 toArray() 方法却创建包含 Map 所有元素的数组对象，因此除了确实需要使用数组中元素的情形外，其效率并不高。我运行了一个小测试（随附文件中的 Test1），该测试使用了 HashMap，并使用以下两种方法对迭代 Map 元素的开销进行了比较：int mapsize = aMap.size();Iterator keyValuePairs1 = aMap.entrySet().iterator();for (int i = 0; i < mapsize; i++){ Map.Entry entry = (Map.Entry) keyValuePairs1.next(); Object key = entry.getKey(); Object value = entry.getValue(); ...}Object[] keyValuePairs2 = aMap.entrySet().toArray();for (int i = 0; i < rem; i++) {{ Map.Entry entry = (Map.Entry) keyValuePairs2[i]; Object key = entry.getKey();
Profilers in Oracle JDeveloperOracle JDeveloper 包含一个嵌入的监测器，它测量内存和执行时间，使您能够快速识别代码中的瓶颈。 我曾使用 Jdeveloper 的执行监测器监测 HashMap 的 containsKey() 和 containsValue() 方法，并很快发现 containsKey() 方法的速度比 containsValue() 方法慢很多（实际上要慢几个数量级！）。 （参见图1 和图2，以及随附文件中的 Test2 类）。 Object value = entry.getValue(); ...}此测试使用了两种测量方法： 一种是测量迭代元素的时间，另一种测量使用 toArray 调用创建数组的其他开销。 第一种方法（忽略创建数组所需的时间）表明，使用已从 toArray 调用中创建的数组迭代元素的速度要比使用 Iterator 的速度大约快 30%-60%。 但如果将使用 toArray 方法创建数组的开销包含在内，则使用 Iterator 实际上要快 10%-20%。 因此，如果由于某种原因要创建一个集合元素的数组而非迭代这些元素，则应使用该数组迭代元素。 但如果您不需要此中间数组，则不要创建它，而是使用 Iterator 迭代元素。表3： 返回视图的 Map 方法： 使用这些方法返回的对象，您可以遍历 Map 的元素，还可以删除 Map 中的元素。entrySet()返回Map 中所包含映射的 Set 视图。 Set 中的每个元素都是一个 Map.Entry 对象，可以使用 getKey() 和 getValue() 方法（还有一个 setValue() 方法）访问后者的键元素和值元素keySet()返回Map 中所包含键的 Set 视图。 删除 Set 中的元素还将删除 Map 中相应的映射（键和值）values()返回map 中所包含值的 Collection 视图。 删除 Collection 中的元素还将删除 Map 中相应的映射（键和值）访问元素表4 中列出了 Map 访问方法。Map 通常适合按键（而非按值）进行访问。 Map 定义中没有规定这肯定是真的，但通常您可以期望这是真的。 例如，您可以期望 containsKey() 方法与 get() 方法一样快。 另一方面，containsValue() 方法很可能需要扫描 Map 中的值，因此它的速度可能比较慢。表4： Map 访问和测试方法： 这些方法检索有关 Map 内容的信息但不更改 Map 内容。get(Object key)返回与指定键关联的值containsKey(Object key)如果Map 包含指定键的映射，则返回 truecontainsValue(Object value)如果此 Map 将一个或多个键映射到指定值，则返回 trueisEmpty()如果Map 不包含键-值映射，则返回 truesize()返回Map 中的键-值映射的数目对使用 containsKey() 和 containsValue() 遍历 HashMap 中所有元素所需时间的测试表明，containsValue() 所需的时间要长很多。 实际上要长几个数量级！ （参见图1 和图2，以及随附文件中的 Test2）。 因此，如果 containsValue() 是应用程序中的性能问题，它将很快显现出来，并可以通过监测您的应用程序轻松地将其识别。 这种情况下，我相信您能够想出一个有效的替换方法来实现 containsValue() 提供的等效功能。 但如果想不出办法，则一个可行的解决方案是再创建一个 Map，并将第一个 Map 的所有值作为键。

10. java中的set和map的内部实现细节是什么（就像ArrayList是Object数组，LinkedList是链表），越详细越好。

一个不包含重复元素的 collection。更确切地讲，set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素。正如其名称所暗示的，此接口模仿了数学上的 set 抽象。

在所有构造方法以及 add、equals 和 hashCode 方法的协定上，Set 接口还加入了其他规定，这些规定超出了从 Collection 接口所继承的内容。出于方便考虑，它还包括了其他继承方法的声明（这些声明的规范已经专门针对 Set 接口进行了修改，但是没有包含任何其他的规定）。

对这些构造方法的其他规定是（不要奇怪），所有构造方法必须创建一个不包含重复元素的 set（正如上面所定义的）。

注：如果将可变对象用作 set 元素，那么必须极其小心。如果对象是 set 中某个元素，以一种影响 equals 比较的方式改变对象的值，那么 set 的行为就是不确定的。此项禁止的一个特殊情况是不允许某个 set 包含其自身作为元素。

某些 set 实现对其所包含的元素有所限制。例如，某些实现禁止 null 元素，而某些则对其元素的类型所有限制。试图添加不合格的元素会抛出未经检查的异常，通常是 NullPointerException 或 ClassCastException。试图查询不合格的元素是否存在可能会抛出异常，也可能简单地返回 false；某些实现会采用前一种行为，而某些则采用后者。概括地说，试图对不合格元素执行操作时，如果完成该操作后不会导致在 set 中插入不合格的元素，则该操作可能抛出一个异常，也可能成功，这取决于实现的选择。此接口的规范中将这样的异常标记为“可选”。
public interface Map<K,V>将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

此接口取代 Dictionary 类，后者完全是一个抽象类，而不是一个接口。

Map 接口提供三种collection 视图，允许以键集、值集或键-值映射关系集的形式查看某个映射的内容。映射顺序 定义为迭代器在映射的 collection 视图上返回其元素的顺序。某些映射实现可明确保证其顺序，如 TreeMap 类；另一些映射实现则不保证顺序，如 HashMap 类。

注：将可变对象用作映射键时必须格外小心。当对象是映射中某个键时，如果以影响 equals 比较的方式更改了对象的值，则映射的行为将是不确定的。此项禁止的一种特殊情况是不允许某个映射将自身作为一个键包含。虽然允许某个映射将自身作为值包含，但请格外小心：在这样的映射上 equals 和 hashCode 方法的定义将不再是明确的。

所有通用的映射实现类应该提供两个“标准的”构造方法：一个 void（无参数）构造方法，用于创建空映射；一个是带有单个 Map 类型参数的构造方法，用于创建一个与其参数具有相同键-值映射关系的新映射。实际上，后一个构造方法允许用户复制任意映射，生成所需类的一个等价映射。尽管无法强制执行此建议（因为接口不能包含构造方法），但是 JDK 中所有通用的映射实现都遵从它。

此接口中包含的“破坏”方法可修改其操作的映射，如果此映射不支持该操作，这些方法将抛出 UnsupportedOperationException。如果是这样，那么在调用对映射无效时，这些方法可以（但不要求）抛出 UnsupportedOperationException。例如，如果某个不可修改的映射（其映射关系是“重叠”的）为空，则对该映射调用 putAll(Map) 方法时，可以（但不要求）抛出异常。

某些映射实现对可能包含的键和值有所限制。例如，某些实现禁止 null 键和值，另一些则对其键的类型有限制。尝试插入不合格的键或值将抛出一个未经检查的异常，通常是 NullPointerException 或 ClassCastException。试图查询是否存在不合格的键或值可能抛出异常，或者返回 false；某些实现将表现出前一种行为，而另一些则表现后一种。一般来说，试图对不合格的键或值执行操作且该操作的完成不会导致不合格的元素被插入映射中时，将可能抛出一个异常，也可能操作成功，这取决于实现本身。这样的异常在此接口的规范中标记为“可选”。

此接口是 Java Collections Framework 的成员。

Collections Framework 接口中的很多方法是根据 equals 方法定义的。例如，containsKey(Object key) 方法的规范中写道：“当且仅当此映射包含针对满足 (key==null ? k==null : key.equals(k)) 的键 k 的映射关系时，返回 true”。不 应将此规范解释为：调用具有非空参数 key 的 Map.containsKey 将导致对任意的键 k 调用 key.equals(k)。实现可随意进行优化，以避免调用 equals，例如，可首先比较两个键的哈希码（Object.hashCode() 规范保证哈希码不相等的两个对象不会相等）。一般来说，只要实现者认为合适，各种 Collections Framework 接口的实现可随意利用底层 Object 方法的指定行为。