Ordina una mappa per valore in Java

  2. HowTo
  3. Java Howtos
  4. Ordina una mappa per valore in Java
Mohammad Irfan 12 ottobre 2023
Java Java Map
  1. Ordinare una Map<chiave, valore> utilizzando il metodo sort() in Java
  2. Ordinare una Map<chiave, valore> utilizzando il metodo sorted() in Java
  3. Ordina una Map<chiave, valore> usando il metodo sort() con Comparatore in Java
  4. Ordinare una Map<chiave, valore> utilizzando il metodo sorted() e toMap() in Java
  5. Ordina una Map<chiave, valore> utilizzando il codice personalizzato in Java
Ordina una mappa per valore in Java

Questo tutorial introduce come ordinare una Map<chiave, valore> per valore in Java ed elenca alcuni codici di esempio per comprenderla.

Esistono diversi modi per ordinare una Map<chiave, valore>. Qui usiamo il metodo sort(), sorted() e l’interfaccia di confronto, ecc. Vediamo gli esempi.

Ordinare una Map<chiave, valore> utilizzando il metodo sort() in Java

Possiamo usare il metodo sort() dell’interfaccia List per ordinare gli elementi di Map. Il metodo sort() ordina gli elementi in ordine crescente e abbiamo specificato l’ordinamento per valore utilizzando il metodo comparingByValue(). Vedi l’esempio sotto.

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

Produzione:

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

Ordinare una Map<chiave, valore> utilizzando il metodo sorted() in Java

Se stai lavorando con i flussi, puoi usare il metodo sorted() che ordina gli elementi in ordine crescente. Passiamo Map.Entry.comparingByValue() come argomento al metodo sorted() per ordinare la Map<chiave, valore> per valori.

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

Produzione:

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

Ordina una Map<chiave, valore> usando il metodo sort() con Comparatore in Java

In questo esempio, usiamo il metodo compareTo() per confrontare i valori di Map<chiave, valore> all’interno del metodo sort() come argomento. Come puoi vedere, abbiamo creato una classe interna anonima dell’interfaccia Comparator e definito il metodo compare() per confrontare i valori.

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

Produzione:

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

Ordinare una Map<chiave, valore> utilizzando il metodo sorted() e toMap() in Java

In questo esempio, stiamo usando il metodo sorted() per ordinare la Map<chiave, valore> e raccogliere il risultato in LinkedHashMap usando il metodo toMap(). Qui, abbiamo utilizzato il concetto di riferimento del metodo per creare un oggetto 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));
  }
}

Produzione:

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

Ordina una Map<chiave, valore> utilizzando il codice personalizzato in Java

Qui, abbiamo creato una classe definita dall’utente che implementa l’interfaccia Comparator e passato il suo oggetto a TreeMap per ottenere Map<chiave, valore> ordinata per valore.

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

Produzione:

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

Articolo correlato - Java Map