Tabelle Sortieren

Jhue89

Bekanntes Mitglied
Hallo Zusammen,

ich möchte eine Tabelle nach einem betimmtem Muster sortieren, leider bin ich mir nicht sicher wie ich das am besten anstelle.

nur um einmal zu erklären was ich genau vor habe.

Ich speicher mir Variablen Namen in einem .json file.

Wenn ich die Datei nach einem Programm Neustart lade möchte ich mir die Variablen Sortiert in einer Tabelle ausgeben lassen.

Die Variablen lade aus dem Json file lese ich mir über eine hashmap ein. Daher sind die ziemlich durcheinander.

Sorieren möchte ich wie folgt:

X
Y
Z
W
S
T
A
B
C
V1
V2
...
V50

Die normalen sortierfunktionen decken sowas natürlich nicht ab.
 

kneitzel

Top Contributor
Die Sortiermethoden im Framework unterstützen in der Regel entweder einen Comparator oder ein Comparable Interface. Damit kannst Du also in Deiner Klasse die Methode zum Vergleichen selbst individuell gestalten. Du kannst z.B. ein einfaches switch auf dem Anfangsbuchstaben haben um dann eine Gewichtung vorzunehmen. x=0, y=1, ... bei V werden die folgenden Ziffern gelesen und Wertung ist dann ein davon abgeleiteter Wert, z.B. 100+diesem Wert.
Am Ende vergleichst Du diesen Wert. Ist er unterschiedlich, dann folgt daraus schon die Reihenfolge. Wenn der Wert gleich ist, dann werden die Strings direkt verglichen.

Oder an welcher Stelle war dein Problem?
 

kneitzel

Top Contributor
Die Umsetzung ist relativ einfach. Schauen wir uns dazu einfach einmal die sort Methoden von der Klasse Collections an:

Da finden sich zwei Methoden:
1. sort(List<T>)
2. sort(List<T>, Comparator<? super T>)

Wenn wir uns die erste Methode anschauen, dann wird dort nach der natural order - also der natürlichen Reihenfolge - sortiert. Und der Link führt dann auch direkt zu Comparable<T>.

Wenn Du eine Klasse Xyz erstellst, dann kannst Du auch eine Sortierreihenfolge festlegen, die "natural order". Und alles was Du dau in der Klasse noch unterbringen musst, ist die compareTo(T) Methode:
Java:
public class Xyz implements Comparable<Xyz> {
    @Override
    public int compareTo(Xyz other) {
        // this mit other vergleichen und dann eine Zahl zurück geben.
    }
}

Das macht aber nur Sinn, wenn es für die Klasse eine natürliche Sortierreihenfolge gibt. Also Wenn Du Studenten hast, dann werden diese in der Regel nach Namen sortiert. Aber es kann ja auch noch andere Sortierungen geben. Jemand braucht eine Liste sortiert nach Matrikelnummer. Oder nach Geburtsdatum ... oder oder oder ....

Es kann aber nur eine natürliche Sortierreihenfolge geben. Aber dann kommt man zu der zweiten Methode:
Man gibt als weiteren Parameter etwas, das die Elemente vergleichen kann. Also ähnlich wie die compareTo Methode bei Comparable gibt es hier dann auch eine Methode, die zwei Elemente vergleicht:
compare(t o1, T o2)

Das ist halt immer hilfreich, wenn es keine natürliche Ordnung der Elemente gibt oder wenn die Klasse nicht im eigenen Zugriff ist und man die Instanzen der Klasse nun aber sortieren können möchte.
 

Flown

Administrator
Mitarbeiter
Ich hab das mal vor zig-Jahren mal gemacht:

Java:
final class PositionComparator<T extends Comparable<? super T>> implements Comparator<T> {

  private final Map<T, Integer> position;
  private final Integer notFound;

  private PositionComparator(Map<T, Integer> position) {
    this(position, -1);
  }

  private PositionComparator(Map<T, Integer> position, Integer notFound) {
    this.position = position;
    this.notFound = notFound;
  }

  @Override
  public int compare(T o1, T o2) {
    return position.getOrDefault(o1, notFound).compareTo(position.getOrDefault(o2, notFound));
  }

  public static <T extends Comparable<? super T>> Comparator<T> fromArray(T[] array) {
    Objects.requireNonNull(array);
    Map<T, Integer> positions = new HashMap<>();
    for (int i = 0; i < array.length; i++) {
      positions.put(array[i], i);
    }
    return new PositionComparator<>(positions);
  }
}

Aufruf sollte dann irgendwas mit:
Java:
List<String> strings = new ArrayList<>(Arrays.asList("X", "Y", "Z", "W", "S", "T", "A", "B", "C"));
for (int i = 0; i < 50; i++) {
  strings.add("V" + (i + 1));
}
Comparator<String> comparator = PositionComparator.fromArray(strings.toArray(String[]::new));
 

Jhue89

Bekanntes Mitglied
Ich hab mich jetzt mal versucht ein bisschen einzulesen, aber ich komm irgendwie überhaupt ncht klar.

