HashMap, LinkedHashMap ve TreeMap arasındaki fark

Arasındaki fark nedir HashMap, LinkedHashMapve TreeMapJava? Üçünde de olduğu gibi çıktıda herhangi bir fark görmüyorum keySetve values. S nedir Hashtable?

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

Her üç sınıf da Maparabirimi uygular ve çoğunlukla aynı işlevselliği sunar. En önemli fark, girişler aracılığıyla yinelemenin gerçekleşme sırasıdır:

• HashMapyineleme sırası hakkında kesinlikle hiçbir garanti vermez. Yeni elemanlar eklendiğinde tamamen değişebilir (ve değişecektir).
• TreeMapcompareTo()yöntemlerine (veya harici olarak tedarik edilen Comparator) göre anahtarların "doğal sıralamasına" göre yinelenecektir . Ayrıca, SortedMapbu sıralama düzenine bağlı yöntemler içeren arabirimi uygular .
• LinkedHashMap girişlerin haritaya yerleştirildiği sırayla yinelenecek

"Hashtable" , karma tabanlı haritaların genel adıdır. Java API bağlamında Hashtable, koleksiyon çerçevesi var olmadan önce Java 1.1 günlerinden kalma eski bir sınıftır. Artık kullanılmamalıdır, çünkü API'si işlevselliği çoğaltan eski yöntemlerle dağınıktır ve yöntemleri senkronize edilir (bu, performansı düşürebilir ve genellikle işe yaramaz). Kullanım ConcurrentHashMap yerine Hashtable.

Görsel sunumu tercih ederim:

╔══════════════╦═════════════════════╦═══════════════════╦═════════════════════╗
║   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               ║
╚══════════════╩═══════════════════════════════════════════════════════════════╝

Her üçü de benzersiz anahtarlardan değerlere eşlemeyi temsil eder ve bu nedenle Harita arabirimini uygular .

1. HashMap anahtarların özetine dayalı bir haritadır . O (1) get / put işlemlerini destekler. Tuşlar olmalıdır tutarlı uygulamaları hashCode()veequals() bunun için çalışmak.

2. LinkedHashMap, HashMap'e çok benzer, ancak öğelerin eklendiği (veya erişildiği) sıraya farkındalık eklediğinden, yineleme sırası ekleme siparişiyle (veya inşaat parametrelerine bağlı olarak erişim sırası) aynıdır.

3. TreeMap ağaç tabanlı bir eşlemedir. Put / get işlemleri O (log n) zamanını alır. Öğelerin Karşılaştırılabilir veya Karşılaştırıcı ile bazı karşılaştırma mekanizmalarına sahip olması gerekir. Yineleme sırası bu mekanizma tarafından belirlenir.

Aşağıdaki diyagramda her sınıfın sınıf hiyerarşisinde nerede olduğunu görün ( daha büyük olanı ). TreeMap uygular SortedMapve NavigableMapsüre HashMapyok.

HashTablekullanılmıyor ve ilgili ConcurrentHashMapsınıf kullanılmalıdır.

HashMap

• Çift değerlere sahiptir (anahtarlar, değerler)
• Çoğaltma anahtarı değeri YOK
• sıralanmamış sıralanmamış
• bir null anahtarına ve birden fazla null değerine izin verir

HashTable

• karma harita ile aynı
• null anahtarlara ve null değerlere izin vermez

LinkedHashMap

• Harita uygulamasının sıralı versiyonu
• Bağlantılı liste ve karma veri yapılarına dayalı

TreeMap

• Sıralı ve sıralı versiyon
• karma veri yapılarına dayalı

Her birini ne zaman kullanacağım konusunda haritalarla ilgili kendi deneyimimden biraz daha fazla girdi:

• HashMap - En iyi performans (hızlı) uygulaması ararken en kullanışlıdır.
• TreeMap (SortedMap arayüzü) - Anahtarları tanımladığım belirli bir sıraya göre sıralayabilme veya yineleyebilme konusunda endişeliyim.
• LinkedHashMap - TreeMap'in bakım maliyeti artmadan TreeMap'ten garantili sipariş vermenin avantajlarını birleştirir. (Neredeyse HashMap kadar hızlıdır). Özellikle LinkedHashMap, removeEldestEntry()yöntemi geçersiz kılarak bir Cache nesnesi oluşturmak için harika bir başlangıç ​​noktası sağlar . Bu, tanımladığınız bazı ölçütleri kullanarak verilerin süresi dolan bir Önbellek nesnesi oluşturmanıza olanak tanır.

