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
Ti piacciono i nostri tutorial? Iscriviti a DelftStack su YouTube per aiutarci a creare altre guide video di alta qualità. Iscriviti

Articolo correlato - Java Map