Différence entre HashMap, LinkedHashMap et TreeMap


958

Quelle est la différence entre HashMap, LinkedHashMapet TreeMapen Java? Je ne vois aucune différence dans la sortie comme tous les trois a keySetet values. Quels sont Hashtables?

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

Réponses:


1161

Les trois classes implémentent l' Mapinterface et offrent principalement les mêmes fonctionnalités. La différence la plus importante est l'ordre dans lequel l'itération des entrées se produira:

  • HashMapne fait absolument aucune garantie sur l'ordre d'itération. Il peut (et changera) même complètement lorsque de nouveaux éléments sont ajoutés.
  • TreeMapitérera selon "l'ordre naturel" des clés selon leur compareTo()méthode (ou une source externe Comparator). De plus, il implémente l' SortedMapinterface, qui contient des méthodes qui dépendent de cet ordre de tri.
  • LinkedHashMap va itérer dans l'ordre dans lequel les entrées ont été placées dans la carte

"Hashtable" est le nom générique des cartes basées sur le hachage. Dans le contexte de l'API Java, Hashtableest une classe obsolète datant de l'époque de Java 1.1 avant que le cadre des collections n'existe. Il ne devrait plus être utilisé, car son API est encombrée de méthodes obsolètes qui dupliquent les fonctionnalités et ses méthodes sont synchronisées (ce qui peut diminuer les performances et est généralement inutile). Utilisez ConcurrentHashMap au lieu de Hashtable.


2
Qu'est-ce que Map en réalité et quelle est la différence entre Map, HashMap et Hashtables?
Kevin

5
@theband: Map est une interface. HashMap et Hashtable l'implémentent tous les deux; comme je l'ai écrit, Hashtable est une classe héritée.
Michael Borgwardt

98
Une différence notable entre Hashtableet HashMapest que dans une table de hachage, "ni la clé ni la valeur ne peuvent être nulles". Cette contrainte n'existe pas sur ce dernier.
aioobe

4
@AshkanN: Oui - en fait, ce sont les moyens standard d'implémenter le tri. TreeMap a un constructeur qui utilise un comparateur à utiliser, et si aucun n'est fourni, il attend que tous les objets ajoutés implémentent Comparable.
Michael Borgwardt

4
Vous pouvez choisir si vous souhaitez l'itération LinkedHashMap dans l'ordre d'insertion ou l'ordre d'accès.
lbalazscs

1608

Je préfère la présentation visuelle:

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

14
En plus de l'ordre d'insertion, LinkedHashMap prend également en charge l'ordre d'accès (lors de l'utilisation du constructeur avec le paramètre d'ordre d'accès booléen).
Eyal Schneider

5
Seaux à double liaison? Je pense que cela ajoute des frais généraux inutiles à la recherche du compartiment pour les opérations d'insertion / suppression (car il doit rechercher le bon compartiment pour placer l'objet). J'ai toujours pensé que les implémentations de LinkedHashMap seraient similaires à celles d'une carte mais avec un petit surcoût supplémentaire de "liste d'entrées" (peut être comme une liste liée) qui est utilisée à des fins d'itération. Êtes-vous sûr, shevchyk? Si oui, pouvez-vous m'expliquer ou me donner des liens en ligne qui soutiennent votre déclaration?
Sai Dubbaka

5
@SaiDubbaka LinkedHashMap a les doubles compartiments liés MAIS AUSSI la table de seaux HashMap a. Il ne le remplace pas. Cela signifie que l'accès aux compartiments se fait de la même manière que dans HashMap, car la liste liée est là pour l'itération dans l'ordre d'insertion (ou l'ordre d'accès) uniquement.
Gerardo Lastra