Her üç sınıfları HashMap, TreeMapve LinkedHashMapuygular java.util.Maparayüz ve değerlere eşsiz anahtarından eşlemesi temsil eder.

HashMap

1. A HashMap, anahtara dayalı değerler içerir.

2. Yalnızca benzersiz öğeler içerir.

3. Bir null anahtarı ve birden fazla null değeri olabilir.

4. Bu tutar hiçbir düzen .

   public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable

LinkedHashMap

1. A LinkedHashMap, anahtara dayalı değerler içerir.
2. Yalnızca benzersiz öğeler içerir.
3. Bir null anahtarı ve birden fazla null değeri olabilir.

4. HashMap ile aynıdır, bunun yerine ekleme talimatını korur . // Aşağıdaki sınıf yavaşlamasına bakın

   public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>

TreeMap

1. A TreeMap, anahtara dayalı değerler içerir. NavigableMap arabirimini uygular ve AbstractMap sınıfını genişletir.
2. Yalnızca benzersiz öğeler içerir.
3. Null anahtarı olamaz, ancak birden fazla null değeri olabilir.

4. Bunun HashMapyerine artan düzeni korur (Anahtarının doğal sırasını kullanarak sıralanır.).

   public class TreeMap<K,V> extends AbstractMap<K,V> implements NavigableMap<K,V>, Cloneable, Serializable

hashtable'a

1. Hashtable bir liste dizisidir. Her liste bir grup olarak bilinir. Kepçenin konumu, hashcode () yöntemi çağrılarak belirlenir. Bir Hashtable, anahtara dayalı değerler içerir.
2. Yalnızca benzersiz öğeler içerir.
3. Herhangi bir boş anahtarı veya değeri olmayabilir.
4. O edilir senkronize .

5. Bu eski bir sınıf.

   public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, Serializable

Ref: http://javarevisited.blogspot.in/2015/08/difference-between-HashMap-vs-TreeMap-vs-LinkedHashMap-Java.html

HashMap, yineleme sırası hakkında kesinlikle garanti vermez. Yeni elemanlar eklendiğinde tamamen değişebilir (ve değişecektir). TreeMap, CompareTo () yöntemine (veya harici olarak sağlanan Karşılaştırıcıya) göre anahtarların "doğal sıralamasına" göre yinelenir. Ayrıca, bu sıralama düzenine bağlı yöntemler içeren SortedMap arabirimini uygular. LinkedHashMap, girişlerin haritaya yerleştirildiği sırayla yinelenir

Performansın nasıl değiştiğine bakın ..

Sıralı haritanın bir uygulaması olan ağaç haritası. Put, get ve içerir karmaşık anahtar işlemi doğal sipariş nedeniyle O (log n) 'dir

@Amit: SortedMapbir arabirim TreeMap, SortedMaparabirimi uygulayan bir sınıftır . Bu SortedMap, uygulayıcılarından yapmasını isteyen protokolü takip ederse anlamına gelir . Bir ağaç, arama ağacı olarak uygulanmadığı sürece, size sipariş verisi veremez, çünkü ağaç her türlü ağaç olabilir. Bu nedenle TreeMap'in Sıralı düzen gibi çalışmasını sağlamak için SortedMap'i uygular (örneğin, İkili Arama Ağacı - BST, AVL ve RB Ağacı gibi dengeli BST, hatta Üçlü Arama Ağacı - çoğunlukla sıralı şekilde yinelemeli aramalar için kullanılır).

public class TreeMap<K,V>
extends AbstractMap<K,V>
implements SortedMap<K,V>, Cloneable, Serializable

NUT-SHELL HashMap: O (1) 'de veri verir, sipariş vermez

TreeMap : sıralı tuşlarla O (log N), taban 2'de veri verir.

