Map用于保存具有映射关系的数据,因此Map集合里保存着两组值,一组值用于保存Map里的key,另一组值用于保存Map里的value,key和value都可以是任何引用类型的数据。Map的key不容许重复,即同一个Map对象的任何两个key通过equals方法比较总是返回false。
key和value之间存在单向一对一关系,即通过指定的key,总能找到唯一的、确定的value。从Map中取出数据时,只要给出指定的key,就可以取出对应的value。
如果把Map里的所有key放在一起看,它们就是一个Set集合,实际上Map确实包含一个keySet()方法,用于返回Map所有key组成的Set集合。如下:
public class Test {
public static void main(String[] args){
Map<String, String> mapVal = new HashMap<String, String>();
mapVal.put("spring", "春");
mapVal.put("summer", "夏");
mapVal.put("autumn", "秋");
mapVal.put("winter", "冬");
//获取mapVal集合的所有key值
Set<String> set = mapVal.keySet();
Iterator<String> it = set.iterator();
while(it.hasNext()){
String season = it.next();
System.out.println(season);
}
}
}
不仅如此,Map里key集合和Set集合里元素的存储形式也很像,Map子类和Set子类在名字上也惊人的相似:如Set接口下有HashSet、LinkedHashSet、SortedSet(接口)、TreeSet、EnumSet等实现类和子接口,而Map接口下则有HashMap、LinkedHashMap、SortedMap(接口)、TreeMap、EnumMap等实现类和子接口。正如它们名字所暗示的,Map的这些实现类和子接口中key集存储形式和对应Set集合中元素的存储形式完全相同。
如果把Map所有value放在一起看,它们又非常类似于一个List:元素与元素之间可以重复,每个元素可以根据索引来查找,只是map中的索引不再使用整数值,而是以另一个对象做为索引。如果需要从List集合中取元素,需要提供该元素的数字索引;如果需要从Map中取出元素,需要提供该元素的key索引。因此,Map有时也被称为字典,或关联数组。Map接口中定义了如下常用方法:
Map中包含一个内部类:Entry。该类封装了一个key-value对,Entry包含三个方法:
我们可以把Map理解成一个特殊的Set,只是该Set里包含的集合元素是Entry对象,而不是普通对象。
如下为Entry示例:
public class Test {
public static void main(String[] args){
Map<String, String> mapVal = new HashMap<String, String>();
mapVal.put("spring", "春");
mapVal.put("summer", "夏");
mapVal.put("autumn", "秋");
mapVal.put("winter", "冬");
Set<Entry<String, String>> entrySet = mapVal.entrySet();
Iterator<Entry<String, String>> iterator = entrySet.iterator();
while(iterator.hasNext()){
Entry<String, String> next = iterator.next();
String key = next.getKey();
String value = next.getValue();
System.out.println("key:"+ key +"-------value:" + value);
}
}
}
HashMap和Hashtable都是Map接口的典型实现类,他们之间的关系完全类似于ArrayList和Vector的关系:Hashtable是一个古老的Map实现类,它从JDK1.0起就已经出现了,当它出现时,Java没有提供Map接口,所以它包含了两个繁琐的方法:elements()(类似于Map接口定义的values()方法)和keys(类似于Map接口定义的keySet()方法),现在很少使用这两个方法。
HashMap和Hashtable的两点典型区别:
Hashtable是一个线程安全的Map实现,但HashMap是线程不安全的实现,所以HashMap比Hashtable性能要高一点;但如果有多条线程访问同一个Map对象时,使用Hashtable实现类会更好。
Hashtable不容许使用null作为key和value,如果试图把null放进Hashtable中,将会引发NullPointerException异常;但HashMap可以使用null做为key和value。
注意:与Vector类似,尽量少用Hashtable实现类,即使需要创建线程安全的Map实现类,也可以通过Collections工具类把HashMap变成线程安全的,无须使用Hashtable实现类。
为了成功地在HashMap、Hashtable中存储、获取对象,用作key的对象必须实现hashCode方法和equals方法。
与HashSet不能保证元素的顺序一样,HashMap和Hashtable也不能保证key-value对的顺序。类似于HashSet的是,HashMap、Hashtable判断两个key相等的标准也是:两个key通过equals方法比较返回true,两个key的hashCode值也相等。
除此之外,HashMap、Hashtable中还包含一个containsValue方法用于判断是否包含指定的value,那么HashMap、Hashtable如何判断两个value相等呢?HashMap、Hashtable判断两个value相等的标准更简单:只要两个对象通过equals比较返回true即可。
HashMap有一个子类:LinkedHashMap;LinkedHashMap也使用双向链表来维护key-value对的次序,该链表定义了迭代顺序,该迭代顺序与key-value对的插入顺序保持一致。LinkedHashMap可以避免需要对HashMap、Hashtable里的key-value对进行排序(只要插入key-value对时保持顺序即可)。同时又避免使用TreeMap所增加的成本。
LinkedHashMap需要维护元素的插入顺序,因此性能略低于HashMap的性能,但在迭代访问Map里的全部元素时将有很好的性能,因为它以链表来维护内部顺序。
public class Test {
public static void main(String[] args){
LinkedHashMap<String, String> mapVal = new LinkedHashMap<String, String>();
mapVal.put("spring", "春");
mapVal.put("summer", "夏");
mapVal.put("autumn", "秋");
mapVal.put("winter", "冬");
System.out.println(mapVal);
for(String str : mapVal.keySet()){
System.out.println("key:" + str);
System.out.println("value:" + mapVal.get(str));
}
}
}
Properties类是Hashtable类的子类,正如它的名字所暗示的,该文件在处理属性文件。Properties类可以把Map对象和属性文件关联起来,从而可以把Map对象中的key-value对写入属性文件,也可以把属性文件中的属性名=属性值加载到Map对象中。由于属性文件里的属性名、属性值只能是字符串类型,所以Properties里的key、value都是字符串类型,该类提供了如下三个方法来修改Properties里的key、value值。
如下代码所示:
public class Test {
public static void main(String[] args){
Properties readProperties = new Properties(); //用来写的Properties对象
readProperties.setProperty("username", "zhangsan");
readProperties.setProperty("password", "123456");
Properties writeProperties = new Properties(); //用来读的Properties对象
FileInputStream fileInputStream = null;
FileOutputStream fileOutputStream = null;
try {
//1.1通过类装载器获取要存储的路径
String path = Test.class.getResource("/").getPath();
path = path + "config.properties";
System.out.println(path);
fileOutputStream = new FileOutputStream(new File(path));
//1.2将配置文件信息写到硬盘上
readProperties.store(fileOutputStream, "This is config with database!");
//2.1读取硬盘上的配置文件
fileInputStream = new FileInputStream(new File(path));
writeProperties.load(fileInputStream);
String username = writeProperties.getProperty("username");
String username2 = writeProperties.getProperty("username2" , "没有找到username2的key");
//打印结果"sername:zhangsan"
System.out.println("username:" + username);
//打印结果"username2:没有找到username2的key"
System.out.println("username2:" + username2);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
if(fileOutputStream != null){
try {
fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
正如Set接口派生出了SortedSet子接口,SortedSet接口有一个TreeSet实现类,Map接口也派生了一个SortedMap子接口,SortedMap也有一个TreeMap实现类。
与TreeSet类似的是,TreeMap也是基于红黑树对TreeMap中所有key进行排序,从而保证TreeMap中所有key-value对处于有序状态。TreeMap也有两种排序方式:
自然排序:TreeMap的所有key必须实现那Comparable接口,而且所有key应该是同一个类的对象,否则将会抛出ClassCaseException。
定制排序:创建TreeMap时,传入一个Comparator对象,该对象负责对TreeMap中所有key进行排序。采用定制排序时不要求Map的key实现Comparable接口。
*可以参考TreeSet的代码演示。
修饰符和类型 | 方法和描述 |
---|---|
Map.Entry<K,V> | ceilingEntry(K key) 返回大于或等于给定键相关联的与最小键 - 值映射,或者null如果不存在这样的键。 |
K | ceilingKey(K key) 返回大于或等于给定键的最小键,或者null如果不存在这样的键。 |
void | clear() 从此映射中删除所有映射。 |
Object | clone() 返回此TreeMap实例的浅表副本。 |
Comparator<? super K> | comparator() 返回用于对此映射中的键进行排序的比较器,或者 null此映射使用其键的自然排序。 |
boolean | containsKey(Object key) true如果此映射包含指定键的映射,则返回。 |
boolean | containsValue(Object value) 返回true如果此映射将一个或多个键映射到指定值。 |
NavigableSet<K> | descendingKeySet() 返回NavigableSet此映射中包含的键的逆序视图。 |
NavigableMap<K,V> | descendingMap() 返回此映射中包含的映射的逆序视图。 |
Set<Map.Entry<K,V>> | entrySet() 返回Set此映射中包含的映射的视图。 |
Map.Entry<K,V> | firstEntry() 返回与此地图中最小键相关的键值映射,或者null地图为空。 |
K | firstKey() 返回此地图中当前第一个(最低)的键。 |
Map.Entry<K,V> | floorEntry(K key) 返回与最大键小于或等于给定键相关联的键 - 值映射,如果不存在这样的键,则返回null。 |
K | floorKey(K key) 返回小于或等于给定键的最大键,如果不存在这样的键返回null。 |
void | forEach(BiConsumer<? super K,? super V> action) 对此映射中的每个条目执行给定操作,直到处理完所有条目或操作抛出异常为止。 |
V | get(Object key) 返回指定键映射到的值,或者null此映射不包含键的映射。 |
SortedMap<K,V> | headMap(K toKey) 返回此映射的关键字严格小于的部分的视图toKey。 |
NavigableMap<K,V> | headMap(K toKey, boolean inclusive) 返回此映射关键字小于(或等于,如果inclusive为真)的部分的视图toKey。 |
Map.Entry<K,V> | higherEntry(K key) 返回与最小键相关的键 - 值映射严格大于给定键,或者null如果不存在这样的键。 |
K | higherKey(K key) 返回严格大于给定键的最小键,或者 null如果不存在这样的键。 |
Set<K> | keySet() 返回Set此映射中包含的键的视图。 |
Map.Entry<K,V> | lastEntry() 返回与此地图中最大键关联的键值映射,或者null映射为空。 |
K | lastKey() 返回此地图中当前最后一个(最高)的键。 |
Map.Entry<K,V> | lowerEntry(K key) 返回与最大键相关的键 - 值映射严格小于给定键,或者null如果没有这样的键。 |
K | lowerKey(K key) 返回最大的密钥严格小于给定的密钥,或者 null如果没有这样的密钥。 |
NavigableSet<K> | navigableKeySet() 返回NavigableSet此映射中包含的键的视图。 |
Map.Entry<K,V> | pollFirstEntry() 移除并返回与此地图中的最小键相关联的键值映射,或者null地图为空。 |
Map.Entry<K,V> | pollLastEntry() 移除并返回与此地图中最大键关联的键值映射,或者null地图为空。 |
V | put(K key, V value) 将指定的值与此映射中指定的键关联。 |
void | putAll(Map<? extends K,? extends V> map) 将指定地图中的所有映射复制到此地图。 |
V | remove(Object key) 如果存在,则从此TreeMap中移除此键的映射。 |
V | replace(K key, V value) 仅当指定键的条目映射到某个值时才替换该条目。 |
boolean | replace(K key, V oldValue, V newValue) 仅当当前映射到指定值时才替换指定键的条目。 |
void | replaceAll(BiFunction<? super K,? super V,? extends V> function) 用对该条目调用给定函数的结果替换每个条目的值,直到处理完所有条目或者该函数抛出异常。 |
int | size() 返回此映射中键值映射的数量。 |
NavigableMap<K,V> | subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) 返回此键映射范围从0 fromKey到的部分视图 toKey。 |
SortedMap<K,V> | subMap(K fromKey, K toKey) 返回此映射部分的视图,其键范围从 fromKey(包含)到toKey独占。 |
SortedMap<K,V> | tailMap(K fromKey) 返回此映射的键大于或等于的部分的视图fromKey。 |
NavigableMap<K,V> | tailMap(K fromKey, boolean inclusive) 返回此映射关键字大于(或等于,如果inclusive为真)的部分的视图fromKey。 |
Collection<V> | values() 返回Collection此映射中包含的值的视图。 |
WeakHashMap与HashMap的用法基本相似。但与HashMap的区别在于,HashMap的key保留对象的强引用,这意味着只要该HashMap对象不被销毁,该HashMap对象所有key所引用的对象不会被垃圾回收,HashMap也不会自动删除这些key所对应的key-value对象;但WeakHashMap的key只保留对实际对象的弱引用,这意味着当垃圾回收了该key所对应的实际对象后,WeakHashMap会自动删除该key对应的key-value对。
public class Test {
public static void main(String[] args){
WeakHashMap<String, String> map = new WeakHashMap<String, String>();
//将WeakHashMap中添加三个key-value对,
//三个key都是匿名字符串对象(没有其他引用)
map.put(new String("语文"), new String("优"));
map.put(new String("数学"), new String("良"));
map.put(new String("英语"), new String("中"));
//将WeakHashMap中添加一个key-value对,
//该key是一个系统缓存的字符串对象。
map.put("java", new String("不及格"));
//输出map对象,将看到4个key-value对{java=不及格, 数学=良, 英语=中, 语文=优}
System.out.println(map);
//通知系统立即进行垃圾回收
System.gc();
System.runFinalization();
//通常情况下,将只看到一个key-value对{java=不及格}
System.out.println(map);
}
}
从上面运行结果可以看出,当系统进行垃圾回收时,删除了WeakHashMap对象的前三个key-value对。这是因为添加前三个key-value对时,这三个key都是匿名字符串对象,只有WeakHashMap保留了对它们的弱引用。WeakHashMap对象中的第四组key-value对的key是一个字符串的直接量,系统会缓冲这个字符串直接量(即系统保留了对该字符串对象的强引用),所以垃圾回收时不会回收它。
IdentityHashMap实现类的实现机制与HashMap基本相似,但它在处理两个key相等时,比较独特:在IdentityHashMap中,当且仅当两个key严格相等时(key1 = key2)时,IdentityHashMap才认为两个key相等,对于普通HashMap而言,只要key1和key2通过equals比较返回true,且它们的hashCode值相等即可。
IdentityHashMap提供了与HashMap基本相似的方法,也允许使用null做为key和value。与HashMap类似的是,IdentityHashMap不保证任何key-value对之间的顺序,更不能保证它们的顺序随时间的推移保持不变。
public class Test {
public static void main(String[] args){
IdentityHashMap<String, String> map = new IdentityHashMap<String, String>();
//下面两行代码会向map中添加两条key-value对
map.put(new String("语文"), "99");
map.put(new String("语文"), "100");
//下面两行代码会向map中添加一条key-value对
map.put("java", "89");
map.put("java", "69");
//打印结果为{java=69, 语文=100, 语文=99}
System.out.println(map);
}
}
EnumMap是一个与枚举类一起使用的Map实现,EnumMap中所有key都必须是单个枚举类的枚举值。创建EnumMap时必须显示或隐式指定它对应的枚举类。
EnumMap不允许使用null作为key值,但容许使用null值做为value。如果试图使用null做为key将抛出NullPointerException异常。如果仅仅只是查询是否包含值为null的key,或者仅仅只是使用删除值为null的key,都不会抛出异常。
enum Season{
SPRING,SUMMER,AUTUMN,WINTER
}
public class Test {
public static void main(String[] args){
EnumMap<Season, String> map = new EnumMap<Season, String>(Season.class);
//打印结果为{}
System.out.println(map);
map.put(Season.SPRING, "春");
map.put(Season.SUMMER, "夏");
map.put(Season.AUTUMN, "秋");
map.put(Season.WINTER, "冬");
//打印结果为{SPRING=春, SUMMER=夏, AUTUMN=秋, WINTER=冬}
System.out.println(map);
}
}
上面程序中创建了一个EnumMap对象,创建该EnumMap对象时指定它的key只能是Season枚举类的枚举值。如果向该EnumMap中添加四个key-value对后,这四个key-value对将会以Season枚举值的自然顺序排序。
对于Map的常用实现类而言,HashMap和Hashtable的效率大致相同,因为它们的实现机制几乎完全一样,但HashMap通常比Hashtable要快一点,因为Hashtable额外实现同步操作。
TreeMap通常比HashMap、Hashtable要慢(尤其在插入、删除key-value对的时候更慢),因为TreeMap需要额外的红黑树操作来维护key之间的次序。但使用TreeMap有一个好处:TreeMap中的key-value对总是处于有序状态,无须专门进行排序操作。