Explication détaillée d'exemples de tri de Map en Java

Cet article partagera avec vous les problématiques du tri par valeur et du tri par clé dans les cartes en Java, et à travers des exemples précis, j'espère qu'il vous sera utile.

Types de carte

En Java, la fonction principale de Map est de stocker des paires clé-valeur. Puisque la valeur est obtenue en fonction de la clé, les clés en double ne sont pas autorisées. Il comporte principalement les catégories suivantes :

HashMap :

La Map la plus couramment utilisée, elle stocke les données en fonction de la valeur HashCode de la clé, et peut être obtenu directement selon la clé Sa valeur a une vitesse d'accès très rapide Lors du parcours, l'ordre dans lequel les données sont obtenues est complètement aléatoire. HashMap permet uniquement que la clé d'un enregistrement soit Null au maximum ; il permet que la valeur de plusieurs enregistrements soit Null ; HashMap ne prend pas en charge la synchronisation des threads, c'est-à-dire que plusieurs threads peuvent écrire HashMap en même temps à tout moment ; conduire à une incohérence des données. Si une synchronisation est requise, vous pouvez utiliser la méthode synchroniséMap de Collections pour synchroniser le HashMap, ou utiliser ConcurrentHashMap. Hashtable est similaire à HashMap. Il hérite de la classe Dictionary. La différence est qu'il ne permet pas que les clés ou les valeurs enregistrées soient vides. Il prend en charge la synchronisation des threads, c'est-à-dire qu'un seul thread à la fois peut écrire dans la table de hachage. time, ce qui entraîne également l'écriture de la table de hachage. Le timing sera plus lent.

LinkedHashMap

enregistre l'ordre d'insertion des enregistrements Lorsque vous utilisez Iterator pour parcourir LinkedHashMap, l'enregistrement obtenu en premier doit être inséré en premier. peut utiliser des paramètres lors de la construction et trier par nombre d'applications. Il sera plus lent que HashMap lors du parcours, mais il y a une exception. Lorsque HashMap a une grande capacité et que les données réelles sont petites, le parcours peut être plus lent que LinkedHashMap, car la vitesse de parcours de LinkedHashMap est uniquement liée aux données réelles et a rien à voir avec la capacité. La vitesse de parcours de HashMap est liée à sa capacité.

TreeMap

implémente l'interface SortMap , qui peut trier les enregistrements qu'il enregistre par clé. La valeur par défaut est par. valeur de clé. Tri par ordre croissant, vous pouvez également spécifier le comparateur de tri Lorsque vous utilisez Iterator pour parcourir le TreeMap, les enregistrements obtenus sont triés.

Trier par clé

D'après l'introduction ci-dessus des types de cartes, nous pouvons voir que TreeMap a sa propre fonction de tri par clé, qui n'a besoin que d'être triée lors de la création, implémentez simplement une interface de comparaison en même temps. L'exemple est le suivant :

private static void sort_by_key(){
    Map<Integer, Integer> treeMap = new TreeMap<>(new Comparator<Integer>() {
      @Override
      public int compare(Integer o1, Integer o2) {
        return o2-o1; //倒序.这里说明一下，如果返回负值，则o1先输出，反之则o2
      }
    });
    
    //填充数据
    for(int i = 0; i < 100;i++){
      int key = (int)(10000*Math.random());
      int value = (int)(10000*Math.random());
      treeMap.put(key, value);
    }
    outMap(treeMap);
  }

public static void outMap(Map<Integer, Integer> map){
    for(Integer integer:map.keySet()){
      System.out.println("key="+integer+"  value="+map.get(integer));
    }
}
/* 结果如下：
key=9977  value=80
key=9684  value=7108
key=9422  value=1706
key=9264  value=1210
key=9248  value=4758
key=9024  value=7048
key=8892  value=3124
key=8879  value=6414
key=8814  value=8171
key=8728  value=1538
key=8513  value=4956
key=8462  value=5617
key=8355  value=8912
*/

Comme le montre ce qui précède, le tri par clé n'est pas difficile, mais le tri par emplacement est plus gênant, et la carte doit être transférée.

Trier par valeur

Étant donné que Map en Java n'a pas cette fonction, nous devons l'implémenter nous-mêmes. L'idée est la suivante :

List en Java peut utiliser l'interface de comparaison.
La carte est en fait une collection d'Entrée<>
Ensuite, en utilisant List>, vous pouvez la trier
Insérez les éléments triés dans LinkedMap

Le code est implémenté comme suit :

 private static Map<Integer, Integer> sortMap(Map<Integer, Integer> linkedMap) {
    
    List<Map.Entry<Integer, Integer>> cache = new ArrayList<>(linkedMap.entrySet());

    //重写比较函数
    Collections.sort(cache,new Comparator<Map.Entry<Integer, Integer>>() {
      @Override
      public int compare(Entry<Integer, Integer> o1, Entry<Integer, Integer> o2) {
        //若返回值小于0，则o1在o2前面
        return o2.getValue()-o1.getValue();
      }
    });

    Map<Integer, Integer> resultMap = new LinkedHashMap<>();
    //将结果插入LinkedMap然后返回
    for(int i = 0; i < cache.size();i++){
      resultMap.put(cache.get(i).getKey(), cache.get(i).getValue());
    }
    return resultMap;
  }
/*结果:
7965  9966
1067  9963
1720  9833
3257  9738
3934  9578
777  9348
1924  9315
3472  9270
3649  9114
5892  9078
*/

De cette manière, le tri par valeur et le tri par clé peuvent être implémentés.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!