Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
Ich habe eine TreeMap. Diese beinhaltet unterschiedliche ID's als Key.
Jeder ID ist als Value eine ArrayList zugeordnet. In der ArrayList sind verschiedene Eigenschaften zu
finden, die die ID besser beschreiben. Name, Wert, Delimter, ... usw. Nun möchte ich jedoch, dass mir
die TreeMap nach den Namen aus der ArrayList sortiert ausgegeben wird.
möchtest du die IDs dazu noch mitausgeben oder nur die Listen?
map.entrySet() oder map.values() liefert die ein Set von Map.Entrys oder ArrayListen,
diese kannst du in eine Liste tun und dann sortieren und dann ausgeben,
zum Sortieren brauchst du einen Comparator der die Reihenfolge von zwei Objeken angibt
das in eine Liste,
Comparator programmieren (siehe Tutorials/ Lehrbücher zu diesem Stichwort) der zwei Map.Entry-Objekte vergleicht,
dazu holt er sich die ArrayListen aus den Map.Entrys, dann die Namen aus den ArrayListen und dann die Namen vergleichen,
nicht allzu kompliziert,
einfach mal schlaumachen (Beispiele anschauen) und dann versuchen
das Posten eines Testprogrammes finde ich sehr löblich, danke,
---------
soso, du möchtest anscheinend dass die gesamte TreeMap nach dem Namen sortiert wird?
das ist eigentlich nicht vorgesehen, sortiert werden sollte doch wohl nach der Id,
nicht die Id nehmen und dann die ArrayList dazu herausnehmen und danach sortieren
warum nimmst du dann nicht den Namen als Key?,
alternativ ein neues Objekt (z.B. eine ArrayList bestehend aus Id + Name) als Key, dann könnte der Comparator was damit anfangen,
hier gehts schief weil die Compare-Operation nicht nur zum Sortieren sondern auch bei anderen Operationen
wie bereits dem Einfügen oder dem Auslesen der ArrayList benötigt wird (um einen neuen Key einzufügen/ einen Suchkey in der Map zu finden muss ja verglichen werden),
somit entsteht eine Rekursion, um Compare ausführen wird wieder Compare aufgerufen, darin wieder usw.,
es funktioniert in diesem Fall nur wenn du die ArrayList aus einer zweiten Datenstruktur liest, z. B. einer zweiten Map
Code:
import java.util.*;
public class Test implements Comparator {
TreeMap basket1 = null;
TreeMap basket2 = null;
public void los() {
ArrayList al_1 = new ArrayList();
al_1.add(0, "5112");
al_1.add(1, "Schrauben");
ArrayList al_2 = new ArrayList();
al_2.add(0, "5114");
al_2.add(1, "Computer");
ArrayList al_3 = new ArrayList();
al_3.add(0, "5111");
al_3.add(1, "Bild");
ArrayList al_4 = new ArrayList();
al_4.add(0, "5119");
al_4.add(1, "Natter");
ArrayList al_5 = new ArrayList();
al_5.add(0, "5100");
al_5.add(1, "Kleid");
basket1 = new TreeMap(this);
basket2 = new TreeMap();
put("5114", al_1);
put("5111", al_2);
put("5119", al_3);
put("5100", al_4);
put("5112", al_5);
System.out.println(basket1); // nach Name sortiert
System.out.println(basket2); // nach Id sortiert
}
public void put(String key, ArrayList value) {
// wichtig: erst in Map2, dann in Map1 einfügen..
basket2.put(key, value);
basket1.put(key, value);
}
public int compare(Object o1, Object o2) {
ArrayList al1 = (ArrayList) (basket2.get(o1));
ArrayList al2 = (ArrayList) (basket2.get(o2));
return al1.get(1).toString().compareTo(al2.get(1).toString());
}
public static void main(String[] args) {
Test test = new Test();
test.los();
}
}
ich könnte mir aber gut vorstellen dass es allgemein sehr bösartiger Stil ist,
dass ein Comparator zum Vergleich zweier Objekte in irgendwelchen Listen nachschaut,
ausgerechnet noch in einer direkt relevanten Datenstruktur,
man sollte doch eher direkt aus o1 und o2 die Schlüsse ziehen,
wie das aussehen könnte zeigt sich in einem Beispiel zu dem was ich die ganze Zeit vorgeschlagen hatte:
Code:
import java.util.*;
public class Test {
TreeMap basket = null;
public void los() {
ArrayList al_1 = new ArrayList();
al_1.add(0, "5112");
al_1.add(1, "Schrauben");
ArrayList al_2 = new ArrayList();
al_2.add(0, "5114");
al_2.add(1, "Computer");
ArrayList al_3 = new ArrayList();
al_3.add(0, "5111");
al_3.add(1, "Bild");
ArrayList al_4 = new ArrayList();
al_4.add(0, "5119");
al_4.add(1, "Natter");
ArrayList al_5 = new ArrayList();
al_5.add(0, "5100");
al_5.add(1, "Kleid");
basket = new TreeMap();
basket.put("5114", al_1);
basket.put("5111", al_2);
basket.put("5119", al_3);
basket.put("5100", al_4);
basket.put("5112", al_5);
System.out.println(basket); // nach Id sortiert
Set entries = basket.entrySet();
List list = new ArrayList(entries);
Collections.sort(list, new Comparator() {
public int compare(Object o1, Object o2) {
ArrayList al1 = (ArrayList) ((Map.Entry) o1).getValue();
ArrayList al2 = (ArrayList) ((Map.Entry) o2).getValue();
return al1.get(1).toString().compareTo(al2.get(1).toString());
}
});
System.out.println(list); // nach Name sortiert
}
public static void main(String[] args) {
Test test = new Test();
test.los();
}
}
mhm warum nicht ein eigenes Objekt erstellen (das dann Name und das andere z.b. speichert). Diese Klasse implementiert Comparable, in der du dann definierst wie sortiert werden soll.
public class Artikel implements Comparable<Artikel> {
private int nummer;
private String name;
public Artikel(int nr, String na) {
nummer = nr;
name = na;
}
// getter Methoden und was man sonst noch braucht
public int compareTo(Artikel a) {
return a.nummer - nummer; // sortieren nach der nummer
// oder
return a.name.compareTo(name); // sortieren nach name
}
}
dann im Programm
Code:
Map<Integer, Artikel> tm = new TreeMap<Integer, Artikel>();
tm.add(new Artikel("5112", "Schrauben"));
alternativ könnte man auch die nummer nicht in Artikel speichern, da du dies ja über das mapping der TreeMap bekommst[/code]