介绍java中list，set和map 的区别

 

Java中ArrayList类的用法

1、什么是ArrayList
ArrayList就是传说中的动态数组，用MSDN中的说法，就是Array的复杂版本，它提供了如下一些好处：
动态的增加和减少元素
实现了ICollection和IList接口
灵活的设置数组的大小

2、如何使用ArrayList
最简单的例子：
ArrayList List = new ArrayList();
for( int i=0;i <10;i++ ) //给数组增加10个Int元素
List.Add(i);
//..程序做一些处理
List.RemoveAt(5);//将第6个元素移除
for( int i=0;i <3;i++ ) //再增加3个元素
List.Add(i+20);
Int32[] values = (Int32[])List.ToArray(typeof(Int32));//返回ArrayList包含的数组

这是一个简单的例子，虽然没有包含ArrayList所有的方法，但是可以反映出ArrayList最常用的用法

3、ArrayList重要的方法和属性
1）构造器
ArrayList提供了三个构造器：
public ArrayList();
默认的构造器，将会以默认（16）的大小来初始化内部的数组
public ArrayList(ICollection);
用一个ICollection对象来构造，并将该集合的元素添加到ArrayList
public ArrayList(int);
用指定的大小来初始化内部的数组

2）IsSynchronized属性和ArrayList.Synchronized方法
IsSynchronized属性指示当前的ArrayList实例是否支持线程同步，而ArrayList.Synchronized静态方法则会返回一个ArrayList的线程同步的封装。
如果使用非线程同步的实例，那么在多线程访问的时候，需要自己手动调用lock来保持线程同步，例如：
ArrayList list = new ArrayList();
//...
lock( list.SyncRoot ) //当ArrayList为非线程包装的时候，SyncRoot属性其实就是它自己，但是为了满足ICollection的SyncRoot定义，这里还是使用SyncRoot来保持源代码的规范性
{
list.Add( “Add a Item” );
}

如果使用ArrayList.Synchronized方法返回的实例，那么就不用考虑线程同步的问题，这个实例本身就是线程安全的，实际上ArrayList内部实现了一个保证线程同步的内部类，ArrayList.Synchronized返回的就是这个类的实例，它里面的每个属性都是用了lock关键字来保证线程同步。

3）Count属性和Capacity属性
Count属性是目前ArrayList包含的元素的数量，这个属性是只读的。
Capacity属性是目前ArrayList能够包含的最大数量，可以手动的设置这个属性，但是当设置为小于Count值的时候会引发一个异常。

4）Add、AddRange、Remove、RemoveAt、RemoveRange、Insert、InsertRange
这几个方法比较类似
Add方法用于添加一个元素到当前列表的末尾
AddRange方法用于添加一批元素到当前列表的末尾
Remove方法用于删除一个元素，通过元素本身的引用来删除
RemoveAt方法用于删除一个元素，通过索引值来删除
RemoveRange用于删除一批元素，通过指定开始的索引和删除的数量来删除
Insert用于添加一个元素到指定位置，列表后面的元素依次往后移动
InsertRange用于从指定位置开始添加一批元素，列表后面的元素依次往后移动

另外，还有几个类似的方法：
Clear方法用于清除现有所有的元素
Contains方法用来查找某个对象在不在列表之中

其他的我就不一一累赘了，大家可以查看MSDN，上面讲的更仔细
5）TrimSize方法
这个方法用于将ArrayList固定到实际元素的大小，当动态数组元素确定不在添加的时候，可以调用这个方法来释放空余的内存。
6）ToArray方法
这个方法把ArrayList的元素Copy到一个新的数组中。
4、ArrayList与数组转换
例1：
ArrayList List = new ArrayList();
List.Add(1);
List.Add(2);
List.Add(3);

Int32[] values = (Int32[])List.ToArray(typeof(Int32));

例2：
ArrayList List = new ArrayList();
List.Add(1);
List.Add(2);
List.Add(3);

Int32[] values = new Int32[List.Count];
List.CopyTo(values);

上面介绍了两种从ArrayList转换到数组的方法

例3：
ArrayList List = new ArrayList();
List.Add( “string” );
List.Add( 1 );
//往数组中添加不同类型的元素

object[] values = List.ToArray(typeof(object)); //正确
string[] values = (string[])List.ToArray(typeof(string)); //错误