5
Il peut être utile de mentionner que O (1) est le meilleur scénario (que nous n'appellerions pas habituellement O, voir cette question )
Sebastian S

4
Il convient également de noter que O (1) n'est pas toujours meilleur que O (log n); si vous avez une clé très longue, quelque chose basé sur les BST peut être beaucoup plus rapide que quelque chose qui doit effectuer un hachage O (n) sur la clé entière avant de pouvoir faire quoi que ce soit.
Fund Monica's Lawsuit

65

Les trois représentent le mappage des clés uniques aux valeurs et implémentent donc l' interface Map .

  1. HashMap est une carte basée sur le hachage des clés. Il prend en charge les opérations get / put O (1). Les clés doivent avoir des implémentations cohérentes de hashCode()etequals() pour que cela fonctionne.

  2. LinkedHashMap est très similaire à HashMap, mais il ajoute la conscience à l'ordre auquel les éléments sont ajoutés (ou accédés), donc l'ordre d'itération est le même que l'ordre d'insertion (ou l'ordre d'accès, selon les paramètres de construction).

  3. TreeMap est une cartographie basée sur un arbre. Ses opérations put / get prennent du temps O (log n). Il nécessite que les éléments disposent d'un mécanisme de comparaison, avec Comparable ou Comparator. L'ordre d'itération est déterminé par ce mécanisme.


1
Donc, si je comprends bien, la seule différence entre LinkedHashMap et TreeMap est la performance, étant donné que l'ordre d'insertion est le même que l'ordre naturel?
Moshe Shaham

19
@MosheShaham Comme il l'a dit dans # 2: LinkedHashMapva itérer dans l'ordre d'insertion, pas dans l'ordre naturel. Donc, si vous ajoutez (2,5,3)à un LinkedHashMapet faites un pour chacun par-dessus, il reviendra 2,5,3. Si elle était 2,5,3à TreeMapelle revenir 2,3,5.
grinch

2
La carte d'arbre a également beaucoup d'autres astuces intéressantes. Comme les cartes tête et queue.
Thomas Ahle

TreeMap <String, Integer> mySection2 = new TreeMap <> (); mySection2.put ("abc1", 2); mySection2.put ("abc2", 5); mySection2.put ("abc3", 3); for (Integer x: mySection2.values ​​()) {Log.e ("LOG", "TreeMap ====" + x); } Cela me donne le même ordre que les éléments ont été insérés? Veuillez suggérer en quoi est-ce différent de LinkedHashMaps?
B.shruti

2
@ B.shruti: En effet, votre ordre d'insertion correspond à l'ordre lexicographique de vos clés ("abc1", "abc2", "abc3"). Si vous insérez dans un ordre différent, votre code continuera à itérer selon l'ordre lexicographique.
Eyal Schneider

47

Voyez où chaque classe se trouve dans la hiérarchie des classes dans le diagramme suivant (le plus grand ). TreeMap implémente SortedMapet NavigableMaptandis HashMapque non.

HashTableest obsolète et la ConcurrentHashMapclasse correspondante doit être utilisée. entrez la description de l'image ici


38

HashMap

  • Il a des valeurs de paire (clés, valeurs)
  • AUCUNE valeur clé de duplication
  • non trié non trié
  • il autorise une clé nulle et plusieurs valeurs nulles

HashTable

  • identique à la carte de hachage
  • il n'autorise pas les clés nulles et les valeurs nulles

LinkedHashMap

  • C'est la version ordonnée de l'implémentation de la carte
  • Basé sur une liste chaînée et des structures de données de hachage

TreeMap

  • Version commandée et triée
  • basé sur des structures de données de hachage

3
HashTable est également synchronisé. Quoi qu'il en soit ,, j'aime votre réponse, propre et claire.
Surasin Tancharoen

35

Juste un peu plus de ma propre expérience avec les cartes, sur quand j'utiliserais chacune:

  • HashMap - Plus utile lorsque vous recherchez une implémentation (rapide) aux meilleures performances.
  • TreeMap (interface SortedMap) - Très utile lorsque je souhaite pouvoir trier ou itérer sur les clés dans un ordre particulier que je définis.
  • LinkedHashMap - Combine les avantages d'une commande garantie depuis TreeMap sans augmenter le coût de maintenance de TreeMap. (Il est presque aussi rapide que le HashMap). En particulier, LinkedHashMap fournit également un excellent point de départ pour créer un objet Cache en remplaçant la removeEldestEntry()méthode. Cela vous permet de créer un objet Cache qui peut expirer des données en utilisant certains critères que vous définissez.

10
Pour être précis, TreeMap ne garde pas les éléments dans l'ordre. Il garde les clés en ordre.
LS

17

Tous les trois classes HashMap, TreeMapet LinkedHashMapmet en œuvre l' java.util.Mapinterface, et représente la cartographie de clé unique aux valeurs.

HashMap

  1. A HashMapcontient des valeurs basées sur la clé.

  2. Il ne contient que des éléments uniques.

  3. Il peut avoir une clé null et plusieurs valeurs null.

  4. Il ne maintient aucun ordre .

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

LinkedHashMap

  1. A LinkedHashMapcontient des valeurs basées sur la clé.
  2. Il ne contient que des éléments uniques.
  3. Il peut avoir une clé null et plusieurs valeurs null.
  4. C'est la même chose que HashMap maintient à la place l' ordre d'insertion . // Voir la décélération de classe ci-dessous

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

TreeMap

  1. A TreeMapcontient des valeurs basées sur la clé. Il implémente l'interface NavigableMap et étend la classe AbstractMap.
  2. Il ne contient que des éléments uniques.
  3. Il ne peut pas avoir de clé nulle mais peut avoir plusieurs valeurs nulles.
  4. Il est identique à la HashMapplace qui maintient l' ordre croissant (trié en utilisant l'ordre naturel de sa clé.).

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

