# TreeMap sortieren über ArrayList als Value



## gondor (14. Feb 2006)

Hallo!

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. 

Wie kann ich das machen?

Vielen Dank,

gondor(..)


----------



## SlaterB (14. Feb 2006)

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


----------



## gondor (14. Feb 2006)

@SlaterB

die IDs brauch ich schon noch, da ich zu jeder ID die Eigenschaften mit ausgeben muss. 

Allerdings halt sortiert nach dem Namen...

gibt es etwas worauf man bei dem Comparator achten muss?

gondor(..)


----------



## SlaterB (14. Feb 2006)

dann also entrySet()

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


----------



## Guest (14. Feb 2006)

hm, jetzt habe ich das mal so gemacht (vereinfacht):


```
public class Test implements Comparator {
	
	TreeMap basket = null;

	public static void main(String[] args) {
		Test test = new Test();
		test.los();
	}

	public void los() {

		try {
			
			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(this);
			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);
			
		} catch (Exception i) {
			System.out.println(i.getMessage());
		}
	}

	public int compare(Object o1, Object o2) {
		ArrayList al1 = (ArrayList)(basket.get(o1));
		ArrayList al2 = (ArrayList)(basket.get(o2));
		return ((String)al1.get(1).toString()).compareTo( (String)al2.get(1).toString() );
	}

}
```

leider gibt es eine exception beim compare:


```
at java.util.TreeMap.getEntry(Unknown Source)
at java.util.TreeMap.get(Unknown Source)
at Test.compare(Test.java:92)
```

wo liegt hier der fehler?

gondor(..)


----------



## gondor (14. Feb 2006)

sry, nicht eingeloggt gewesen.


----------



## SlaterB (15. Feb 2006)

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


```
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:


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

}
```


----------



## bygones (15. Feb 2006)

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.

Dann einfach in eine TreeMap stecken....


----------



## gondor (16. Feb 2006)

@deathbyaclown

wie meinst du das? mir ist das 'konzept' noch nicht wirklich klar...

@SlaterB

danke für deine mühe.

gondor(..)


----------



## bygones (16. Feb 2006)

so mein ich das

```
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

```
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]


----------

