Hallo,

gibt es eine Möglichkeit in einer Arraylist nur bestimmte Zeilen zu sortieren. Also nur die Zeilen 3-5 oder so. Oder gibt es vielleicht die Möglichkeit mehrere Spalten zum Sortieren anzugeben. Also erst nachname dann Vorname dann Wohnort usw.

Bin bis jetzt soweit das ich mir eine Klasse geschrieben habee die abhängig von der gewünschten Spalte die gesamt Liste sortiert. möchte aber eben nach mehreren Spalten sortieren. Deswegen meine Idee erst die gesamte tabelle nach einer Spalte dann alle gleichen nach der 2. Spalte usw. Weiß aber nicht wie ich das realisieren soll Hatte schon überlegt die gleichen jeweils in eine ArrayList und das dann weitersortieren und dann wieder die gleichen in eine ArrayList und weitersortieren usw. Allerdings bräucthe die dafür 6 arraylisten und denke das das Speicherverschwendung ist.
Deswegen meine andere Idee erst die Arraylist nach dem Nachnamen soriteren mir den ersten und den letzten index merken und nur diese spalten dann nach vorname sortieren usw.

Habt ihr eine idee wie ich das ganze realiesieren kann?

Hier meine bisheriege sortierKlasse

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

class ArraySort implements Comparator<PjOv>{               public final static int LASTNAME   = 0;             public final static int FIRSTNAME   = 1;       public final static int SCHOOL= 2;             public final static int ADRESS= 3;       public final static int BIRTHDAY=4;               private int sortField;                                       public ArraySort(int sortField) {          this.sortField = sortField;       }         public int compare(PjOv pjOv1, PjOv pjOv2 )       {          int result = 0;          switch (sortField) {          case 0:             result = pjOv1.getLastname().compareTo(pjOv2.getLastname());             break;          case 1:             result = pjOv1.getFirstName().compareTo(pjOv2.getFirstName());             break;          case 2:             result = pjOv1.getSchool().getName().compareTo(pjOv2.getSchool().getName());             break;          case 3:              result = pjOv1.getAdress().getStreet().compareTo(pjOv2.getAdress().getStreet());             break;          case 4:             result =  result = pjOv1.getBirth().compareTo(pjOv2.getBirth());                   break;          default:             break;                    }          return result;       }          }

Hi,

wenn ich das richtig verstehe, möchtest du die Sortieralgorithmen selbst implementieren?
Die Idee mit dem erst nach Spalte 1 und dann nach spalte 2 sortieren ist schon nicht verkehrt. Das funktioniert, wenn du einen stabilen Sortieralgorithmus benutzt (z.b. Insertionsort, Bubblesort oder Mergesort). Wenn du erst nach Spalte 1 sortierst und dann nach Spalte 2 bleibt bei gleichen Elementen in Spalte 2 die Sortierung von Spalte 1 erhalten.
Was die "Beschränkung" des zu sortierenden Bereichs angeht, kannst du wenn ich mich nicht grad ganz vertue, bei allen diesen algos einfach nur nen Teilbereich sortieren. Würde sagen mal danach.

Grüße
Daniel

Hallo,

schau mal hier:

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69

/**  *  */ package de.tutorials;   import java.util.ArrayList; import java.util.Collections; import java.util.List;   /**  * @author Thomas.Darimont  *  */ public class MultiColumnSortExample {       /**      * @param args      */     public static void main(String[] args) {         List<Bubu> bubus = new ArrayList<Bubu>();         bubus.add(new Bubu("X",4,5));         bubus.add(new Bubu("X",4,3));         bubus.add(new Bubu("B",1,6));         bubus.add(new Bubu("A",1,6));         bubus.add(new Bubu("B",2,1));                 System.out.println(bubus);         Collections.sort(bubus);         System.out.println(bubus);             }           static class Bubu implements Comparable<Bubu>{           String a ;         int b;         int c;                 /**          * @param a          * @param b          * @param c          */         public Bubu(String a, int b, int c) {             super();             this.a = a;             this.b = b;             this.c = c;         }                 @Override         public String toString() {             return a +  " " + b + " " + c;         }           @Override         public int compareTo(Bubu other) {             int distance = a.compareTo(other.a);             if(distance == 0){                 distance = b - other.b;                 if(distance == 0){                     distance = c - other.c;                 }             }             return distance;         }     } }

In dem Beispiel sortiere ich erst nach a, dann nach b, dann nach c aufsteigend.
Gruß Tom