Hashtable

  1. Une table de hachage est un tableau de liste. Chaque liste est connue sous le nom de compartiment. La position du compartiment est identifiée en appelant la méthode hashcode (). Une table de hachage contient des valeurs basées sur la clé.
  2. Il ne contient que des éléments uniques.
  3. Il peut ne pas avoir de clé ou de valeur nulle.
  4. Il est synchronisé .
  5. Il s'agit d'une classe héritée.

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

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


La notation Big-O de HashMap ne doit pas être O (1). C'est le meilleur des cas, et les tables de hachage ont O (n) comme pire scénario. Ceci est soutenu par votre lien.
Haakon Løtveit


@ HaakonLøtveit Je proposerai également d'aller chercher le code réel ici - grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/…
roottraveller

Cela dit TOUJOURS que c'est O (n) dans le pire des cas. C'est un concept mathématique, et vous ne pouvez pas dire que c'est O (1), à moins que ce ne soit en fait O (1). Vous supposez également ici de très bonnes fonctions de hachage. Je veux dire, nous pourrions utiliser quelque chose comme la classe TerribleHashKey {@Override hashCode () {return 4; / * Déterminé par un lancer de dés équitable * /}} et utilisez-le comme clé pour d'autres choses amusantes. Avoir une forte probabilité d'O (1) et avoir O (1) n'est pas la même chose. Les gens viennent ici pour aider avec leurs devoirs. Ne
gâchons

Et il convient de noter qu'en Java 8, vous avez le pire cas d'O (log (n)) si vous avez plus de 8 compartiments , voir grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk /… Pour plus de détails à ce sujet.
Haakon Løtveit

14

HashMap ne fait absolument aucune garantie sur l'ordre d'itération. Il peut (et changera) même complètement lorsque de nouveaux éléments sont ajoutés. TreeMap va itérer selon "l'ordre naturel" des clés selon leur méthode compareTo () (ou un comparateur externe). En outre, il implémente l'interface SortedMap, qui contient des méthodes qui dépendent de cet ordre de tri. LinkedHashMap itérera dans l'ordre dans lequel les entrées ont été placées dans la carte

Regardez comment les performances varient .. entrez la description de l'image ici

Carte arborescente qui est une implémentation de la carte triée. La complexité de l'opération put, get et containsKey est O (log n) en raison de l'ordre naturel


9

