ArrayList<ArrayList> sortieren - hilfe bei Comperator

[ne0n2005]

Hallo ,
ich schreibe gerade an einer ArrayList, welche mit ArrayListen des Typs Integer gefüllt wird. Das ganze sieht in etwa so aus:

private ArrayList<ArrayList>   list = new ArrayList<ArrayList>();
private ArrayList<Integer> innere = new ArrayList<Integer>();

Die von der ArrayList inner erstelle ich immer clone und hänge sie in die ArrayList list an.
Jetzt möchte ich gerne meine ArrayList list nach den jeweils letzten Wert der inneren Sortieren:

public int letzterWert(int index)  {
	ArrayList<Integer> innereList= list.get(index);
	int sizeInnereList= innereList.size();
	return innereList.get(sizeInnereList-1);
}

Ich bin schon darauf gestoßen das dies mit Collections.sort(liste, meinEigenerComperator);

Mein Problem ist jetzt jedoch meinEigenerComperator zu schreiben. Vielleicht bin ich auch auf dem ganz flaschen Dampfer fürs sortieren oder gar mit meiner verwaltung von Integer-Zahlen.

Ich hoffe man kann mein beschriebenes Problem überhaupt verstehen.
Schon einmal vielen dank fürs reinschauen und euch allen frohe Ostertage.

mfg neon

 

[AlexSpritze]

Ahoi,

ich vermute mal so könnte dein Komparator aussehen:

class MyComparator implements Comparator<List<Integer>> {
  public int compare( List<Integer> o1, List<Integer> o2 ) {
    // Noch prüfungen ob die listen null oder leer sind
    return o1.get(o1.size()-1).compareTo(o2.get(o2.size()-1));
  }
}

Der vergleicht zwei Listen anhand ihres letzten Wertes.

.. so prinzipiell sollte das aussehen, aber ich vermute, da gibt es Probleme mit den Generics?!

 

[ne0n2005]

Ja super, danke für deine schnelle antwort. Ich werds gleich mal ausprobieren, es sieht jedenfall schon recht gut aus, müsste so eigentlich passen.

 

[ne0n2005]

Irgendwie hat es leider dann doch nicht so geklappt wie ich mir das gedacht habe.
Wenn ich das richtig verstanden habe, müsste es ja in etwa wo aussehen:

public class MeinComperator implements Comparator<ArrayList<ArrayList<Integer>>>  {
	public int compare( ArrayList<ArrayList<Integer>> o1, ArrayList<ArrayList<Integer>> o2 ) {
		ArrayList<Integer> innere1 = o1.get(index_welchenIchnichtHabe);
		ArrayList<Integer> innere2 = o1.get(index_welchenIchnichtHabe);
		return innere1.get(innere1.size()-1).compareTo(innere2.get(innere2.size()-1));
	}
}

Jedoch habe ich hier das Problem mit dem Index. Das würde ja auch keine Sinn machen hier mit dem Iterator durchlaufen zu lassen denke ich mir.
Also brauche ich wohl nochmal eure hilfe, ich komme hier nicht ganz weiter.

 

[AlexSpritze]

Ahoi,

also der Index ist doch der vom letzten Item? Daher innere1.get(innere1.size()-1), damit kriegst du das letzte Element der Liste.

Hier mal ein Testprogramm:

import java.util.*;

public class NewClass {

  private ArrayList<ArrayList<Integer>> list = new ArrayList<ArrayList<Integer>>();
//  private ArrayList<Integer> innere = new ArrayList<Integer>(); // brauchst du die? list enthält ja die inneren Listen

  public NewClass() {
    fill();
    sort();
    print();
  }

  void fill() { // list befüllen
    ArrayList<Integer> _list = null;
    for (int i = 0; i < 10; i++) {
      _list = new ArrayList<Integer>();
      for (int j = 0; j < 10; j++) {
        _list.add(new Integer((int) (Math.random() * 100)));
      }
      this.list.add(_list);
    }
  }

  void sort() {
    Collections.sort(list, new MyComparator());
  }

  void print() { // Gibt die letzten Elemente der Listen in list aus
    for (ArrayList<Integer> _list : list) {
      System.out.println(_list.get(_list.size() - 1));
    }
  }

  public static void main( String[] args ) {
    new NewClass();
  }
}

class MyComparator implements Comparator<ArrayList<Integer>> {

  public int compare( ArrayList<Integer> o1, ArrayList<Integer> o2 ) {
    // o1 und o2 auf null prüfen
    Integer i1 = o1.get(o1.size() - 1);
    Integer i2 = o2.get(o2.size() - 1);
    return i1.compareTo(i2);
  }
}

 

[ne0n2005]

Aiaiaiaiai, jetzt hab ich meinen Fehler gefunden. Ich hatte

private ArrayList<ArrayList> list = new ArrayList<ArrayList>();

anstatt

private ArrayList<ArrayList<Integer>> list = new ArrayList<ArrayList<Integer>>();

,dann hatte er immer an der stelle mit dem Collections.sort(list, new MeinComparator()); gemeckert das der Comperaor nicht passend sei. Ich dachte er würde selber schauen welchen Typ die ArrayList´s haben, welche ich zur Liste "list" hinzufüge - dem schein jedoch nicht so.
Aber gut das mir der Fehler passiert ist, sonst hätte ich mich sicher nicht so ausfühlich damit beschäftigt.

Vielen dank auch nocheinmal für das Beispielprogramm. Und ja du hast recht, die Liste "innere" brauche ich nicht, ich dachte es sei bloß etwas verständlicher, wenn ich sie nocheinmal poste.

Frohe Ostern

 

[AlexSpritze]

Das Beispielprogramm hatte ich auch gemacht, um mir das selbst nochmal zu zeigen, war mir dann auch etwas unsicher mit dem Comparator
Frohe Ostern