Ich versuche grade das Beispiel von Flown zu testen und zu verstehen.

leider kann ich das nicht testen, weil ich fehlermeldungen zurück bekomme.

Java:
Comparator<String> comparator = PositionComparator.fromArray(strings.toArray(String[]::new));

Java:
.toArray(String[]::new));
dieser Teil wird Rot unterstrichen

The method toArray(T[]) in the type List<String> is not applicable for the arguments (String[]::new)

sagt bitte nicht das es an der java version liegt.
 

Jw456

Top Contributor
Benuze zum Test mal nicht asList sondern eine ArrayList .



 
Zuletzt bearbeitet:

kneitzel

Top Contributor
Die Methode toArray erwartet ein Array, das dann gefüllt wird. Also statt String[]::new sollte es da new String[strings.size()] heißen.
 

kneitzel

Top Contributor
Also die Sache gibt es schon seit Java 11 (jetzt ist gerade Java 17 LTS da)
Jo, aber dennoch arbeiten einige immer noch mit dem Java 8 (leider).

Das ist eine Referenz auf den Konstruktor eines String-Arrays als Spezialfall einer Methodenreferenz. Vereinfach gesagt lassen sich damit bereits existierende Methoden herumreichen.
Und um das letzte Stück des Weges zu vervollständigen: Collection hat auch eine toArray Methode bekommen und die sieht so aus:
toArray(IntFunction<T[]> generator)

IntFunction<T[]> ist ein funktionales Interface, das eine Methode (apply) erwartet, die als Parameter ein int entgegen nimmt und ein T[] zurück gibt (T ist ein Generic und wird dann in der Anwendung durch einen konkreten Typ ersetzt - hier String).

Und String[] hat ein Konstruktor, der ein int (die Größe) entgegen nimmt.

Funktionale Interfaces kann man auf diverse Arten als Parameter nutzen:
a) Es wird eine Instanz übergeben, die dieses Interface implementiert (Klar, das geht mit jedem Interface also auch mit funktionalen).
b) Lambda Expression
c) Methodenreferenz
 

kneitzel

Top Contributor
Ich nehme an, wenn man neu mit Java beginnt, fängt man nicht mit Java 1.4 an oder? Sondern nimmt das neueste oder neueste LTS.
Die Erfahrung hier im Forum zeigt leider, dass dies zu einem nicht unerheblichen Teil eben nicht so ist.

Ein Beispiel findest Du hier im Thread, denn der TE scheint in die Gruppe derer zu gehören, die mit Java anfangen und dennoch nicht das aktuelle Java verwenden.

Ansonsten verstehe ich nicht, wieso Du plötzlich mit Java 1.4 ankommst. Java 8 ist immer noch eine LTS Version, die supportet wird. Daher spricht nichts gegen die Nutzung dieser Version und dies fällt wohl eher in den Bereich Polemik. Aber das müssen wir in keiner Weise vertiefen, denn unabhängig von unseren Sichtweisen: Die Realität verändern wir nur in sehr engen Bereichen.
 

Jhue89

Bekanntes Mitglied
Die Erfahrung hier im Forum zeigt leider, dass dies zu einem nicht unerheblichen Teil eben nicht so ist.

Ein Beispiel findest Du hier im Thread, denn der TE scheint in die Gruppe derer zu gehören, die mit Java anfangen und dennoch nicht das aktuelle Java verwenden.

Ansonsten verstehe ich nicht, wieso Du plötzlich mit Java 1.4 ankommst. Java 8 ist immer noch eine LTS Version, die supportet wird. Daher spricht nichts gegen die Nutzung dieser Version und dies fällt wohl eher in den Bereich Polemik. Aber das müssen wir in keiner Weise vertiefen, denn unabhängig von unseren Sichtweisen: Die Realität verändern wir nur in sehr engen Bereichen.
Das Programm an dem ich arbeite ist seinerzeit noch mit Java 7 erstellt worden. Ich bin schon rauf auf Java 8. Gerstern hatte ich noch eine Thread in dem ich Probleme mit der Java version hatte / habe. Leider haben nicht alle Rechner auf dem das verwendet werden soll aktuellere Versionen.
 

Jhue89

Bekanntes Mitglied
So nochmal zurück zum Thema.

ich hab das jetzt mal ausprobiert. Aber das funktioniert nicht.
Also ich hab ja jetzt schon einiges mit Java gemacht aber diese Comparator Geschichte bekomme ich einfach nicht in meinen Kopf.
Leider verwirrt mich das Internet nur nochmehr.
Ich hab jetzt mal ein kleines Testprogramm gemacht. Ich hoffe dadurch verstehe ich das ein bisschen besser.

Ich stell das mal hier rein. Villeicht findet ja einer Zeit und erklärt mir das.

In diesem Projekt habe ich zwei Aufgabenstellungen

als erstes die Sortierung der Liste "strings"
als zweites die Liste "VarListe" vom typ FixVariables
 

