Interfețele SortedMap și NavigableMap - Clasa TreeMap

Java oferă interfețe suplimentare pentru gestionarea colecțiilor de tip map:SortedMap șiNavigableMap.

SortedMap

Interfața SortedMap extinde interfața Map și creează o colecție în care toate elementele sunt sortate în ordinea crescătoare a cheilor. Aceasta adaugă următoarele metode:

K firstKey(): returnează cheia primului element din map
K lastKey(): returnează cheia ultimului element din map
SortedMap<K, V> headMap(K end): returnează un SortedMap cu toate elementele până la cheia end
SortedMap<K, V> tailMap(K start): returnează un SortedMap cu toate elementele începând de la cheia start
SortedMap<K, V> subMap(K start, K end): returnează un SortedMap cu toate elementele între cheile start și end

NavigableMap

Interfața NavigableMap extinde SortedMap și oferă funcționalități suplimentare pentru a obține elemente bazate pe relațiile dintre chei. Principalele metode sunt:

Map.Entry<K, V> ceilingEntry(K key): returnează elementul cu cea mai mică cheie k, care este mai mare sau egală cu key
Map.Entry<K, V> floorEntry(K key): returnează elementul cu cea mai mare cheie k, care este mai mică sau egală cu key
Map.Entry<K, V> higherEntry(K key): returnează elementul cu cea mai mică cheie k, care este mai mare decât key
Map.Entry<K, V> lowerEntry(K key): returnează elementul cu cea mai mare cheie k, care este mai mică decât key
Map.Entry<K, V> firstEntry(): returnează primul element din map
Map.Entry<K, V> lastEntry(): returnează ultimul element din map
Map.Entry<K, V> pollFirstEntry(): returnează și elimină primul element din map
Map.Entry<K, V> pollLastEntry(): returnează și elimină ultimul element din map
K ceilingKey(K key): returnează cea mai mică cheie k, care este mai mare sau egală cu key
K floorKey(K key): returnează cea mai mare cheie k, care este mai mică sau egală cu key
K higherKey(K key): returnează cea mai mică cheie k, care este mai mare decât key
K lowerKey(K key): returnează cea mai mare cheie k, care este mai mică decât key
NavigableSet<K> descendingKeySet(): returnează un NavigableSet cu toate cheile în ordine inversă
NavigableMap<K, V> descendingMap(): returnează un NavigableMap cu toate elementele în ordine inversă
NavigableMap<K, V> headMap(K upperBound, boolean incl): returnează toate elementele până la cheia upperBound, incluzând upperBound dacă parametrul incl este true
NavigableMap<K, V> tailMap(K lowerBound, boolean incl): returnează toate elementele începând cu cheia lowerBound, incluzând lowerBound dacă parametrul incl este true
NavigableMap<K, V> subMap(K lowerBound, boolean lowIncl, K upperBound, boolean highIncl): returnează toate elementele între cheile lowerBound și upperBound, incluzând aceste chei dacă parametrul lowIncl și highIncl sunt true

TreeMap

Clasa TreeMap<K, V> reprezintă un map sub formă de arbore. Aceasta moștenește clasa AbstractMap și implementează interfața NavigableMap, iar prin aceasta și SortedMap. Spre deosebire de HashMap, în TreeMap elementele sunt sortate automat în ordinea crescătoare a cheilor.

Constructorii principali ai clasei TreeMap sunt:

TreeMap(): creează un arbore gol
TreeMap(Map<? extends K,? extends V> map): creează un arbore și adaugă toate elementele din colecția map
TreeMap(SortedMap<K, ? extends V> smap): creează un arbore și adaugă toate elementele din SortedMap
TreeMap(Comparator<? super K> comparator): creează un arbore gol, iar elementele vor fi sortate conform comparatorului

Exemplu de utilizare a clasei TreeMap:

import java.util.*;

public class Program{
     
   public static void main(String[] args) {
         
       TreeMap<Integer, String> states = new TreeMap<Integer, String>();
       states.put(10, "Germany");
       states.put(2, "Spain");
       states.put(14, "France");
       states.put(3, "Italy");
       
       // Obținem un obiect pe baza cheii 2
       String first = states.get(2);
       System.out.println(first);
       
       // Parcurgerea elementelor
       for(Map.Entry<Integer, String> item : states.entrySet()) {
           System.out.printf("Key: %d  Value: %s \n", item.getKey(), item.getValue());
       }
       
       // Obținem setul de chei
       Set<Integer> keys = states.keySet();
       
       // Obținem toate valorile
       Collection<String> values = states.values();
       
       // Obținem toate elementele după cheia 4
       Map<Integer, String> afterMap = states.tailMap(4);
       
       // Obținem toate elementele până la cheia 10
       Map<Integer, String> beforeMap = states.headMap(10);
       
       // Obținem ultimul element din arbore
       Map.Entry<Integer, String> lastItem = states.lastEntry();
       System.out.printf("Last item has key %d value %s \n",lastItem.getKey(), lastItem.getValue());
         
       // TreeMap cu obiecte Person
       Map<String, Person> people = new TreeMap<String, Person>();
       people.put("1240i54", new Person("Tom"));
       people.put("1564i55", new Person("Bill"));
       people.put("4540i56", new Person("Nick"));
       
       for(Map.Entry<String, Person> item : people.entrySet()) {
           System.out.printf("Key: %s  Value: %s \n", item.getKey(), item.getValue().getName());
       }
   }
}

class Person {
     
   private String name;
   public Person(String name) {
       this.name = name;
   }
   String getName() {
       return name;
   }
}

Explicații:

TreeMap sortează automat elementele în funcție de cheile lor.

Metodele headMap și tailMap returnează elementele care se află înainte sau după o anumită cheie
Metodele firstEntry() și lastEntry() returnează primul și ultimul element din map