Map m1 = new HashMap();
m1.put("map", "HashMap");
m1.put("schildt", "java2");
m1.put("mathew", "Hyden");
m1.put("schildt", "java2s");
print(m1.keySet());
print(m1.values());
SortedMap sm = new TreeMap();
sm.put("map", "TreeMap");
sm.put("schildt", "java2");
sm.put("mathew", "Hyden");
sm.put("schildt", "java2s");
print(sm.keySet());
print(sm.values());
LinkedHashMap lm = new LinkedHashMap();
lm.put("map", "LinkedHashMap");
lm.put("schildt", "java2");
lm.put("mathew", "Hyden");
lm.put("schildt", "java2s");
print(lm.keySet());
print(lm.values());
╔══════════════╦═════════════════════╦═══════════════════╦═════════════════════╗
║ Property ║ HashMap ║ TreeMap ║ LinkedHashMap ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║ Iteration ║ no guarantee order ║ sorted according ║ ║
║ Order ║ will remain constant║ to the natural ║ insertion-order ║
║ ║ over time ║ ordering ║ ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║ Get/put ║ ║ ║ ║
║ remove ║ O(1) ║ O(log(n)) ║ O(1) ║
║ containsKey ║ ║ ║ ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║ ║ ║ NavigableMap ║ ║
║ Interfaces ║ Map ║ Map ║ Map ║
║ ║ ║ SortedMap ║ ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║ ║ ║ ║ ║
║ Null ║ allowed ║ only values ║ allowed ║
║ values/keys ║ ║ ║ ║
╠══════════════╬═════════════════════╩═══════════════════╩═════════════════════╣
║ ║ Fail-fast behavior of an iterator cannot be guaranteed ║
║ Fail-fast ║ impossible to make any hard guarantees in the presence of ║
║ behavior ║ unsynchronized concurrent modification ║
╠══════════════╬═════════════════════╦═══════════════════╦═════════════════════╣
║ ║ ║ ║ ║
║Implementation║ buckets ║ Red-Black Tree ║ double-linked ║
║ ║ ║ ║ buckets ║
╠══════════════╬═════════════════════╩═══════════════════╩═════════════════════╣
║ Is ║ ║
║ synchronized ║ implementation is not synchronized ║
╚══════════════╩═══════════════════════════════════════════════════════════════╝
所有这三个类都实现Map
接口,并提供大多数相同的功能。最重要的区别是通过条目进行迭代的顺序:
HashMap
绝对不保证迭代顺序。添加新元素时,它甚至可以(并将)完全改变。 TreeMap
将根据键的compareTo()
方法(或外部提供的Comparator
)根据键的 “自然顺序” 进行迭代。此外,它实现了SortedMap
接口,该接口包含依赖于此排序顺序的方法。 LinkedHashMap
将按照将条目放入地图的顺序进行迭代 “哈希表”是基于哈希的映射的通用名称。在 Java API 的上下文中, Hashtable
是 Java 1.1 在集合框架存在之前的过时类。不再使用它,因为它的 API 充满了重复功能的过时方法,并且其方法是同步的(这会降低性能,并且通常是无用的)。使用ConcurrentHashMap而不是 Hashtable。
这三个代表从唯一键到值的映射,因此实现了Map接口。
HashMap 是基于键哈希的映射。它支持 O(1)get / put 操作。密钥必须具有hashCode()
和equals()
一致实现,此hashCode()
才能起作用。
LinkedHashMap 与 HashMap 非常相似,但是它增加了添加(或访问)项目的顺序的意识,因此迭代顺序与插入顺序(或访问顺序,取决于构造参数)相同。
TreeMap 是基于树的映射。其放置 / 获取操作花费 O(log n)时间。它要求项目具有可比较或比较器的某种比较机制。迭代顺序由此机制确定。
在下图中查看每个类在类层次结构中的位置( 较大的一个 )。 TreeMap 实现SortedMap
和NavigableMap
而HashMap
不实现。
HashTable
已过时,应使用相应的ConcurrentHashMap
类。
从我自己使用地图的经验中获得的更多信息,以及何时使用每一个地图的信息:
removeEldestEntry()
方法,为创建 Cache 对象提供了一个很好的起点。这使您可以创建一个 Cache 对象,该对象可以使用您定义的某些条件使数据过期。 所有三个类HashMap
, TreeMap
和LinkedHashMap
实现java.util.Map
接口,并表示从唯一键到值的映射。
HashMap
包含基于键的值。
它仅包含唯一元素。
它可能具有一个 null 键和多个 null 值。
它不保持任何顺序 。
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable
LinkedHashMap
包含基于键的值。 与 HashMap 相同,只是保持插入顺序 。 // 请参见下面的类减速
public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>
TreeMap
包含基于键的值。它实现了 NavigableMap 接口并扩展了 AbstractMap 类。 与HashMap
相同,只是保持升序 (使用其键的自然顺序排序)。
public class TreeMap<K,V> extends AbstractMap<K,V> implements NavigableMap<K,V>, Cloneable, Serializable
这是一个遗留类。
public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, Serializable
参考: http : //javarevisited.blogspot.in/2015/08/difference-between-HashMap-vs-TreeMap-vs-LinkedHashMap-Java.html
HashMap 绝对不保证迭代顺序。添加新元素时,它甚至可以(并将)完全改变。 TreeMap 将根据键的 compareTo()方法(或外部提供的 Comparator)根据键的 “自然顺序” 进行迭代。此外,它实现了 SortedMap 接口,该接口包含依赖于此排序顺序的方法。 LinkedHashMap 将按照将条目放入地图的顺序进行迭代
看一下性能如何变化。
树图是已排序图的实现。由于自然排序,put,get 和 containsKey 操作的复杂度为 O(log n)
public class TreeMap<K,V>
extends AbstractMap<K,V>
implements SortedMap<K,V>, Cloneable, Serializable
以下是 HashMap 和 TreeMap 之间的主要区别
HashMap 不维护任何顺序。换句话说,HashMap 不能保证首先插入的元素将被首先打印,就像 TreeSet 一样,TreeMap 元素也根据其元素的自然顺序进行排序。
内部 HashMap 实现使用哈希,而 TreeMap 内部使用 Red-Black 树实现。
HashMap 可以存储一个 null 键和许多 null 值。TreeMap 不能包含 null 键,但可以包含许多 null 值。
HashMap 对诸如 get 和 put 即 O(1)之类的基本操作具有恒定的时间性能。根据 Oracle 文档,TreeMap 为 get 和 put 方法提供了保证的 log(n)时间成本。
HashMap 比 TreeMap 快得多,因为对于大多数操作,HashMap 的性能时间与 TreeMap 的日志时间是恒定的。
HashMap 在比较中使用 equals()方法,而 TreeMap 在使用 compareTo()方法维护排序。
HashMap 实现 Map 接口,而 TreeMap 实现 NavigableMap 接口。