Anhänge

  • FixVariables.java
    1 KB · Aufrufe: 1
  • SettingsBD.java
    6,2 KB · Aufrufe: 0
  • SortierungTEst.java
    1,7 KB · Aufrufe: 0

kneitzel

Top Contributor
Im Augenblick muss ich sagen, dass ich absolut nicht verstehe, was Du da machen willst. Daher einfach erst einmal ein paar "Formalismen", die uns auf jedem Fall helfen, dir zu helfen und die Dir vermutlich auch die Software Entwicklung erleichtern.

Wenn Du so ein "kleines Testprogramm" machst, dann mach ein minimales Beispiel. SettingsBD ist extrem gross und unübersichtlich. Und für den Test brauchst Du ausschließlich:

Java:
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

public class SettingsBD implements Serializable {

    private static final long serialVersionUID = -6412864940716820763L;
    private List<FixVariables> VarListe = new ArrayList<FixVariables>();

    public List<FixVariables> getVarListe() {
        return VarListe;
    }
}
(Wobei das noch zuviel ist. Brauchst ja keine Serialisierung in dem Programm. Aber egal ...)

Das Gleiche gilt bei FixVariables:
Java:
import java.io.Serializable;

public class FixVariables implements Serializable {
    private static final long serialVersionUID = -3954448839321798129L;
    private String Name =null;
    public String getName() {
        return Name;
    }

    public void setName(String name) {
        Name = name;
    }
}

Schon sind zwei Klassen absolut minimiert worden. Wobei für den Test auch die SettingsBD weg könnten...

Aber dann gleich weitere Hinweise:
- Naming Conventions -> Variablen fangen mit einem kleinen Buchstaben an!
- Einrückung in der Test-Klasse: Ich hoffe, dass es nur irgend welche Einstellungen sind und dass der Code bei Dir richtig Eingerückt war.


Und nach diesen Formalismen: Was genau wolltest Du denn nun testen? Da ist nicht Comparator oder Compareable in Deinem Code.
Du sortierst auch nur Deine List<String>.

Daher wäre meine erste Frage: Was von dem, das Dir gesagt wurde, hast Du da jetzt testen wollen?
 

Jhue89

Bekanntes Mitglied
Ok, ich hab die den code auch mal kleiner gemacht.

Zum Thema Naming Conventions da werde ich verstärkt drauf achten.
Der Code ist bei mir vernünfitg eingerückt

Also haupt thema ist ja das ich eine Tabelle nach dem oben genannten schema sortieren möchte. Die Tabelle greift auf die FixVariablen zu.

Da wurde ja gesagt das ich dazu einen Comperator werden kann.

Um die ganze sache aber im Grundsatz zu verstehen wollte ich erstmal mit einer einfachen ListString anfangen.

So wie ich das vertanden habe kann ich hier
Java:
strings.sort(null);
einen comperator übergeben.

Und ab da komme ich nicht mehr klar.

1. Wo muss ich den Comperator anlegen? Muss ich dafür eine eigene Klasse erstellen oder mach ich das in der Main Methode?
 

kneitzel

Top Contributor
1. Wo muss ich den Comperator anlegen? Muss ich dafür eine eigene Klasse erstellen oder mach ich das in der Main Methode?
Du kannst ihn beliebig anlegen. Comparator ist ein funktionales Interface, daher kannst Du z.B. die üblichen Wege nehmen:
a) Klasse vom Interface ableiten:
Java:
import java.util.Comparator;

public class MyComparator implements Comparator<String> {
    @Override
    public int compare(String o1, String o2) {
        // Hier wäre der Vergleich irgendwie zu implementieren.
        return o1.compareTo(o2);
    }
}

Oder als Anonyme Klasse innerhalb deines Codes z.B. (Wovon ich generell abrate, da es den Code unnötig aufbläht:
Java:
        Comparator<String> myComparator = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        };

b) Lambda Expressions. Da wird die Methode, die implementiert werden soll, genommen und nur die Parameter betrachtet und mit -> dann die Implementation angehängt (Ganz stark vereinfacht ausgedrückt):
Java:
        Comparator<String> myComparator = (o1, o2) -> o1.compareTo(o2);

c) Die letzte Methode ist dann die Methoden-Referenz. Eine beliebige Methode, die die gleichen Parameter und Rückgabe hat, kann dann genommen werden, also int irgendEinName(String, String):
Java:
public class MyClass {
    public static int compareMyStrings(String o1, String o2) {
        return o1.compareTo(o2);
    }

    public void someOtherMethod() {
        ...
        Comparator<String> myComparator = MyClass::compareMyStrings;
        ...
    }
}

In den Beispielen wurde jetzt immer eine Instanz von Comparator erzeugt. Das kann man natürlich auch direkt angeben, also bei Dir z.B.:
strings.sort( (o1,o2) -> o1.compareTo(o2) );

Und dann gibt es natürlich einige fertige Implementierungen, die man nutzen kann.
 

Jhue89

Bekanntes Mitglied
Also ich würde den weg mit der eigenen Klasse gehen wollen. Ich denke das ist am übersichtlichsten für mich.

