HashMap, LinkedHashMap和TreeMap在Java中的区别是什么? 我在输出中没有看到任何不同,因为这三个都有keySet和values。什么是哈希表?

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());

当前回答

HashMap: 不维持秩序 比LinkedHashMap快 用于存储对象堆 LinkedHashMap: LinkedHashMap插入顺序将被维持 比HashMap慢,比TreeMap快 如果你想保持一个插入顺序,使用这个。 TreeMap: TreeMap是一种基于树的映射 TreeMap将遵循键的自然顺序 比HashMap和LinkedHashMap慢 在需要维护自然(默认)排序时使用TreeMap

其他回答

我更喜欢视觉呈现:

Property HashMap TreeMap LinkedHashMap
Iteration Order no guaranteed order, will remain constant over time sorted according to the natural ordering insertion-order
Get / put / remove / containsKey O(1) O(log(n)) O(1)
Interfaces Map NavigableMap, Map, SortedMap Map
Null values/keys allowed only values allowed
Fail-fast behavior Fail-fast behavior of an iterator cannot be guaranteed, impossible to make any hard guarantees in the presence of unsynchronized concurrent modification Fail-fast behavior of an iterator cannot be guaranteed, impossible to make any hard guarantees in the presence of unsynchronized concurrent modification Fail-fast behavior of an iterator cannot be guaranteed, impossible to make any hard guarantees in the presence of unsynchronized concurrent modification
Implementation buckets Red-Black Tree double-linked buckets
Is synchronized implementation is not synchronized implementation is not synchronized implementation is not synchronized

这三个类都实现了Map接口,并提供了基本相同的功能。最重要的区别是迭代条目的顺序:

HashMap绝对不保证迭代顺序。当添加新元素时,它甚至可以(也将会)完全改变。 TreeMap将根据键的compareTo()方法(或外部提供的Comparator)的“自然顺序”进行迭代。此外,它实现了SortedMap接口,该接口包含依赖于此排序顺序的方法。 LinkedHashMap将按照条目放入映射的顺序进行迭代

“哈希表”是基于哈希的映射的通用名称。在Java API的上下文中, Hashtable是Java 1.1时代的一个过时的类,在集合框架存在之前。它不应该再使用了,因为它的API中充满了重复功能的过时方法,而且它的方法是同步的(这会降低性能,而且通常是无用的)。使用ConcurrentHashMap而不是Hashtable。

HashMap 可以包含一个空键。

HashMap没有秩序。

TreeMap

TreeMap不能包含任何空键。

TreeMap保持升序。

LinkedHashMap

LinkedHashMap可用于维护插入顺序,即键被插入到Map中,也可用于维护访问顺序,即键被访问。

例子::

1) HashMap map = new HashMap();

    map.put(null, "Kamran");
    map.put(2, "Ali");
    map.put(5, "From");
    map.put(4, "Dir");`enter code here`
    map.put(3, "Lower");
    for (Map.Entry m : map.entrySet()) {
        System.out.println(m.getKey() + "  " + m.getValue());
    } 

2) TreeMap map = new TreeMap();

    map.put(1, "Kamran");
    map.put(2, "Ali");
    map.put(5, "From");
    map.put(4, "Dir");
    map.put(3, "Lower");
    for (Map.Entry m : map.entrySet()) {
        System.out.println(m.getKey() + "  " + m.getValue());
    }

3) LinkedHashMap map = new LinkedHashMap();

    map.put(1, "Kamran");
    map.put(2, "Ali");
    map.put(5, "From");
    map.put(4, "Dir");
    map.put(3, "Lower");
    for (Map.Entry m : map.entrySet()) {
        System.out.println(m.getKey() + "  " + m.getValue());
    }

它们都提供一个key->值映射和一种遍历键的方法。最重要的区别 这些类是时间保证和键的顺序。

HashMap offers 0(1) lookup and insertion. If you iterate through the keys, though, the ordering of the keys is essentially arbitrary. It is implemented by an array of linked lists. TreeMap offers O(log N) lookup and insertion. Keys are ordered, so if you need to iterate through the keys in sorted order, you can. This means that keys must implement the Comparable interface.TreeMap is implemented by a Red-Black Tree. LinkedHashMap offers 0(1) lookup and insertion. Keys are ordered by their insertion order. It is implemented by doubly-linked buckets.

假设你将一个空的TreeMap, HashMap和LinkedHashMap传递给下面的函数:

void insertAndPrint(AbstractMap<Integer, String> map) {
  int[] array= {1, -1, 0};
  for (int x : array) {
    map.put(x, Integer.toString(x));
  }
  for (int k: map.keySet()) {
   System.out.print(k + ", ");
  }
}

它们的输出如下所示。

对于HashMap,在我自己的测试中,输出是{0,1,-1},但它可以是任何顺序。没有任何保证 排序。 Treemap,输出为{- 1,0,1} LinkedList,输出为{1,-1,0}

HashMap: 不维持秩序 比LinkedHashMap快 用于存储对象堆 LinkedHashMap: LinkedHashMap插入顺序将被维持 比HashMap慢,比TreeMap快 如果你想保持一个插入顺序,使用这个。 TreeMap: TreeMap是一种基于树的映射 TreeMap将遵循键的自然顺序 比HashMap和LinkedHashMap慢 在需要维护自然(默认)排序时使用TreeMap