@Amit: SortedMapest une interface alors TreeMapqu'une classe qui implémente l' SortedMapinterface. Cela signifie que suit le protocole qui SortedMapdemande à ses implémenteurs de le faire. Un arbre, sauf s'il est implémenté comme arbre de recherche, ne peut pas vous donner de données ordonnées car l'arbre peut être n'importe quel type d'arbre. Donc, pour que TreeMap fonctionne comme l'ordre trié, il implémente SortedMap (par exemple, l'arbre de recherche binaire - BST, BST équilibré comme AVL et RB Tree, même l'arbre de recherche ternaire - principalement utilisé pour les recherches itératives de manière ordonnée).

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

En NUT-SHELL HashMap: donne des données en O (1), pas de classement

TreeMap : donne des données en O (log N), base 2. avec clés ordonnées

LinkedHashMap: est une table de hachage avec une capacité de liste liée (pensez à Indexed-SkipList) pour stocker les données de la manière dont elles sont insérées dans l'arborescence. Idéal pour implémenter LRU (utilisé le moins récemment).


6

Voici la différence majeure entre HashMap et TreeMap

  1. HashMap ne maintient aucune commande. En d'autres termes, HashMap ne fournit aucune garantie que l'élément inséré en premier sera imprimé en premier, alors que, tout comme TreeSet, les éléments TreeMap sont également triés selon l'ordre naturel de ses éléments.

  2. L'implémentation HashMap interne utilise Hashing et TreeMap utilise en interne l'implémentation arborescente Rouge-Noir.

  3. HashMap peut stocker une clé nulle et plusieurs valeurs nulles. TreeMap ne peut pas contenir de clés nulles mais peut contenir de nombreuses valeurs nulles.

  4. HashMap prend des performances à temps constant pour les opérations de base telles que get and put, c'est-à-dire O (1) .Selon Oracle docs, TreeMap fournit un coût en temps log (n) garanti pour la méthode get and put.

  5. HashMap est beaucoup plus rapide que TreeMap, car le temps de performance de HashMap est constant par rapport au temps de journalisation TreeMap pour la plupart des opérations.

  6. HashMap utilise la méthode equals () en comparaison tandis que TreeMap utilise la méthode compareTo () pour maintenir l'ordre.

  7. HashMap implémente l'interface Map tandis que TreeMap implémente l'interface NavigableMap.


5

Ce sont différentes implémentations de la même interface. Chaque implémentation présente des avantages et des inconvénients (insertion rapide, recherche lente) ou vice versa.

Pour plus de détails, consultez le javadoc de TreeMap , HashMap , LinkedHashMap .


Quels sont les Hashtables en réalité et ce qui le différencie d'une carte.
Kevin

5

La carte de hachage ne conserve pas l'ordre d'insertion.
Exemple. Hashmap Si vous insérez des clés comme

1  3
5  9
4   6
7   15
3   10

Il peut le stocker sous

4  6
5  9
3  10
1  3
7  15

Hashmap lié préserve l'ordre d'insertion.

Exemple.
Si vous insérez des clés

1  3
5  9
4   6
7   15
3   10

Il le stockera sous

1  3
5  9
4   6
7   15
3   10

même que nous insérons.

La carte arborescente stocke les valeurs dans l'ordre croissant des clés. Exemple.
Si vous insérez des clés

1  3
5  9
4   6
7   15
3   10

Il le stockera sous

1  3
3  10
4   6
5   9
7   15

4
  • HashMap:

    • L'ordre n'est pas maintenu
    • Plus rapide que LinkedHashMap
    • Utilisé pour stocker des tas d'objets
  • LinkedHashMap:

    • L'ordre d'insertion de LinkedHashMap sera maintenu
    • Plus lent que HashMap et plus rapide que TreeMap
    • Si vous souhaitez conserver un ordre d'insertion, utilisez-le.
  • TreeMap:

    • TreeMap est une cartographie basée sur un arbre
    • TreeMap suivra l'ordre naturel des clés
    • Plus lent que HashMap et LinkedHashMap
    • Utilisez TreeMap lorsque vous devez conserver un ordre naturel (par défaut)