Ich habe mir jetzt eine Klasse MyComperator erstellt.

Java:
MyComperator comp = new MyComperator();           
    strings.sort(comp);
    System.out.println("Strings : " + strings);

Soweit so gut.

Jetzt muss ich dem Comperator noch mitteilen wie die neue Sortierung aussehen soll.
Das mache ich dann in compare und gebe dann einen int zurück damit er weiss wo er das einreihen muss oder?

zurückgeben muss ich 0, 1, oder -1.
 

kneitzel

Top Contributor
Du vergleichst die zwei Parameter. Soll der erste vor dem zweiten kommen, dann gibst Du eine negative Zahl (z.B. -1) zurück. Haben sie die gleiche Position, dann 0 und ansonsten eine positive Zahl (z.B. die 1).

Evtl. einfach eine Denkbrücke: bei Integern hast Du dann sozusagen einfach a-b als Ergebnis. (Das ist keine gültige Implementierung, da es zu Überläufen kommen kann. Aber zum merken reicht es evtl.)

Oder aus der Doku ganz offiziell:
Returns:
a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.
 

Jhue89

Bekanntes Mitglied
Jetzt bin ich am verzweifeln. das System habe ich soweit verstanden. Aber ich habe noch keine Logik gefunden wie ich die oben genannete Sortierung durchführen kann.

Am schwierigsten ist es für mich eine Logik zu finden das folgendes dabei rauskommt [X, Y, Z, W, S, T, A, B, C, B1-B100, V1-V49]

Kann mir einer Helfen?
 

Jhue89

Bekanntes Mitglied
Also abschließend wäre [X, Y, Z, W, S, T, A, B, C, V1-V100], B1-B100 war nur beispielhaft um das System zu verstehen
 

kneitzel

Top Contributor
Also wenn nur diese Elemente vorkommen können (und es nicht wie ich in der ersten Antwort dachte es nur Anfänge wären), dann hast Du doch in #6 schon eine fertige Lösung bekommen. Der PositionComparator sollte so wie er geschrieben wurde, funktionieren. Wie der PositionComparator erzeugt werden kann, wurde auch aufgezeigt. Lediglich die Verwendung zum sortieren würde dann fehlen, aber das hast Du ja schon begriffen.

Somit musst Du das doch nur den MyComparator durch den PositionComparator ersetzen:

Java:
    MyComperator comp = new MyComperator();          
    strings.sort(comp);
    System.out.println("Strings : " + strings);

wird dann zu:
Java:
        List<String> strings = new ArrayList<>(Arrays.asList("X", "Y", "Z", "W", "S", "T", "A", "B", "C"));
        for (int i = 0; i < 50; i++) {
            strings.add("V" + (i + 1));
        }
        Comparator<String> comparator = PositionComparator.fromArray(strings.toArray(String[]::new));
        strings.sort(comparator);
        System.out.println("Strings : " + strings);
 

Jhue89

Bekanntes Mitglied
Also wenn nur diese Elemente vorkommen können (und es nicht wie ich in der ersten Antwort dachte es nur Anfänge wären), dann hast Du doch in #6 schon eine fertige Lösung bekommen. Der PositionComparator sollte so wie er geschrieben wurde, funktionieren. Wie der PositionComparator erzeugt werden kann, wurde auch aufgezeigt. Lediglich die Verwendung zum sortieren würde dann fehlen, aber das hast Du ja schon begriffen.

Somit musst Du das doch nur den MyComparator durch den PositionComparator ersetzen:

Java:
    MyComperator comp = new MyComperator();         
    strings.sort(comp);
    System.out.println("Strings : " + strings);

wird dann zu:
Java:
        List<String> strings = new ArrayList<>(Arrays.asList("X", "Y", "Z", "W", "S", "T", "A", "B", "C"));
        for (int i = 0; i < 50; i++) {
            strings.add("V" + (i + 1));
        }
        Comparator<String> comparator = PositionComparator.fromArray(strings.toArray(String[]::new));
        strings.sort(comparator);
        System.out.println("Strings : " + strings);

Jein.... Mein Problem ist die Sortierung der Buchstaben X-C

So wie ich das sehe werden die ja so fest in die Liste reingeschrieben.

Die Liste die ich bearbeite schnappt sich von Verschieden stellen die Werte daher ist das alles ziemlich durcheinander.

Somit sieht die Liste dann immer unterschiedlich aus. z.b [V1, V20, X, V13, C, Z, V25, Y].
Sortiert würde die Liste dann ja so aussehen [ X, Y, Z, C, V1, V13, V20, V25]

Die V Variablen würden ja funktionieren aber wie bekomme ich X Y Z und C Sortiert?

Oder ich verstehe das Programm nicht... das ist natürlich auch möglich.:rolleyes:
 

mihe7

Top Contributor
Hast Du den Code schonmal ausprobiert?

Code:
jshell> List<String> list = new ArrayList<>(List.of("V1", "V20", "X", "V13", "C", "Z", "V25", "Y"));
list ==> [V1, V20, X, V13, C, Z, V25, Y]