LinkedHashMap: Verileri ağaca eklenme biçiminde saklayabilmeleri için bağlantılı listeli (dizinli-SkipList'i düşünün) karma tablodur. LRU (en son kullanılan) uygulamak için en uygunudur.

HashMap ve TreeMap arasındaki büyük fark aşağıdadır

1. HashMap herhangi bir sipariş tutmaz. Başka bir deyişle, HashMap ilk önce eklenen öğenin yazdırılacağı konusunda herhangi bir garanti vermez; burada TreeSet gibi TreeMap öğeleri de öğelerinin doğal sırasına göre sıralanır

2. Dahili HashMap uygulaması Hashing ve TreeMap'i dahili olarak Kırmızı-Siyah ağaç uygulamasını kullanır.

3. HashMap bir null anahtar ve birçok null değer saklayabilir. TreeMap null anahtar içeremez, ancak birçok null değer içerebilir.

4. HashMap get ve put yani O (1) gibi temel işlemler için sabit zamanlı performans alır. Oracle belgelerine göre TreeMap, get ve put yöntemi için garantili log (n) zaman maliyeti sağlar.

5. HashMap, çoğu işlem için TreeMap günlük zamanına karşı sabit olduğundan, HashMap TreeMap'ten çok daha hızlıdır.

6. HashMap karşılaştırmada equals () yöntemini kullanırken TreeMap sıralamayı korumak için CompareTo () yöntemini kullanır.

7. TreeMap NavigableMap arayüzünü uygularken HashMap Harita arayüzünü uygular.

Bunlar aynı arayüzün farklı uygulamalarıdır. Her uygulamanın bazı avantajları ve bazı dezavantajları vardır (hızlı ekleme, yavaş arama) veya tersi.

Ayrıntılar için TreeMap , HashMap , LinkedHashMap javadosuna bakın .

Karma haritası ekleme sırasını korumaz.
Misal. Hashmap Anahtarları şu şekilde ekliyorsanız

1  3
5  9
4   6
7   15
3   10

Olarak saklayabilir

4  6
5  9
3  10
1  3
7  15

Bağlı Hashmap ekleme sırasını korur.

Misal.
Anahtar takıyorsanız

1  3
5  9
4   6
7   15
3   10

Olarak depolayacak

1  3
5  9
4   6
7   15
3   10

eklediğimizle aynı.

Ağaç haritası, değerleri Anahtarların Artan Sırasında saklar. Misal.
Anahtar takıyorsanız

1  3
5  9
4   6
7   15
3   10

Olarak depolayacak

1  3
3  10
4   6
5   9
7   15

• hashmap:

  • Sipariş korunmuyor
  • LinkedHashMap'ten daha hızlı
  • Nesneleri depolamak için kullanılır

• LinkedHashMap:

  • LinkedHashMap ekleme sırası korunacak
  • HashMap'ten daha yavaş ve TreeMap'ten daha hızlı
  • Kampanya siparişini korumak istiyorsanız bunu kullanın.

• TreeMap:

  • TreeMap ağaç tabanlı bir eşleme
  • TreeMap anahtarın doğal sırasını izleyecek
  • HashMap ve LinkedHashMap'ten daha yavaş
  • Doğal (varsayılan) siparişi sürdürmeniz gerektiğinde TreeMap kullanın

Hepsi bir anahtar-> değer haritası ve anahtarlar arasında yineleme yapmak için bir yol sunar. Bu sınıflar arasındaki en önemli ayrım, zaman garantileri ve anahtarların sıralanmasıdır.

1. HashMap 0 (1) arama ve ekleme sunar. Anahtarlar arasında yineleme yaparsanız, anahtarların sıralaması aslında keyfidir. Bir dizi bağlantılı liste tarafından uygulanır.
2. TreeMap, O (log N) araması ve yerleştirme sunar. Anahtarlar sıralanmıştır, bu nedenle anahtarları sıralı bir şekilde yinelemeniz gerekiyorsa yapabilirsiniz. Bu, anahtarların Karşılaştırılabilir arabirimi uygulaması gerektiği anlamına gelir.TreeMap bir Kırmızı-Siyah Ağaç tarafından uygulanır.
3. LinkedHashMap 0 (1) arama ve ekleme sunar. Anahtarlar ekleme sıralarına göre sıralanır. Çift bağlantılı kovalarla uygulanır.

Aşağıdaki işleve boş bir TreeMap, HashMap ve LinkedHashMap ilettiğinizi düşünün:

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 + ", ");
  }
}