和数组不一样，因为可以转换为Object数组，所以往ArrayList里面添加不同类型的元素是不会出错的，但是当调用ArrayList方法的时候，要么传递所有元素都可以正确转型的类型或者Object类型，否则将会抛出无法转型的异常。

5、ArrayList最佳使用建议
这一节我们来讨论ArrayList与数组的差别，以及ArrayList的效率问题
1）ArrayList是Array的复杂版本
ArrayList内部封装了一个Object类型的数组，从一般的意义来说，它和数组没有本质的差别，甚至于ArrayList的许多方法，如Index、IndexOf、Contains、Sort等都是在内部数组的基础上直接调用Array的对应方法。
2）内部的Object类型的影响
对于一般的引用类型来说，这部分的影响不是很大，但是对于值类型来说，往ArrayList里面添加和修改元素，都会引起装箱和拆箱的操作，频繁的操作可能会影响一部分效率。
但是恰恰对于大多数人，多数的应用都是使用值类型的数组。
消除这个影响是没有办法的，除非你不用它，否则就要承担一部分的效率损失，不过这部分的损失不会很大。
3）数组扩容
这是对ArrayList效率影响比较大的一个因素。
每当执行Add、AddRange、Insert、InsertRange等添加元素的方法，都会检查内部数组的容量是否不够了，如果是，它就会以当前容量的两倍来重新构建一个数组，将旧元素Copy到新数组中，然后丢弃旧数组，在这个临界点的扩容操作，应该来说是比较影响效率的。
例1：比如，一个可能有200个元素的数据动态添加到一个以默认16个元素大小创建的ArrayList中，将会经过：
16*2*2*2*2 = 256
四次的扩容才会满足最终的要求，那么如果一开始就以：
ArrayList List = new ArrayList( 210 );
的方式创建ArrayList，不仅会减少4次数组创建和Copy的操作，还会减少内存使用。

例2：预计有30个元素而创建了一个ArrayList：
ArrayList List = new ArrayList(30);
在执行过程中，加入了31个元素，那么数组会扩充到60个元素的大小，而这时候不会有新的元素再增加进来，而且有没有调用TrimSize方法，那么就有1次扩容的操作，并且浪费了29个元素大小的空间。如果这时候，用：
ArrayList List = new ArrayList(40);
那么一切都解决了。
所以说，正确的预估可能的元素，并且在适当的时候调用TrimSize方法是提高ArrayList使用效率的重要途径。
4）频繁的调用IndexOf、Contains等方法（Sort、BinarySearch等方法经过优化，不在此列）引起的效率损失
首先，我们要明确一点，ArrayList是动态数组，它不包括通过Key或者Value快速访问的算法，所以实际上调用IndexOf、Contains等方法是执行的简单的循环来查找元素，所以频繁的调用此类方法并不比你自己写循环并且稍作优化来的快，如果有这方面的要求，建议使用Hashtable或SortedList等键值对的集合。
ArrayList al=new ArrayList();

al.Add("How");
al.Add("are");
al.Add("you!");

al.Add(100);
al.Add(200);
al.Add(300);

al.Add(1.2);
al.Add(22.8);

 