jshell> Collections.sort(list, comparator)

jshell> list
list ==> [X, Y, Z, C, V1, V13, V20, V25]
 

kneitzel

Top Contributor
Nur um es richtig zu verstehen: Du hast eine feste Menge an Werten:
"X", "Y", "Z", "W", "S", "T", "A", "B", "C", "V1", ..., "V50"
und die sind in genau dieser Reihenfolge zu sortieren.

Nun bekommst Du eine Liste mit Strings, wobei die Strings alle aus dieser Menge kommen.


Und ich sehe jetzt gerade ein Problem, dass Dich evtl. verwirrt und das entstanden ist, weil ich zu schnell im Forum zwei Codes zusammen gefügt habe: In beiden Codes wurde die Variable strings verwendet. Das müssen natürlich zwei unterschiedliche Variablen sein. In Zeile 1 wurde eine Liste mit allen gültigen Strings in der richtigen Reihenfolge angelegt und in Zeile 6 sollte eine List mit Werten (nicht die Variable aus Zeile 1!) sortiert werden!

Mach in Zeile 6 aus dem strings ein values. Und damit es deutlicher wird, dass der Code so wie er da ist, fix ist, packen wir es in eine Methode:
Java:
public void complexSort(List<String> values) {
        List<String> strings = new ArrayList<>(Arrays.asList("X", "Y", "Z", "W", "S", "T", "A", "B", "C"));
        for (int i = 0; i < 50; i++) {
            strings.add("V" + (i + 1));
        }
        Comparator<String> comparator = PositionComparator.fromArray(strings.toArray(String[]::new));
        values.sort(comparator);
}
Dann ist jetzt einfach ein sort(strings) aufrufbar.

Oder noch besser:
Java:
    public Comparator<String> getComparator() {
        List<String> strings = new ArrayList<>(Arrays.asList("X", "Y", "Z", "W", "S", "T", "A", "B", "C"));
        for (int i = 0; i < 50; i++) {
            strings.add("V" + (i + 1));
        }
        return comparator = PositionComparator.fromArray(strings.toArray(String[]::new));
    }

Dann hast Du jetzt ein beliebiges List<String> mit Deinen Werten, die Du sortieren kannst:
myValues.sort(getCompator());
 

Jhue89

Bekanntes Mitglied
Nur um es richtig zu verstehen: Du hast eine feste Menge an Werten:
"X", "Y", "Z", "W", "S", "T", "A", "B", "C", "V1", ..., "V50"
und die sind in genau dieser Reihenfolge zu sortieren.

Also ich habe in einer json Datei ein Objekt "Parameter" in dem Verschiedene Variablen stehten.
Es gibt aber viele unterschiedliche Dateien deswegen sind die Parameter auch unterschiedlich. Diese Parameter lese ich über eine Hashmap aus und schreibe Sie in eine Tabelle. In der Tabelle möchte ich die dann aber das genannte Sortierschema haben.
Welche Varibalen aus dem JsonFile kommen weiss ich nicht. Ich weiss nur es könnten "X", "Y", "Z", "W", "S", "T", "A", "B", "C", "V1", ..., "V50" vorhanden sein.
Mit der Hashmap werden die Variablen ja auch nicht unbedingt nach der Reihenfolge in der Datei eingelesen.

Nachtrag: Es gibt übrigens viele Stellen in meinem Programm in dem ich das Sortierschema brauche. Es ist nicht nur auf das jsonfile beschränkt.
Ich dachte nur damit ist das grundsätzliche Problem leichter zu verstehen.
 

Jhue89

Bekanntes Mitglied
Hast Du den Code schonmal ausprobiert?

Code:
jshell> List<String> list = new ArrayList<>(List.of("V1", "V20", "X", "V13", "C", "Z", "V25", "Y"));
list ==> [V1, V20, X, V13, C, Z, V25, Y]

jshell> Collections.sort(list, comparator)

jshell> list
list ==> [X, Y, Z, C, V1, V13, V20, V25]
Nein den habe ich noch nicht. mach ich aber gleich mal.
 

Jhue89

Bekanntes Mitglied
Hast Du den Code schonmal ausprobiert?

Code:
jshell> List<String> list = new ArrayList<>(List.of("V1", "V20", "X", "V13", "C", "Z", "V25", "Y"));
list ==> [V1, V20, X, V13, C, Z, V25, Y]

jshell> Collections.sort(list, comparator)

jshell> list
list ==> [X, Y, Z, C, V1, V13, V20, V25]

Den Code kann ich nicht testen "List.of" ist ein Java 9 element... 🙈 ich hab doch erst Java 8
 

Jhue89

Bekanntes Mitglied
so der Code von Knitzel hat schonmal funktioniert. Danke. Jetzt hab ich auch kapiert warum das vorher nicht ging. Tatschlich hat mich das fehlende Value verwirrt.
 

Neumi5694

