Methoden Zweidimensionales Array mit Arrays.sort sortieren?

[undercover]

Moin Leute,
mal eine Frage.
Ist es möglich mit der Methode Arrays.sort ein mehrdimensionales Array zu sortieren? Ganz genau nur die Einträge i zu sortieren ([j]) und j gänzlich außen vor zu lassen?
Ich habe eine MergeSort Methode die genau das macht , allerdings möchte ich wissen ob es mit der Arrays.sort geht.

Gruß

 

[stg]

Es ist nicht klar, was bei dir i und was j sein soll und was nun wie sortiert werden soll.
Ein zweidimensionales Array ist ein Array von Arrays. Dieses kannst du mit Arrays.sort und einem passendem Comparator sortieren.
Willst du hingegen die "einzelnen Arrays", sortieren, so kannst du in einer Schleife über das "äußere Array" laufen und dann jedes einzelne mit Arrays.sort sortieren.

 

[undercover]

Mein Fehler, habe etwas vergessen. Mein Array liegt in folgender Form vor :
String [][] array; zum Verständnis was ich meine ,String [j] array , i = 100 j = 2.
Das Array sieht z.B so aus :
Vor der Sortierung: Nach der Sortierung:
[.][Jeder]-----------------------[.][Jeder]
[Jeder][hat]--------------------[Jeder][hat]
[hat][viel]----------------------[Spass][obwohl]
[viel][Spass]-------------------[es][regnet]
[Spass][obwohl]---------------[hat][viel]
[obwohl][es]-------------------[obwohl][es]
[es][regnet]-------------------[regnet][.]
[regnet][.]--------------------[viel][Spass]

Die Sortierung soll sich nur um die i Einträge lexikografisch kümmern. Darf die j Einträge aber nicht ändern.
Geht das überhaupt ?
Ansonsten muss ich es anders lösen.
Eine Merge die es macht habe ich , wollte nur wissen ob es mit einer Methode geht.

 

[CSHW89]

Wenn ich es richtig verstanden habe: du willst das äußere Array sortieren anhand des i-ten Elements jedes inneren Arrays. Dann so (ungetestet):

Arrays.sort(array, (a1,a2) -> a1[ i ].compareTo(a2[ i ]))

 

[undercover]

Funktioniert so leider nicht. Er erzeigt zwei Arrays a1 [0] = {Jeder} [1] = {hat} ; a2 [0] = {.} [1] = {Jeder}.
Ich gucke mal ob ich das anders lösen kann.

 

[Xyz1]

Das geht so nicht, weder mit Arrays.sort noch mit Comparator.

Noch ne Anmerkung: wegfallen.

 

[undercover]

Das sollte keine Scherzfrage sein, es hat einen Sinn wieso das jeweils zweite Element unsortiert ist.
In der unsortierten Liste sieht man das jedes Wort einen Nachfolger hat z.b. der "." - "Jeder". Das ist ein Beispieltext, es kann auch sein das es 200 "." gibt die immer einen anderen Nachfolger haben.
Ich möchte das Array so sortieren das ich alle "." mit möglichen Nachfolgern habe um dann random einen Punkt zu nehmen mit einem zufälligen Nachfolger .
Deshalb ist es wichtig das das zweite Element immer an das erste gebunden ist und nicht vertauscht oder sortiert wird .

 

[Meniskusschaden]

@stg hat doch einen vernünftigen Vorschlag gemacht. Hast du das schon ausprobiert?

 

[Xyz1]

Ach so, das ist oben so schlecht formatiert, dass es für mich zufällig aussieht. also ist das irgenwie gekuppelt. Dann geht das natürlich --- andernfalls NICHT!

 

[mrBrown]

Vielleicht sollte @undercover noch mal klar machen, was er eigentlich will.

Die Lösung für das Problem, was ich und auch andere da raus lesen, steht schließlich schon da^^

 

[undercover]

^^ pardon , manchmal ist es schwer eine Korrekte Frage zu formulieren , wenn man es nicht besser beschreiben kann
@Meniskusschaden, habe ich leider ohne Erfolg , werde es Morgen erneut in Angriff nehmen. Iwi muss es ja klappen das lediglich die Spalte lexikografisch sortiert wird ohne die Zeilen [j] zu verändern, sodass es am Ende ungefähr so ausschaut:
Bsp.
[.][Ende]
[.][Anfang]
[Anfang][war]
[Anfang][ist]
[bereit][gewesen]

Gruß , vielen Dank für die Unterstützung

 

[mrBrown]

^^ pardon , manchmal ist es schwer eine Korrekte Frage zu formulieren , wenn man es nicht besser beschreiben kann

Es würde schon deutlich leichter sein, wenn du statt deiner Array-Schreibweise eine gebräuchliche nutzt.

Dein Beispielarray entspricht vermutlich diesem: {{".","Ende"},{".","Anfang"},{"Anfang","war"},{"Anfang","ist"},{"bereit","gewesen"}} ?

Das kann man ganz wunderbar nach dem jeweils erstem String sortieren: Arrays.sort(array, (a1,a2) -> a1[ 0 ].compareTo(a2[ 0 ]));
Die inneren Arrays werden dabei nicht verändert

 