-------------------------------------------------------
System.Collections.ArrayList类是一个特殊的数组。通过添加和删除元素，就可以动态改变数组的长度。
一．优点
1。支持自动改变大小的功能
2。可以灵活的插入元素
3。可以灵活的删除元素
二．局限性
跟一般的数组比起来，速度上差些
三．添加元素
1．publicvirtualintAdd(objectvalue);
将对象添加到ArrayList的结尾处
ArrayListaList=newArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
内容为abcde
2．publicvirtualvoidInsert(intindex,objectvalue);
将元素插入ArrayList的指定索引处
ArrayListaList=newArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
aList.Insert(0,"aa");
结果为aaabcde
3．publicvirtualvoidInsertRange(intindex,ICollectionc);
将集合中的某个元素插入ArrayList的指定索引处
ArrayListaList=newArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
ArrayListlist2=newArrayList();
list2.Add("tt");
list2.Add("ttt");
aList.InsertRange(2,list2);
结果为abtttttcde
四．删除
a)publicvirtualvoidRemove(objectobj);
从ArrayList中移除特定对象的第一个匹配项,注意是第一个
ArrayListaList=newArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
aList.Remove("a");
结果为bcde
2.publicvirtualvoidRemoveAt(intindex);
移除ArrayList的指定索引处的元素
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
aList.RemoveAt(0);
结果为bcde
3．publicvirtualvoidRemoveRange(intindex,intcount);
从ArrayList中移除一定范围的元素。Index表示索引，count表示从索引处开始的数目
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
aList.RemoveRange(1,3);
结果为ae
4．publicvirtualvoidClear();
从ArrayList中移除所有元素。
五．排序
a)publicvirtualvoidSort();
对ArrayList或它的一部分中的元素进行排序。
ArrayListaList=newArrayList();
aList.Add("e");
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
DropDownList1.DataSource=aList;//DropDownListDropDownList1;
DropDownList1.DataBind();
结果为eabcd
ArrayListaList=newArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
aList.Sort();//排序
DropDownList1.DataSource=aList;//DropDownListDropDownList1;
DropDownList1.DataBind();
结果为abcde
b)publicvirtualvoidReverse();
将ArrayList或它的一部分中元素的顺序反转。
ArrayListaList=newArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
aList.Reverse();//反转
DropDownList1.DataSource=aList;//DropDownListDropDownList1;
DropDownList1.DataBind();
结果为edcba
六．查找
a)publicvirtualintIndexOf(object);
b)publicvirtualintIndexOf(object,int);
c)publicvirtualintIndexOf(object,int,int);
返回ArrayList或它的一部分中某个值的第一个匹配项的从零开始的索引。没找到返回-1。
ArrayListaList=newArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
intnIndex=aList.IndexOf(“a”);//1
nIndex=aList.IndexOf(“p”);//没找到，-1
d)publicvirtualintLastIndexOf(object);
e)publicvirtualintLastIndexOf(object,int);
f)publicvirtualintLastIndexOf(object,int,int);
返回ArrayList或它的一部分中某个值的最后一个匹配项的从零开始的索引。
ArrayListaList=newArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("a");//同0
aList.Add("d");
aList.Add("e");
intnIndex=aList.LastIndexOf("a");//值为2而不是0
g)publicvirtualboolContains(objectitem);
确定某个元素是否在ArrayList中。包含返回true,否则返回false
七．其他
1．publicvirtualintCapacity{get;set;}
获取或设置ArrayList可包含的元素数。
2．publicvirtualintCount{get;}
获取ArrayList中实际包含的元素数。
Capacity是ArrayList可以存储的元素数。Count是ArrayList中实际包含的元素数。Capacity总是大于或等于Count。如果在添加元素时，Count超过Capacity，则该列表的容量会通过自动重新分配内部数组加倍。
如果Capacity的值显式设置，则内部数组也需要重新分配以容纳指定的容量。如果Capacity被显式设置为0，则公共语言运行库将其设置为默认容量。默认容量为16。
在调用Clear后，Count为0，而此时Capacity切是默认容量16，而不是0
3．publicvirtualvoidTrimToSize();
将容量设置为ArrayList中元素的实际数量。
如果不向列表中添加新元素，则此方法可用于最小化列表的内存系统开销。
若要完全清除列表中的所有元素，请在调用TrimToSize之前调用Clear方法。截去空ArrayList会将ArrayList的容量设置为默认容量，而不是零。
ArrayListaList=newArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");//Count=5,Capacity=16,
aList.TrimToSize();//Count=Capacity=5;

 

List的用法
List包括List接口以及List接口的所有实现类。因为List接口实现了Collection接口，所以List接口拥有Collection接口提供的所有常用方法，又因为List是列表类型，所以List接口还提供了一些适合于自身的常用方法，如表1所示。