Top Contributor
Ist das nicht ein wenig verfrüht? :p
Nuja, gerade ältere Software verwendet of noch Sun-Libraries, die in den neuen kostenlosen JDKs nicht mehr verfügbar sind.
Wenn man das Ganze ohne all zu großen Aufwand portieren kann, sollte man natürlich zu einer neueren greifen, aber wenn der Aufwand hoch ist und es nicht notwendig ist zu wechseln, spricht nichts dagegen, die noch kostenlose JDK/JRE 1.8_u201 zu verwenden.
 

Jhue89

Bekanntes Mitglied
Also das Funktioniert ja schonmal ganz gut.

Was muss ich machen wenn ich das auf einer Tabelle anwenden will.
Was ich bisher gelesen habe muss ich einen RowSorter verwenden.
Aber ich bin mir nicht ganz sicher wie ich die beiden zusammenbringe
 

Jhue89

Bekanntes Mitglied
Wie bereits gesagt klappt die Sortierung, aber jetzt bin ich auf ein paar weiter hindernisse gestoßen.

1. Ich muss für meine Tabelle immer einmal die Spalte anklicken, damit die Sortierung stattfindet.

2. Wenn ich die Tabelle umsortiere wandern leere Zeilen nach oben.

Benutzt habe ich das habe ich das DefaultTableModel.
 

Jhue89

Bekanntes Mitglied
Zu 2 sobald ich die Methode aufrufe ich habe im Comparator ein .add(null) und ein .add("") hinzugefügt damit er leere nach hinten stellt. aber das ist vermutlich falsch. In Tablesorter habe ich schonmal ein bisschen was ausprobiert.

Zu 1 die Sortierung soll stattfinden wenn ich die Methoden aufrufe.

Java:
public class userSort {

    
     public static Comparator<String> getComparator() {
            List<String> values = new ArrayList<>(Arrays.asList(
                    "X", "Y", "Z", "W", "S", "T", "A", "B", "C",
                    "TH","FK",
                    "D","E","F","G","H","I","J","K","L","M","N",
                    "O","P","Q","R","U",
                    "MASTER_X","MASTER_Y","MASTER_Z","MASTER_W","MASTER_S","MASTER_T","MASTER_A","MASTER_B","MASTER_C"));
            for (int i = 0; i < 50; i++) {
                values.add("MASTER_V" + (i + 1));
                
            }
            for (int i = 0; i < 50; i++) {
                 values.add("V" + (i+1));               
            }
           values.add("");
           values.add(null);
            return PositionComparator.fromArray(values.toArray(new String[values.size()]));
        }
    
     public static void TableSorter(JTable table)
     {
        TableRowSorter<TableModel> sorter = new TableRowSorter<TableModel>();
         table.setRowSorter(sorter);
         sorter.setModel(table.getModel());
        
        
         sorter.setComparator(0, getComparator());
         sorter.toggleSortOrder(0);
         table.removeAll();
         table.setModel(sorter.getModel());
        
         table.updateUI();
     }
}
 

Neumi5694

Top Contributor
Komparator
Java:
//wie du isEmpty implementierst, überlass ich dir
        if(isEmpty(a1)) {
            if (isEmpty(a2)) {
                return 0;
            } else {
                return -1;
            }
        } else if (isEmpty(a2)) {
            return 1;
        } else {
            
        }

Ruf nach dem Setzen der Sortierreihenfolge mal sorter.sort() auf.
 

Jhue89

Bekanntes Mitglied
Du meinst bei mir im PositionComperatrator?
Denn hatte ich von oben übernommen und ich muss gestehen das ich davon nur die hälfte verstehe.

Java:
package Sort;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

final class PositionComparator<T extends Comparable<? super T>> implements Comparator<T> {

  private final Map<T, Integer> position;
  private final Integer notFound;

  private PositionComparator(Map<T, Integer> position) {
    this(position, -1);
  }

  private PositionComparator(Map<T, Integer> position, Integer notFound) {
    this.position = position;
    this.notFound = notFound;
  }

  @Override
  public int compare(T o1, T o2) {
    return position.getOrDefault(o1, notFound).compareTo(position.getOrDefault(o2, notFound));
  }

  public static <T extends Comparable<? super T>> Comparator<T> fromArray(T[] array) {
    Objects.requireNonNull(array);
    Map<T, Integer> positions = new HashMap<>();
    for (int i = 0; i < array.length; i++) {
      positions.put(array[i], i);
    }
    return new PositionComparator<>(positions);
  }
}
 

Neumi5694

Top Contributor
Ein Komparator vergleicht zwei Dinge, entscheidet, ob das zweite Ding weiter hinten stehen soll, weiter vorne oder ob die beiden gleichwertig sind, was die Reihenfolge angeht.
Das hier ist dein PositionComparator:
Java:
  public int compare(T o1, T o2) {
    return position.getOrDefault(o1, notFound).compareTo(position.getOrDefault(o2, notFound));
  }