1

Tous offrent une carte clé-> valeur et un moyen de parcourir les clés. La distinction la plus importante entre ces classes est la garantie de temps et la commande des clés.

  1. HashMap propose 0 (1) recherche et insertion. Si vous parcourez les clés, cependant, l'ordre des clés est essentiellement arbitraire. Il est implémenté par un tableau de listes chaînées.
  2. TreeMap offre la recherche et l'insertion O (log N). Les clés sont ordonnées, donc si vous devez parcourir les clés dans l'ordre trié, vous le pouvez. Cela signifie que les clés doivent implémenter l'interface Comparable.TreeMap est implémenté par un arbre rouge-noir.
  3. LinkedHashMap offre la recherche et l'insertion 0 (1). Les clés sont classées par ordre d'insertion. Il est mis en œuvre par des compartiments à double liaison.

Imaginez que vous avez passé un TreeMap, HashMap et LinkedHashMap vide dans la fonction suivante:

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

La sortie de chacun ressemblera aux résultats ci-dessous.

Pour HashMap, la sortie était, dans mes propres tests, {0, 1, -1}, mais cela pouvait être n'importe quel ordre. Il n'y a aucune garantie sur la commande.
Treemap, la sortie était, {-1, 0, 1}
LinkedList, la sortie était, {1, -1, 0}


1

Bien qu'il existe de nombreuses excellentes réponses ici, je voudrais présenter mon propre tableau décrivant les différentes Mapimplémentations fournies avec Java 11.

Nous pouvons voir ces différences répertoriées sur le graphique du tableau:

  • HashMapest l' usage général Map couramment utilisé lorsque vous n'avez pas de besoins particuliers.
  • LinkedHashMapétend HashMap, en ajoutant ce comportement: Gère un ordre, l' ordre dans lequel les entrées ont été ajoutées à l'origine . La modification de la valeur pour la saisie de valeur-clé ne modifie pas sa place dans l'ordre.
  • TreeMapmaintient également un ordre, mais utilise soit (a) l'ordre «naturel» , c'est-à-dire la valeur de la compareTométhode sur les objets clés définis sur l' Comparableinterface, soit (b) appelle une Comparatorimplémentation que vous fournissez.
  • NULL s: TreeMapn'autorise pas un NULL comme clé , tandis que HashMap& LinkedHashMapdo.
    • Les trois autorisent NULL comme valeur.
  • HashTableest hérité de Java 1 . Supplanté par la ConcurrentHashMapclasse. Citant le Javadoc: ConcurrentHashMapobéit à la même spécification fonctionnelle que Hashtable, et inclut des versions de méthodes correspondant à chaque méthode de Hashtable.

Tableau des implémentations de cartes dans Java 11, comparant leurs fonctionnalités


0

HashMap
peut contenir une clé nulle.

HashMap ne maintient aucune commande.

TreeMap

TreeMap ne peut contenir aucune clé nulle.

TreeMap maintient l'ordre croissant.

LinkedHashMap

LinkedHashMap peut être utilisé pour maintenir l'ordre d'insertion, sur lequel les clés sont insérées dans la carte ou il peut également être utilisé pour maintenir un ordre d'accès, sur lequel les clés sont accessibles.

Exemples ::

1) Carte HashMap = nouveau 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) Carte TreeMap = nouveau 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) Carte LinkedHashMap = nouvelle 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());
    }

0

Le plus important parmi les trois est de savoir comment ils enregistrent l'ordre des entrées.

HashMap- N'enregistre pas l'ordre des entrées. par exemple.

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

Sortie pour HashMap

LinkedHashMap: Il enregistre l'ordre dans lequel les entrées ont été effectuées. par exemple:

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

Sortie de LinkedHashMap

TreeMap: Il enregistre les entrées dans l'ordre croissant des touches. par exemple:

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

Sortie de TreeMap

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.