[undercover]

@mrBrown
genau so meinte ich es, danke für den Hinweis , ist fürs nächste mal abgespeichert.
Ich hatte einen Fehler @CSHW89 hatte es ebenso beschrieben, habe für i nur die länge des Arrays angegeben, aus dem Grund , das mir diese Schreibweise nicht bekannt ist. Handelt es sich dabei um einen Lambda Expression? Könntest du kurz erleutern was hier "Arrays.sort(array, (a1,a2) -> a1[ 0 ].compareTo(a2[ 0 ]));" passiert ?

Vielen Dank für die schnelle Antwort, ich bin echt begeistert, tolle community

 

[undercover]

Könnte man anhand des erstellten mehrdimensionalen Arrays eine binäre Suche durchführen, die wieder nur das äußere Array durchsucht und einen int index liefert der die Anzahl der Vorkommen zeigt?
Als Beispiel int index = 3; (da drei mal der Punkt im äußeren Array vorkommt?).
Dazu müsste ja das erste und letzte Vorkommen ermittelt, ein Array erstellt und die länge des Array ausgegeben werden.

 

[Flown]

@undercover Kannst du bitte mal die ganze Aufgabenstellung hier posten?

 

[undercover]

@Flown
Die Aufgabe war es , aus einem Text die Wörter heraus zu lesen und zu jedem Wort die möglichen Nachfolger zu speichern. Als Beispiel in einem Text gibt es 200 x ".", die Punkte werden als Wörter gepeichert und dazu die Wörter als Nachfolger die darauf folgen.
Am Ende soll ein Zufallstext erstellt werden , indem man ein Wort sucht und einen zufälligen Nachfolger ausgibt , im nächsten Durchlauf ist dann das Wort = Nachfolger usw. Es wird also ein Zufallstext generiert.
Ich hatte das ganze schon gelöst indem ich ein mehrdimensionales Array erstellt habe, und es dann sortiert habe (MergeSort). Als es sortiert war, habe ich es per binäre Suche durchsucht und erstes und letztes Vorkommen des Wortes in einem Array gespeichert. Per Array.length habe ich random einen Wert genommen und so einen zufälligen Nachfolger raussuchen.

Ich wollte dies jetzt mit den gegebenen Klassen von util probieren.
Das sortieren konnte hier schon gelöset werden, leider klappt die binarySearch nicht, da man kein erstes und letztes Vorkommen suchen kann.
Muss also etwas anderes finden.

 

[mrBrown]

Arrays sind da aber nicht grad sinnvolle Datenstrukturen für...

Hast du dir mal (Hash)Map und (Array)List angeguckt?

 

[undercover]

@mrBrown
Ist mir auch aufgefallen als ich zur util binarySearch gekommen bin ^^ da funktioniert leider kein mehrdimensionales Array . ArrayList , HashMap und Tree...schau ich mir jetzt mal an .
Danke für eure Mühe wieder ein Stück dazu gelernt.

 

[mrBrown]

Dann ist doch das benutzen von

Ist mir auch aufgefallen als ich zur util binarySearch gekommen bin ^^ da funktioniert leider kein mehrdimensionales Array

Doch, das würde auch funktionieren.
Maps und Listen sind aber der deutlich bessere Weg

 

[undercover]

Wie kann ich den das erste und das letzte Vorkommen eines Strings bestimmen ohne eine eigene binarySearch zu schreiben ?

 

[mrBrown]

Indem du die vorhandene Binary-Search nutzt?

int r = Arrays.binarySearch(array, new String[]{"."}, (a1, a2) -> a1[0].compareTo(a2[0]));

new String[]{"."} deshalb, weil du ein Array von String[] hast, du kannst also auch nur nach Arrays suchen, "." ist dabei das Wort, was du suchst.
Der Comparator ist der gleiche, der auch zum sortieren benutzt wurde.

 

[Flown]

Guck mal hier wie ich sowas lösen würde (etwas vereinfacht noch):

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Test {
  
  public static void main(String... args) {
    System.out.println(generateRandomTextFrom("Jeder hat viel Spass obwohl es regnet."));
  }
  
  public static String generateRandomTextFrom(String text) {
    Map<String, List<String>> possibilities = computePossibilities(text);
    StringBuilder builder = new StringBuilder();
    for (String word = getRandom(possibilities.get(".")); !"."
        .equals(word); word = getRandom(possibilities.get(word))) {
      if (builder.length() != 0) {
        builder.append(' ');
      }
      builder.append(word);
    }
    return builder.append('.').toString();
  }
  
  private static String getRandom(List<String> words) {
    return words.get((int) (Math.random() * words.size()));
  }
  
  private static Map<String, List<String>> computePossibilities(String text) {
    String last = ".";
    Map<String, List<String>> possibilities = new HashMap<>();
    for (String word : text.split("((?<=\\.)|(?=\\.)|\\s+)")) {
      possibilities.computeIfAbsent(last, s -> new ArrayList<>()).add(word);
      last = word;
    }
    return possibilities;
  }
}

 

[undercover]

Vielen Dank für die Hilfe,
hat alles geklappt