Her biri için çıktı aşağıdaki sonuçlara benzeyecektir.

HashMap için çıktı, kendi testlerimde {0, 1, -1} idi, ancak herhangi bir sipariş olabilir. Sipariş için garanti yoktur.
Treemap, çıktı {-1, 0, 1}
LinkedList, çıktı {1, -1, 0}

Burada çok sayıda mükemmel Yanıt olsa da, MapJava 11 ile birlikte gelen çeşitli uygulamaları açıklayan kendi masamı sunmak istiyorum .

Bu farklılıkları tablo grafiğinde görebilirsiniz:

• HashMapolan genel amaçlı Map hiçbir özel ihtiyaçları olduğunda yaygın olarak kullanılan.
• LinkedHashMapHashMapbu davranışı ekleyerek genişletir : Bir siparişi, girdilerin başlangıçta eklendiği sırayı korur . Anahtar / değer girişi için değerin değiştirilmesi, sırayla yerini değiştirmez.
• TreeMapçok fazla bir düzen sağlar, ancak (a) “doğal” düzen kullanır , yani compareToyöntemin Comparablearabirimde tanımlanan anahtar nesneler üzerindeki değeri veya (b) bir uygulamayı çağırırComparator sağladığınız .
  • TreeMaphem SortedMaparayüzü hem de halefini arayüzü uygular NavigableMap.
• BOŞ s: TreeMapyok değil anahtar olarak NULL izin ederken, HashMap&LinkedHashMap yapmak.
  • Üçü de NULL değerine izin verir.
• HashTableolduğu eski Java 1'den, . Sınıf tarafından desteklendi ConcurrentHashMap. Javadoc'tan alıntı:: ConcurrentHashMapile aynı fonksiyonel spesifikasyona uyar ve Hashtableher bir metoduna karşılık gelen metotların versiyonlarını içerir Hashtable.

HashMap
bir null anahtar içerebilir.

HashMap herhangi bir sipariş vermez.

TreeMap

TreeMap hiçbir boş anahtar içeremez.

TreeMap artan düzeni korur.

LinkedHashMap

LinkedHashMap, Harita üzerinde anahtarların eklendiği ekleme sırasını korumak için kullanılabilir veya aynı zamanda, tuşlara erişildiği bir erişim sırasını korumak için de kullanılabilir.

Örnekler ::

1) HashMap haritası = yeni 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 haritası = yeni 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 haritası = yeni 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());
    }

Bu üçü arasında en önemlisi, girişlerin sırasını nasıl kaydettikleri.

HashMap- Girişlerin sırasını kaydetmez. Örneğin.

public static void main(String[] args){
        HashMap<String,Integer> hashMap = new HashMap<>();
        hashMap.put("First",1);// First ---> 1 is put first in the map
        hashMap.put("Second",2);//Second ---> 2 is put second in the map
        hashMap.put("Third",3); // Third--->3 is put third in the map
        for(Map.Entry<String,Integer> entry : hashMap.entrySet())
        {
            System.out.println(entry.getKey()+"--->"+entry.getValue());
        }
    }

LinkedHashMap: Girişlerin yapılma sırasını kaydeder. Örneğin:

public static void main(String[] args){
        LinkedHashMap<String,Integer> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put("First",1);// First ---> 1 is put first in the map
        linkedHashMap.put("Second",2);//Second ---> 2 is put second in the map
        linkedHashMap.put("Third",3); // Third--->3 is put third in the map
        for(Map.Entry<String,Integer> entry : linkedHashMap.entrySet())
        {
            System.out.println(entry.getKey()+"--->"+entry.getValue());
        }
    }

TreeMap: Girişleri tuşların artan sırasına göre kaydeder. Örneğin:

public static void main(String[] args) throws IOException {
        TreeMap<String,Integer> treeMap = new TreeMap<>();
        treeMap.put("A",1);// A---> 1 is put first in the map
        treeMap.put("C",2);//C---> 2 is put second in the map
        treeMap.put("B",3); //B--->3 is put third in the map
        for(Map.Entry<String,Integer> entry : treeMap.entrySet())
        {
            System.out.println(entry.getKey()+"--->"+entry.getValue());
        }
    }