Types de carte
En Java, la fonction principale de la carte est de stocker les paires de valeurs clés. Étant donné que la valeur est obtenue en fonction de la clé, la clé ne peut pas être répétée. Il a principalement les catégories suivantes:
Hashmap:
La MAP la plus couramment utilisée stocke les données en fonction de la valeur de code de hash de la clé et peut obtenir directement sa valeur en fonction de la clé, avec une vitesse d'accès très rapide. Lors de la traversée, l'ordre d'acquisition de données est complètement aléatoire. Hashmap ne permet qu'à un seul enregistrement d'être nul; La valeur de plusieurs enregistrements est nul; HashMap ne prend pas en charge la synchronisation du thread, c'est-à-dire que plusieurs threads peuvent écrire HashMap à tout moment; Cela peut entraîner une incohérence dans les données. Si une synchronisation est requise, vous pouvez utiliser la méthode des collections SynchronizedMap pour faire synchronisé HashMap ou utiliser ConcurrentHashMap. Hashtable est similaire à HashMap. Il hérite de la classe du dictionnaire. La différence est qu'il ne permet pas aux clés ou aux valeurs enregistrées d'être vides; Il prend en charge la synchronisation du thread, c'est-à-dire qu'un seul thread peut écrire du hashtable à tout moment, donc il fait également du hachable plus lent lors de l'écriture.
LinkedHashmap
L'ordre d'insertion des enregistrements est enregistré. Lors de la traversée LinkedHashmap avec Iterator, les enregistrements obtenus en premier doivent être insérés en premier. Vous pouvez également utiliser des paramètres pendant la construction et les trier en fonction du nombre d'applications. Il sera plus lent que Hashmap lors de la traversée, mais il y a une exception. Lorsque Hashmap a une grande capacité et est moins de données réelles, elle peut être plus lente que LinkedHashMap, car la vitesse de traversée de LinkedHashMap n'est liée qu'aux données réelles et n'a rien à voir avec la capacité, tandis que la vitesse de traversée de Hashmap est liée à sa capacité.
Tramper
Implémentation de l'interface Sortmap, les enregistrements qu'il enregistre peut être trié en fonction de la clé. Par défaut, il est trié dans l'ordre croissant des valeurs clés, ou il peut également spécifier un comparateur trié. Lorsqu'il est traversé avec itérateur, les enregistrements obtenus sont triés.
Tri des clés
D'après l'introduction ci-dessus aux types de cartes, nous pouvons voir que Treemap a sa propre fonction de tri des clés. Il n'a qu'à implémenter une interface de comparaison en même temps lors de la création. L'exemple est le suivant:
private static void sort_by_key () {map <Integer, Integer> Treemap = new Treemap <> (nouveau comparateur <Integer> () {@Override public int compare (Integer O1, entier o2) {return o2-o1; // inverse ordre. // Remplissez les données pour (int i = 0; i <100; i ++) {int key = (int) (10000 * math.random ()); int value = (int) (10000 * math.random ()); Treemap.put (clé, valeur); } outmap (Treemap); } public static void outmap (map <Integer, Integer> map) {for (Integer Integer: map.KeySet ()) {System.out.println ("key =" + enter + "value =" + map.get (Integer)); }} / * Le résultat est le suivant: key = 9977 value = 80Key = 9684 Value = 7108Key = 9422 Value = 1706Key = 9264 Value = 1210Key = 9248 Value = 4758KEY = 9024 Value = 7048Key = 8892 Value = 3124key = 8879 Value = 6414KEY = 8892 Valeur = 8171KEY = 8728 VALEUR = 1538KEY = 8513 Valeur = 4956KEY = 8462 Valeur = 5617Key = 8355 Valeur = 8912 * /Comme on peut le voir à partir de ce qui précède, il n'est pas difficile de trier par les clés, mais il est plus difficile de placer le type, vous devez donc tourner la carte.
Trier par valeur
Étant donné que MAP n'a pas cette fonction en Java, nous devons l'implémenter nous-mêmes. L'idée est la suivante:
La liste dans Java peut utiliser l'interface compare.
La carte est en fait une collection d'entrée <>. Ainsi, l'utilisation de la liste <entrée <>> peut implémenter le tri et l'insertion des éléments triés dans LinkedMap.
L'implémentation du code est la suivante:
Map statique privé <Integer, Integer> sortmap (map <Integer, Integer> LinkedMap) {list <map.entry <Integer, Integer >> cache = new ArrayList <> (LinkedMap.EntrySet ()); // Réécrivez les collections de fonctions de comparaison.sort (cache, nouveau comparateur <map.entry <Integer, Integer >> () {@Override public int compare (entrée <Integer, entier> o1, entrée <entier, entier> o2) {// Si la valeur de retour est inférieure à 0, alors o1 est avant O2 return o2.getValue () - o1. }); Map <Integer, Integer> resultMap = new LinkedHashMap <> (); // Insérez le résultat dans LinkedMap et Return for (int i = 0; i <cache.size (); i ++) {resultMap.put (cache.get (i) .getKey (), cache.get (i) .getValue ()); } return resultMap; } / * Résultat: 7965 99661067 99631720 98333257 97383934 957877 93481924 93153472 92703649 91145892 9078 * /De cette façon, le tri par valeur et le tri par clé peut être réalisé.