表1 List接口定义的常用方法及功能
从表1可以看出，List接口提供的适合于自身的常用方法均与索引有关，这是因为List集合为列表类型，以线性方式存储对象，可以通过对象的索引操作对象。
List接口的常用实现类有ArrayList和LinkedList，在使用List集合时，通常情况下声明为List类型，实例化时根据实际情况的需要，实例化为ArrayList或LinkedList，例如：
List l = new ArrayList();// 利用ArrayList类实例化List集合
List l2 = new LinkedList();// 利用LinkedList类实例化List集合
1．add(int index, Object obj)方法和set(int index, Object obj)方法的区别
在使用List集合时需要注意区分add(int index, Object obj)方法和set(int index, Object obj)方法，前者是向指定索引位置添加对象，而后者是修改指定索引位置的对象，例如执行下面的代码：
src\com\mwq\TestCollection.java关键代码：
public static void main(String[] args) {
String a = "A", b = "B", c = "C", d = "D", e = "E";
List list = new LinkedList();
list.add(a);
list.add(e);
list.add(d);
list.set(1, b);// 将索引位置为1的对象e修改为对象b
list.add(2, c);// 将对象c添加到索引位置为2的位置
Iterator it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
在控制台将输出如下信息：
A
B
C
D
因为List集合可以通过索引位置访问对象，所以还可以通过for循环遍历List集合，例如遍历上面代码中的List集合的代码如下：
src\com\mwq\TestCollection.java关键代码：
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));// 利用get(int index)方法获得指定索引位置的对象
}
src\com\mwq\TestCollection.java完整代码如下：
package com.mwq;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Iterator;
import java.util.List;
public class TestCollection {
public static void main(String[] args) {
System.out.println("开始：");
String a = "A", b = "B", c = "C", d = "D", e = "E";
List list = new LinkedList();
list.add(a);
list.add(e);
list.add(d);
list.set(1, b);// 将索引位置为1的对象e修改为对象b
list.add(2, c);// 将对象c添加到索引位置为2的位置
Iterator it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
// for (int i = 0; i < list.size(); i++) {
// System.out.println(list.get(i));// 利用get(int index)方法获得指定索引位置的对象
// }
System.out.println("结束！");
}
}
2．indexOf(Object obj)方法和lastIndexOf(Object obj)方法的区别
在使用List集合时需要注意区分indexOf(Object obj)方法和lastIndexOf(Object obj)方法，前者是获得指定对象的最小的索引位置，而后者是获得指定对象的最大的索引位置，前提条件是指定的对象在List集合中具有重复的对象，否则如果在List集合中有且仅有一个指定的对象，则通过这两个方法获得的索引位置是相同的，例如执行下面的代码：
src\com\mwq\TestCollection.java关键代码：
public static void main(String[] args) {
String a = "A", b = "B", c = "C", d = "D", repeat = "Repeat";
List list = new ArrayList();
list.add(a); // 索引位置为 0
list.add(repeat); // 索引位置为 1
list.add(b); // 索引位置为 2
list.add(repeat); // 索引位置为 3

list.add(c); // 索引位置为 4
list.add(repeat); // 索引位置为 5
list.add(d); // 索引位置为 6
System.out.println(list.indexOf(repeat));
System.out.println(list.lastIndexOf(repeat));
System.out.println(list.indexOf(b));
System.out.println(list.lastIndexOf(b));
}
src\com\mwq\TestCollection.java完整代码如下：
package com.mwq;
import java.util.ArrayList;
import java.util.List;
public class TestCollection {
public static void main(String[] args) {
System.out.println("开始：");
String a = "A", b = "B", c = "C", d = "D", repeat = "Repeat";
List list = new ArrayList();
list.add(a); // 索引位置为 0
list.add(repeat); // 索引位置为 1
list.add(b); // 索引位置为 2
list.add(repeat); // 索引位置为 3
list.add(c); // 索引位置为 4
list.add(repeat); // 索引位置为 5
list.add(d); // 索引位置为 6
System.out.println(list.indexOf(repeat));
System.out.println(list.lastIndexOf(repeat));
System.out.println(list.indexOf(b));
System.out.println(list.lastIndexOf(b));
System.out.println("结束！");
}
}
在控制台将输出如下信息：
1
5
2
2
3．subList(int fromIndex, int toIndex)方法
在使用subList(int fromIndex, int toIndex)方法截取现有List集合中的部分对象生成新的List集合时，需要注意的是，新生成的集合中包含起始索引位置代表的对象，但是不包含终止索引位置代表的对象，例如执行下面的代码：
src\com\mwq\TestCollection.java关键代码：
public static void main(String[] args) {
String a = "A", b = "B", c = "C", d = "D", e = "E";
List list = new ArrayList();
list.add(a); // 索引位置为 0
list.add(b); // 索引位置为 1
list.add(c); // 索引位置为 2
list.add(d); // 索引位置为 3
list.add(e); // 索引位置为 4
list = list.subList(1, 3);// 利用从索引位置 1 到 3 的对象重新生成一个List集合
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
src\com\mwq\TestCollection.java完整代码：
package com.mwq;
import java.util.ArrayList;
import java.util.List;
public class TestCollection {
public static void main(String[] args) {
System.out.println("开始：");
String a = "A", b = "B", c = "C", d = "D", e = "E";
List list = new ArrayList();
list.add(a); // 索引位置为 0
list.add(b); // 索引位置为 1
list.add(c); // 索引位置为 2
list.add(d); // 索引位置为 3
list.add(e); // 索引位置为 4
list = list.subList(1, 3);// 利用从索引位置 1 到 3 的对象重新生成一个List集合
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("结束！");
}
}
在控制台将输出如下信息：
B
C

 

Java中Vector和ArrayList的区别

首先看这两类都实现List接口，而List接口一共有三个实现类，分别是ArrayList、Vector和LinkedList。List用于存放多个元素，能够维护元素的次序，并且允许元素的重复。3个具体实现类的相关区别如下：

1. ArrayList是最常用的List实现类，内部是通过数组实现的，它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔，当数组大小不满足时需要增加存储能力，就要讲已经有数组的数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时，需要对数组进行复制、移动、代价比较高。因此，它适合随机查找和遍历，不适合插入和删除。
2. Vector与ArrayList一样，也是通过数组实现的，不同的是它支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性，但实现同步需要很高的花费，因此，访问它比访问ArrayList慢。
3. LinkedList是用链表结构存储数据的，很适合数据的动态插入和删除，随机访问和遍历速度比较慢。另外，他还提供了List接口中没有定义的方法，专门用于操作表头和表尾元素，可以当作堆栈、队列和双向队列使用。

查看Java源代码，发现当数组的大小不够的时候，需要重新建立数组，然后将元素拷贝到新的数组内，ArrayList和Vector的扩展数组的大小不同。

ArrayList中：

1 public boolean add(E e) { 2 3 ensureCapacity(size + 1 ); // 增加元素，判断是否能够容纳。不能的话就要新建数组 4 5 elementData[size ++ ] = e; 6 7 return true ; 8 9 } 10 11 public void ensureCapacity( int minCapacity) { 12 13 modCount ++ ; 14 15 int oldCapacity = elementData.length; 16 17 if (minCapacity > oldCapacity) { 18 19 Object oldData[] = elementData; // 此行没看出来用处，不知道开发者出于什么考虑 20 21 int newCapacity = (oldCapacity * 3 ) / 2 + 1 ; // 增加新的数组的大小 22 23 if (newCapacity < minCapacity) 24 25 newCapacity = minCapacity; 26 27 // minCapacity is usually close to size, so this is a win: 28 29 elementData = Arrays.copyOf(elementData, newCapacity); 30 31 } 32 33 } 34 35

Vector中：

1 private void ensureCapacityHelper( int minCapacity) { 2 3 int oldCapacity = elementData.length; 4 5 if (minCapacity > oldCapacity) { 6 7 Object[] oldData = elementData; 8 9 int newCapacity = (capacityIncrement > 0 ) ? 10 11 (oldCapacity + capacityIncrement) : (oldCapacity * 2 ); 12 13 if (newCapacity < minCapacity) { 14 15 newCapacity = minCapacity; 16 17 } 18 19 elementData = Arrays.copyOf(elementData, newCapacity); 20 21 } 22 23 } 24 25

 

关于ArrayList和Vector区别如下：

1. ArrayList在内存不够时默认是扩展50% + 1个，Vector是默认扩展1倍。
2. Vector提供indexOf(obj, start)接口，ArrayList没有。
3. Vector属于线程安全级别的，但是大多数情况下不使用Vector，因为线程安全需要更大的系统开销。

 

本文主要介绍java中list，set和map 的区别 。

　　List按对象进入的顺序保存对象，不做排序或编辑操作。Set对每个对象只接受一次，并使用自己内部的排序方法(通常，你只关心某个元素是否属于Set,而不关心它的顺序--否则应该使用List)。Map同样对每个元素保存一份，但这是基于"键"的，Map也有内置的排序，因而不关心元素添加的顺序。如果添加元素的顺序对你很重要，应该使用 LinkedHashSet或者LinkedHashMap.

　　List的功能方法

　　实际上有两种List: 一种是基本的ArrayList,其优点在于随机访问元素，另一种是更强大的LinkedList,它并不是为快速随机访问设计的，而是具有一套更通用的方法。

　　List : 次序是List最重要的特点：它保证维护元素特定的顺序。List为Collection添加了许多方法，使得能够向List中间插入与移除元素(这只推荐LinkedList使用。)一个List可以生成ListIterator,使用它可以从两个方向遍历List,也可以从List中间插入和移除元素。

　　ArrayList : 由数组实现的List。允许对元素进行快速随机访问，但是向List中间插入与移除元素的速度很慢。ListIterator只应该用来由后向前遍历ArrayList,而不是用来插入和移除元素。因为那比LinkedList开销要大很多。

　　LinkedList : 对顺序访问进行了优化，向List中间插入与删除的开销并不大。随机访问则相对较慢。(使用ArrayList代替。)还具有下列方法：addFirst(), addLast(), getFirst(), getLast(), removeFirst() 和 removeLast(), 这些方法 (没有在任何接口或基类中定义过)使得LinkedList可以当作堆栈、队列和双向队列使用。

　　Set的功能方法

　　Set具有与Collection完全一样的接口，因此没有任何额外的功能，不像前面有两个不同的List。实际上Set就是Collection,只是行为不同。(这是继承与多态思想的典型应用：表现不同的行为。)Set不保存重复的元素(至于如何判断元素相同则较为负责)

　　Set : 存入Set的每个元素都必须是唯一的，因为Set不保存重复元素。加入Set的元素必须定义equals()方法以确保对象的唯一性。Set与Collection有完全一样的接口。Set接口不保证维护元素的次序。

　　HashSet : 为快速查找设计的Set。存入HashSet的对象必须定义hashCode()。

　　TreeSet : 保存次序的Set, 底层为树结构。使用它可以从Set中提取有序的序列。

　　LinkedHashSet : 具有HashSet的查询速度，且内部使用链表维护元素的顺序(插入的次序)。于是在使用迭代器遍历Set时，结果会按元素插入的次序显示。

　　Map的功能方法

　　方法put(Object key, Object value)添加一个“值”(想要得东西)和与“值”相关联的“键”(key)(使用它来查找)。方法get(Object key)返回与给定“键”相关联的“值”。可以用containsKey()和containsValue()测试Map中是否包含某个“键”或“值”。标准的Java类库中包含了几种不同的Map：HashMap, TreeMap, LinkedHashMap, WeakHashMap, IdentityHashMap。它们都有同样的基本接口Map，但是行为、效率、排序策略、保存对象的生命周期和判定“键”等价的策略等各不相同。

　　执行效率是Map的一个大问题。看看get()要做哪些事，就会明白为什么在ArrayList中搜索“键”是相当慢的。而这正是HashMap提高速度的地方。HashMap使用了特殊的值，称为“散列码”(hash code)，来取代对键的缓慢搜索。“散列码”是“相对唯一”用以代表对象的int值，它是通过将该对象的某些信息进行转换而生成的。所有Java对象都能产生散列码，因为hashCode()是定义在基类Object中的方法。

　　HashMap就是使用对象的hashCode()进行快速查询的。此方法能够显著提高性能。

　　Map : 维护“键值对”的关联性，使你可以通过“键”查找“值”

　　HashMap : Map基于散列表的实现。插入和查询“键值对”的开销是固定的。可以通过构造器设置容量capacity和负载因子load factor，以调整容器的性能。

　　LinkedHashMap : 类似于HashMap，但是迭代遍历它时，取得“键值对”的顺序是其插入次序，或者是最近最少使用(LRU)的次序。只比HashMap慢一点。而在迭代访问时发而更快，因为它使用链表维护内部次序。

　　TreeMap : 基于红黑树数据结构的实现。查看“键”或“键值对”时，它们会被排序(次序由Comparabel或Comparator决定)。TreeMap的特点在于，你得到的结果是经过排序的。TreeMap是唯一的带有subMap()方法的Map，它可以返回一个子树。

　　WeakHashMao : 弱键(weak key)Map，Map中使用的对象也被允许释放: 这是为解决特殊问题设计的。如果没有map之外的引用指向某个“键”，则此“键”可以被垃圾收集器回收。

　　IdentifyHashMap : 使用==代替equals()对“键”作比较的hash map。专为解决特殊问题而设计。