Twój problem polega na tym, że musisz zejść z piątej postaci normalnej na ziemię. :)
Tłumacząc po ludzku musisz rozbić każdą obecną w mapie parę <String, List<Zamowienie>> na serię par:
<String1, Zamówienie1>
//...
<String1, ZamówienieN>
//...
<StringN, Zamówienie1>
//...
<StringN, ZamówienieN>
Dopiero wtedy masz możliwość posortować "mapę". Natomiast prościej by było gdybyś mógł się pozbyć tych Stringów (bez aluzji :)).
Mając listę kluczy do mapy możesz z mapy wyciągnąć zamówienia:
List<String> indeksy = keyList(transakcje, new LexicOrder<>());
Do tego potrzeba metody takiej jak ta:
static <K, V> List<K> keyList(Map<K, V> map, Comparator<? super K> c)
{
final List<K> keys = new ArrayList<>(map.size());
for(K element: map.keySet())
Lists.sortingInsert(element, keys, false, c);
return keys;
}
Potem rozbicie postaci normalnej:
List<Pair<String, Zamówienie>> zamówienia = new ArrayList<>();
for(String indeks: indeksy)
zamówienia.add(new Pair<>(indeks, transakcje.get(indeks)));
I na koniec posortowanie:
List<Pair<String, Zamówienie>> zamówieniaPosortowane = Lists.sortedBy(zamówienia,
new Comparator<>()
{
@Override public int compare(Pair<String, Zamówienie> p1, Pair<String, Zamówienie> p2)
{
return String.CASE_INSENSITIVE_ORDER
.compare(p1.getValue().k.nazwiskoImie, p2.getValue().k.nazwiskoImie);
}
}
Nie jest to maksymalnie efektywne ponieważ ostatnie sortowanie nie będzie całkowicie po polsku - a w przypadku nazwisk dobrze by było, żeby taki "Ącki" poszedł na początku, a nie na końcu. Żeby to poprawić należałoby dziedziczyć po klasie Pair<String, Zamówienie>, przesłonić sobie toString tak aby do Stringa wyrzucało zawartość getValue().k.nazwiskoImie, a następnie użyć komparatora LexicOrder - który potrafi sobie sortować wg alfabetów narodowych i dodatkowo cache'ować klucze (CollationKey) porównywania elementów. Ewentualnie trzeba stworzyć interfejs, który z dowolnego typu E wyciągnie sobie String (czyli getValue().k.nazwiskoImie) i podać go jako dodatkowy parametr konstruktora do zmodyfikowanego potomka LexicOrder.
W przypadku map trzeba jeszcze uważać aby kluczami nie zostały tablice lub wyliczenia bo standardowa HashMap nie potrafi liczyć haszy dla tych typów i wali bezwartościową wersję z Object.
Do tego powyżej potrzebny jest uniwersalny typ pary, podstawowe komparatory i podstawy sortowania zwykłych list:
- Pair:
package com.olamagato.util;
import com.olamagato.util.Arr;
import java.util.Objects;
/**
* Reprezentuje skojarzoną parę klucz-wartość będącą
* odwzorowaniem niezmiennym.
* @param <K> typ klucza
* @param <V> typ wartości
* @author Olamagato
* @version 1.0
*/
public class Pair<K, V>
{
/**
* Tworzy odwzorowanie pary klucza i wartości.
* @param key klucz odwzorowania
* @param value wartość odwzorowania
*/
public Pair(K key, V value)
{
this.key = key;
this.value = value;
}
/**
* Zwraca klucz odwzorowania.
* @return klucz
*/
public K getKey() { return key; }
/**
* Zwraca wartość odwzorowania.
* @return wartość
*/
public V getValue() { return value; }
/**
* Zwraca wartość równości między dwoma obiektami odwzorowań
* @param oth obiekt innej pary
* @return true jeżeli ten obiekt oraz oth są tożsame
*/
@Override public boolean equals(Object obj)
{
if(obj == null || this.getClass() != obj.getClass())
return false;
else if(obj == this)
return true;
@SuppressWarnings(value = "unchecked")
final Pair<K, V> other = (Pair<K, V>)obj;
return Objects.deepEquals(this.key, other.key) &&
Objects.deepEquals(this.value, other.value);
}
/**
* Kod haszujący odwzorowania zależy od kodu klucza i wartości
* odwzorowania.
* @return kod haszujący odwzorowania
*/
@Override public int hashCode()
{ return Arrays.hashCode(keyHashCode(), value); }
/**
* Zwraca cache'owany kod haszujący klucza odwzorowania.
* @return kod haszujący klucza
*/
public int keyHashCode()
{
return keyHashCodeCache != 0 ? keyHashCodeCache
: (keyHashCodeCache = Arrays.hashCode(key));
}
private K key;
private V value;
private int keyHashCodeCache; //cache kodu haszującego klucza
} //public static final class Pair<K, V>
- I cała reszta w jednej klasie narzędziowej:
package com.olamagato.util;
import java.text.CollationKey;
import java.text.Collator;
import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
/**
* Klasa pomocnicza do obsługi list.
* @author Olamagato
* @version 1.4
*/
abstract public class Lists
{
/**
* Klasa obiektu naturalnie porównującego obiekty typu E.
* Wszędzie gdzie potrzeba komparatora dla typu elementów mających swój
* naturalny porządek, tam można umieścić komparator w takiej postaci
* {@code new NaturalOrder<E>()}, gdzie E jest klasą posiadającą swój
* naturalny porządek wyrażony implementacją interfejsu
* {@literal Comparable<E>}. Klasy używające: SortedList.
* @param <E> elementy listy mające swój naturalny porządek
*/
public static class NaturalOrder<E extends Comparable<? super E>>
implements Comparator<E>
{
/**
* Komparator zwracający wynik porównania elementów mających swój
* naturalny porządek.
* @param e1 pierwszy element
* @param e2 drugi element
* @return liczba dodatnia gdy e1>e2, zero gdy e1==e2 lub ujemna
* gdy e1< e2
*/
@Override public int compare(E e1, E e2) { return e1.compareTo(e2); }
} //public static class NaturalOrder<E extends Comparable<? super E>>
/**
* Klasa obiektu porównującego leksykograficznie obiekty typu E. Wszędzie
* gdzie potrzeba komparatora dla typu elementów mających swój porządek
* leksykograficzny można umieścić komparator w takiej postaci
* {@code new LexicOrder<E>()}, gdzie E jest klasą posiadającą jakiś
* porządek leksykograficzny obiektów w postaci tekstowej. Domyślnie
* porównywanie następuje wg porównania leksykograficznego dla domyślnego
* alfabetu domyślnego języka w bieżącej JVM. Komparator porównuje elementy
* na podstawie przeprowadzonej ekstrakcji obiektów CollationKey dla postaci
* tekstowej porównywanych elementów. Klucze porównywania dla poszczególnych
* elementów są przy użyciu generowane i zachowywane do późniejszego użycia.
* Pozwala to na efektywne sortowanie lub inne operacje wymagające wielu
* porównań tych samych elementów. Domyślny sposób użycia:
* {@code new LexicOrder<>()} Zobacz:
* {@link SortedList}, {@link Lists}{@literal sortedBy()}
* @param <E> typ elementów listy
*/
public class LexicOrder<E> implements Comparator<E>
{
/**
* Tworzy obiekt porównujący postaci tekstowe elementów E w bieżącej
* lokalizacji z domyślnym poziomem dekompozycji i siły porównywania.
*/
public LexicOrder()
{
this.collator = Collator.getInstance();
}
/**
* Tworzy obiekt porównujący postaci tekstowe elementów E w podanej
* lokalizacji, z domyślnym dla niej poziomem dekompozycji i siły
* porównywania.
* @param locale żądana lokalizacja
*/
public LexicOrder(Locale locale)
{
this.collator = Collator.getInstance(locale);
}
/**
* Tworzy obiekt porównujący postaci tekstowe elementów E w podanej
* lokalizacji, z podanym poziomem dekompozycji i siły porównywania.
* @param locale żądana lokalizacja
* @param decomposition żądany poziom dekompozycji
* @param strength żądana dokładność porównywania
*/
public LexicOrder(Locale locale, int decomposition, int strength)
{
this.collator = Collator.getInstance(locale);
this.collator.setDecomposition(decomposition);
this.collator.setStrength(strength);
}
/**
* Porównuje wartości tekstowe elementów e1 i e2 przy pomocy
* wygenerowanego obiektu typu Collator oraz tworzonych z opóźnieniem
* kluczy porównywania umieszczanych w mapie, która pozwala odzyskać te
* klucze przy ponownym użyciu.
* @param e1 pierwszy element
* @param e2 drugi element
* @return wynik porównania postaci tekstowych tych elementów
*/
@Override public int compare(E e1, E e2)
{
CollationKey ck1 = cache.get(e1), ck2 = cache.get(e2);
if(ck1 == null)
cache.put(e1, ck1 = collator.getCollationKey(e1.toString()));
if(ck2 == null)
cache.put(e2, ck2 = collator.getCollationKey(e2.toString()));
return ck1.compareTo(ck2);
}
private final HashMap<E, CollationKey> cache = new HashMap<>();
private final Collator collator;
} //public static class LexicOrder<E> extends ArrayList<E>
/**
* Tworzy listę elementów E o zawartości identycznej jak podawana lista,
* lecz posortowaną wg klucza podawanego przez comparator.
* @param <E> typ elementów
* @param list lista elementów
* @param comp comparator dwóch elementów typu E
* @return lista elementów posortowanych wg podanego indeksera
*/
public static <E> List<E> sortedBy(List<E> list, final Comparator<E> comp)
{
final List<E> result = new ArrayList<>(list.size());
for(E element: list) //wstawia również elementy nieunikalne
Lists.sortingInsert(element, result, false, comp);
return result;
}
/**
* Przeszukuje za pomocą podziałów połówkowych całą posortowaną rosnąco
* listę o dostępie swobodnym i zwraca indeks znalezionego elementu toFind
* lub wartość -ins - 1, gdzie ins jest pozycją wstawienia elementu, czyli
* większy od pierwszego mniejszego elementu na liście. Metoda może być
* wykorzystana do szybkiego określenia występowania elementu toFind na
* liście list, czyli efektywnie zastąpić metodę contains().
* @param <E> typ elementu listy
* @param list posortowana rosnąco lista elementów
* @param toFind element, którego indeks jest do znalezienia
* @param c obiekt komparatora porównującego dwa elementy listy
* @return nieujemny indeks znalezionego elementu lub -punkt_wstawienia-1
*/
public static <E>
int binarySearch(E toFind, List<E> list, Comparator<? super E> c)
{
int l = 0;
int r = list.size() - 1;
for(int cmp, mid = (l + r) >>> 1; l <= r; mid = (l + r) >>> 1)
{
cmp = c.compare(toFind, list.get(mid));
if(cmp > 0) l = ++mid;
else if(cmp < 0) r = --mid;
else return mid; //toFind found
}
return -(l + 1); //toFind not found.
}
/**
* Wstawia element toInsert do podanej posortowanej listy w taki sposób,
* aby znalazł się on między elementem mniejszym i większym. Elementy są
* porównywane za pomocą podanego komparatora. Parametr allowReplace
* pozwala na zastępowanie równych elementów już występujących na liście,
* czyli wymusza unikalność wartości wstawianych elementów.
* Pomyślne wstawienie/zastąpienie zwraca true, a brak wykonanej akcji
* zwraca false. Metoda może być efektywnie wykorzystana do szybkiego
* tworzenia posortowanych list.
* @param <E> typ elementu
* @param toInsert element do wstawienia na listę list
* @param list posortowana lista (może być pusta)
* @param comparator obiekt porównujący elementy
* @param allowReplace pozwala na zastępowanie elementów istniejących
* @return true w przypadku wstawienia unikalnego
*/
public static <E> boolean sortingInsert(E toInsert, List<E> list,
boolean allowReplace, Comparator<? super E> comparator)
{
int found = binarySearch(toInsert, list, comparator);
if(found < 0)
list.add(-found - 1, toInsert);
else if(allowReplace)
list.set(found, toInsert); //dozwolone zastępowania
else //dostawia element równy przed istniejący
{
list.add(found, toInsert);
return false;
}
return true;
}
private Lists() { }
}
Trochę tego dużo, ale wszystko pochodzi z działającego kodu, więc nie będę ciął, żeby czegoś nie pogubić.
Javadoc powinien być jasny, więc nie będę się dodatkowo produkował.
ps. Ups. Chyba to już po ptakach. Nie rzuciłem okiem na daty :)