Comment trier une carte par valeur en Java

  2. HowTo
  3. Howtos de Java
  4. Comment trier une carte par valeur en …
Mohammad Irfan 12 octobre 2023
Java Java Map
  1. Trier une Map<key, value> en utilisant la méthode sort() en Java
  2. Trier une clé Map<, valeur> en utilisant la méthode sorted() en Java
  3. Trier une Map<key, value> en utilisant la méthode sort() avec Comparator en Java
  4. Trier une clé Map<, valeur> en utilisant les méthodes sorted() et toMap() en Java
  5. Trier une clé Map<key, value> Utiliser du code personnalisé en Java
Comment trier une carte par valeur en Java

Ce tutoriel présente comment trier une Map<key, value> para value en Java et donne quelques exemples de codes pour la comprendre.

Il y a plusieurs façons de trier un Map<key, value>. Nous utilisons ici la méthode sort(), sorted() et l’interface de comparaison, etc. Voyons les exemples.

Trier une Map<key, value> en utilisant la méthode sort() en Java

Nous pouvons utiliser la méthode sort() de l’interface List pour trier les éléments de la carte. La méthode sort() trie les éléments en ordre croissant et nous avons spécifié le tri par valeur en utilisant la méthode comparingByValue(). Voir l’exemple ci-dessous.

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

public class SimpleTesting {
  public static void main(String[] args) {
    Map<Integer, Integer> map = new HashMap<>();
    map.put(2, 1020);
    map.put(3, 300);
    map.put(1, 100);
    map.put(5, 500);
    map.forEach((k, v) -> System.out.println(k + "=" + v));
    System.out.println("After Sorting by value");
    List<Entry<Integer, Integer>> list = new ArrayList<>(map.entrySet());
    list.sort(Entry.comparingByValue());
    list.forEach(System.out::println);
  }
}

Production:

1=100
2=1020
3=300
5=500
After Sorting
1=100
3=300
5=500
2=1020

Trier une clé Map<, valeur> en utilisant la méthode sorted() en Java

Si vous travaillez avec des flux, vous pouvez utiliser la méthode sorted() qui trie les éléments par ordre croissant. Nous passons Map.Entry.comparingByValue() en argument à la méthode sorted() pour trier la Map<key, value> par valeurs.

import java.util.HashMap;
import java.util.Map;
import java.util.stream.Stream;

public class SimpleTesting {
  public static void main(String[] args) {
    Map<Integer, Integer> map = new HashMap<>();
    map.put(2, 1020);
    map.put(3, 300);
    map.put(1, 100);
    map.put(5, 500);
    map.forEach((k, v) -> System.out.println(k + "=" + v));
    System.out.println("After Sorting by value");
    Stream<Map.Entry<Integer, Integer>> sorted =
        map.entrySet().stream().sorted(Map.Entry.comparingByValue());
    sorted.forEach(System.out::println);
  }
}

Production:

1 = 100 2 = 1020 3 = 300 5 = 500 After Sorting by value 1 = 100 3 = 300 5 = 500 2 = 1020

Trier une Map<key, value> en utilisant la méthode sort() avec Comparator en Java

Dans cet exemple, nous utilisons la méthode compareTo() pour comparer les valeurs de Map<key, value> à l’intérieur de la méthode sort() comme argument. Vous pouvez voir que nous avons créé une classe interne anonyme de l’interface Comparator et défini la méthode compare() pour comparer les valeurs.

import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

public class SimpleTesting {
  public static void main(String[] args) {
    Map<Integer, Integer> map = new HashMap<>();
    map.put(2, 1020);
    map.put(3, 300);
    map.put(1, 100);
    map.put(5, 500);
    map.forEach((k, v) -> System.out.println(k + "=" + v));
    System.out.println("After Sorting by value");
    List<Entry<Integer, Integer>> list = new LinkedList<>(map.entrySet());
    Collections.sort(list, new Comparator<Object>() {
      @SuppressWarnings("unchecked")
      public int compare(Object o1, Object o2) {
        return ((Comparable<Integer>) ((Map.Entry<Integer, Integer>) (o1)).getValue())
            .compareTo(((Map.Entry<Integer, Integer>) (o2)).getValue());
      }
    });
    Map<Integer, Integer> result = new LinkedHashMap<>();
    for (Iterator<Entry<Integer, Integer>> it = list.iterator(); it.hasNext();) {
      Map.Entry<Integer, Integer> entry = (Map.Entry<Integer, Integer>) it.next();
      result.put(entry.getKey(), entry.getValue());
    }
    result.forEach((k, v) -> System.out.println(k + "=" + v));
  }
}

Production:

1=100
2=1020
3=300
5=500
After Sorting by value
1=100
3=300
5=500
2=1020

Trier une clé Map<, valeur> en utilisant les méthodes sorted() et toMap() en Java

Dans cet exemple, nous utilisons la méthode sorted() pour trier la clé Map<key, value> et collecter le résultat dans LinkedHashMap en utilisant la méthode toMap(). Ici, nous avons utilisé le concept de référence de la méthode pour créer un objet LinkedHashMap.

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Collectors;

public class SimpleTesting {
  public static void main(String[] args) {
    Map<Integer, Integer> map = new HashMap<>();
    map.put(2, 1020);
    map.put(3, 300);
    map.put(1, 100);
    map.put(5, 500);
    map.forEach((k, v) -> System.out.println(k + "=" + v));
    System.out.println("After Sorting by value");
    Map<Integer, Integer> result = map.entrySet()
                                       .stream()
                                       .sorted(Entry.comparingByValue())
                                       .collect(Collectors.toMap(Entry::getKey, Entry::getValue,
                                           (e1, e2) -> e1, LinkedHashMap::new));
    result.forEach((k, v) -> System.out.println(k + "=" + v));
  }
}

Production:

1=100
2=1020
3=300
5=500
After Sorting by value
1=100
3=300
5=500
2=1020

Trier une clé Map<key, value> Utiliser du code personnalisé en Java

Ici, nous avons créé une classe définie par l’utilisateur qui implémente l’interface Comparator et nous avons passé son objet à TreeMap pour obtenir un tri Map<key, value> par valeur.

import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
class UserComparator implements Comparator<Object> {
  Map<Integer, Integer> map;
  public UserComparator(Map<Integer, Integer> map) {
    this.map = map;
  }
  public int compare(Object o1, Object o2) {
    if (map.get(o2) == map.get(o1))
      return 1;
    else
      return ((Integer) map.get(o1)).compareTo((Integer) map.get(o2));
  }
}
public class SimpleTesting {
  public static void main(String[] args) {
    Map<Integer, Integer> map = new HashMap<>();
    map.put(2, 1020);
    map.put(3, 300);
    map.put(1, 100);
    map.put(5, 500);
    map.forEach((k, v) -> System.out.println(k + "=" + v));
    System.out.println("After Sorting by value");
    UserComparator comparator = new UserComparator(map);
    Map<Integer, Integer> result = new TreeMap<Integer, Integer>(comparator);
    result.putAll(map);
    result.forEach((k, v) -> System.out.println(k + "=" + v));
  }
}

Production:

1=100
2=1020
3=300
5=500
After Sorting by value
1=100
3=300
5=500
2=1020

Article connexe - Java Map