getOrDefault greift den Wert aus der Map mit Key o1, bzwo2 ab. Die Methode vergleicht die beiden Werte dann. Ist kein Wert vorhanden, wird der Inhalt von notFound für den Vergleich hergezogen.
Hier solltest du ansetzen. Vielleicht reicht's ja schon, für notFound einen hohen Wert zu wählen. Ansonsten programmier die Methode komplett um und mach schrittweise die Unterscheidungen, wie ich sie oben beschrieben habe.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
C Tabelle sortieren (evtl. setComparator) Java Basics - Anfänger-Themen 2
B 2D-Array (Tabelle) alphabetisch sortieren Java Basics - Anfänger-Themen 6
R Tabelle sortieren, Problem mit Double bzw. String-Werten Java Basics - Anfänger-Themen 5
I Array sortieren oder Tabelle sortieren ? Java Basics - Anfänger-Themen 2
S Erbitte Hilfe !! Tabelle sortieren funktioniert nicht Java Basics - Anfänger-Themen 3
Sonas814 ASCII-Tabelle Java Basics - Anfänger-Themen 2
J Jtable Eingabe nach Klick ausserhalb der Tabelle übernehmen Java Basics - Anfänger-Themen 6
J Autovervollständigung in einer Tabelle Java Basics - Anfänger-Themen 40
RudiRüssel maximale Anzahl von Schlüsseln in einer Hash Tabelle Java Basics - Anfänger-Themen 2
crrnogorka Letzte Zeile einer Tabelle "überschreibt" alle anderen Zeilen Java Basics - Anfänger-Themen 1
F Tabelle - Berechnung Rang Java Basics - Anfänger-Themen 2
N Tabelle schön in der Konsole ausgeben Java Basics - Anfänger-Themen 5
S Datenbank Tabelle eine Zeile an einer bestimmten Stelle einfügen Java Basics - Anfänger-Themen 2
D Tabelle in der Konsole Java Basics - Anfänger-Themen 3
H Meine Tabelle befüllen in .fxml Java Basics - Anfänger-Themen 16
B Import Tabelle - Struktur durch User einstellbar Java Basics - Anfänger-Themen 4
O Max Gewinn einer Tabelle Java Basics - Anfänger-Themen 12
D Apache POI Tabelle wechseln Java Basics - Anfänger-Themen 2
B Kann man eine Tabelle in Eclipse erzeugen und damit arbeiten? Java Basics - Anfänger-Themen 8
S Ich verstehe die RegEx Tabelle von Javadoc nicht so ganz Java Basics - Anfänger-Themen 3
krgewb ASCII-Tabelle Java Basics - Anfänger-Themen 12
BlueFox Tabelle in der Konsole ausgeben - Probleme Java Basics - Anfänger-Themen 1
V Operatoren Was will mir die Tabelle in meinem Lehrbuch sagen? (logische Operatoren) Java Basics - Anfänger-Themen 4
J Werte aus einer Tabelle übernehmen Java Basics - Anfänger-Themen 2
F Daten aus Excel-Tabelle in Java importieren Java Basics - Anfänger-Themen 15
W Befüllung einer Tabelle mit Checkbox, Trennung GUI und Model Java Basics - Anfänger-Themen 5
P ASCII-Tabelle Java Basics - Anfänger-Themen 5
T printf Daten aus der Tabelle in Excel übernehmen Java Basics - Anfänger-Themen 5
A Hash Tabelle Element suchen Java Basics - Anfänger-Themen 1
B Vererbung In offener Hash Tabelle einfügen Java Basics - Anfänger-Themen 4
M 1x1 Tabelle Abstände korrigieren Java Basics - Anfänger-Themen 2
P Wert aus Tabelle erhalten Java Basics - Anfänger-Themen 1
U Tabelle ändern und die Inhalte speichern Java Basics - Anfänger-Themen 9
I HTML Tabelle nur so lange erzeugen bis Höhe erreicht Java Basics - Anfänger-Themen 9
N Erste Schritte MySQL Tabelle in JList darstellen Java Basics - Anfänger-Themen 1
S Klassen Objekt- Tabelle / Dynamisches 2Dimensionales Array für Objekte Java Basics - Anfänger-Themen 6
H "Tabelle" Java Basics - Anfänger-Themen 4
B Tabelle mit Fremdschlüssel versehen Java Basics - Anfänger-Themen 0
M Primefaces tabelle bearbeiten Java Basics - Anfänger-Themen 4
M Tabelle aktualisieren (mal wieder) Java Basics - Anfänger-Themen 10
M Erste Schritte Tabelle aktualisieren (mal wieder) Java Basics - Anfänger-Themen 7
G JTable: Werte in Tabelle direkt ansprechen Java Basics - Anfänger-Themen 3
P Excel-Tabelle erstellen Java Basics - Anfänger-Themen 4
I Daten aus Arraylists in eine Tabelle übertragen Java Basics - Anfänger-Themen 2
B daten speichern in einer tabelle Java Basics - Anfänger-Themen 5
J Zuweisung/Tabelle Java Basics - Anfänger-Themen 6
M Werte aus Tabelle elegant zuordnen? Java Basics - Anfänger-Themen 2
D String aus txt in label für Tabelle einfügen Java Basics - Anfänger-Themen 8
S Abfragen wenn das ende einer Tabelle erreicht ist Java Basics - Anfänger-Themen 8
M Tabelle aktualisiert sich erst nach mausklick Java Basics - Anfänger-Themen 4
J Tabelle aus Website einlesen [nicht im Quellcode] Java Basics - Anfänger-Themen 6
J Tabelle aktuallisieren Java Basics - Anfänger-Themen 22
A Im Telefonbuch eine Tabelle ergänzen Java Basics - Anfänger-Themen 6
N Ergebnisse dynamisch in Tabelle schreiben Java Basics - Anfänger-Themen 3
F Werte aus Tabelle vergleichen/rechnen Java Basics - Anfänger-Themen 5
J Punkte hinzufügen Tabelle Java Basics - Anfänger-Themen 5
C CSV-Tabelle Java Basics - Anfänger-Themen 21
M nur 1 wert in tabelle Java Basics - Anfänger-Themen 3
M Kreuztabellenabfrage an Tabelle anfügen Java Basics - Anfänger-Themen 3
M Wert aus Tabelle lesen Java Basics - Anfänger-Themen 4
M Überschrift wird nicht angezeigt Tabelle Java Basics - Anfänger-Themen 2
O Tabelle Formatieren mit system.out.format Java Basics - Anfänger-Themen 11
M Tabelle mit Buttons Java Basics - Anfänger-Themen 24
M JSON Datensätze aus Website in Tabelle Java Basics - Anfänger-Themen 17
U Drag&Drop von Tabelle in Textfeld Java Basics - Anfänger-Themen 3
D Auf Objekt in Tabelle zugreifen Java Basics - Anfänger-Themen 4
D Eclipse und Visual Editor - erzeugen einer Tabelle Java Basics - Anfänger-Themen 8
Binary.Coder JTable bzw. Tabelle in bestimmte Form überführen Java Basics - Anfänger-Themen 5
D Inhalt der Spalten einer Tabelle addieren Java Basics - Anfänger-Themen 4
H JTable Überschrift der Tabelle wird nicht angezeigt Java Basics - Anfänger-Themen 5
F Aus Tabelle auslesen Java Basics - Anfänger-Themen 10
B Tabelle, Größe der Komponenten Java Basics - Anfänger-Themen 2
H ButtonGroup in Tabelle Java Basics - Anfänger-Themen 2
X Zeile in Tabelle kopieren und in andere einfügen Java Basics - Anfänger-Themen 6
X Arraylist in Tabelle Java Basics - Anfänger-Themen 18
M Tabelle mit immer sortiertem Inhalt Java Basics - Anfänger-Themen 5
R ASCII-Tabelle Java Basics - Anfänger-Themen 6
F Tabelle in anderer Klasse füllen Java Basics - Anfänger-Themen 9
Beckenbauer OOP Durch Komma getrennte Einträge in einem String in ein Array oder eine Tabelle schreiben Java Basics - Anfänger-Themen 4
M 2D-Array als Tabelle ausgeben ? Java Basics - Anfänger-Themen 6
M Konsole: Tabelle Ausgeben Java Basics - Anfänger-Themen 5
M Sortierte Tabelle in Datei schreiben Java Basics - Anfänger-Themen 5
A Leere Fläche einer Tabelle umfärben Java Basics - Anfänger-Themen 3
J Tabelle in Fenster anzeigen Java Basics - Anfänger-Themen 12
Z Array mit daten einer datenbankbefüllen und dies an eine tabelle geben Java Basics - Anfänger-Themen 6
M Einfügen von Daten in eine Tabelle Java Basics - Anfänger-Themen 9
J Java Ein mal Eins Tabelle Java Basics - Anfänger-Themen 11
G POI: Zelle aus einer Tabelle kopieren und in einr anderen einfügen Java Basics - Anfänger-Themen 5
J Feld in Tabelle suchen Java Basics - Anfänger-Themen 8
babel Datenbank Daten direkt an die Tabelle übergeben ohne Arrays Java Basics - Anfänger-Themen 9
T Programm startet nicht wg. Tabelle? Java Basics - Anfänger-Themen 19
R Moechte Tabelle ausschreiben auf der Konsole Java Basics - Anfänger-Themen 2
S Daten aus Tabelle auslesen Java Basics - Anfänger-Themen 5
J Datei auslesen und in Tabelle einfügen Java Basics - Anfänger-Themen 6
E Boolean wert innerhalb einer Tabelle ändern Java Basics - Anfänger-Themen 4
B zahlen verschieben tabelle Java Basics - Anfänger-Themen 2
P Zeilnumbruch vermeiden bei einer Tabelle *hilfe* Java Basics - Anfänger-Themen 11
M Daten in Tabelle setzen. Java Basics - Anfänger-Themen 6
T ASCII Tabelle darstellen Java Basics - Anfänger-Themen 7
G Tabelle änderungen Java Basics - Anfänger-Themen 48

Ähnliche Java Themen


Oben