Warum scheint meine Sortierschleife ein Element anzuhängen, wo es nicht sein sollte?

Ich versuche, ein Array von Strings mit compareTo() zu sortieren. Das ist mein Code:

 static String Array[] = {" Hello ", " This ", "is ", "Sorting ", "Example"}; String temp; public static void main(String[] args) { for (int j=0; j<Array.length;j++) { for (int i=j+1 ; i<Array.length; i++) { if (Array[i].compareTo(Array[j])<0) { String temp = Array[j]; Array[j] = Array[i]; Array[i] = temp; } } System.out.print(Array[j]); } } 

Jetzt ist die Ausgabe:

 Hello This Example Sorting is 

Ich bekomme Ergebnisse, aber nicht die Ergebnisse, die ich bekommen möchte, nämlich:

 Hello This Example Is Sorting 

Wie kann ich meinen Code anpassen, um das String-Array richtig zu sortieren?

Ihre Ausgabe ist korrekt. Bezeichnen Sie die weißen Zeichen von “Hello” und “This” am Anfang.

Ein anderes Problem ist mit Ihrer Methodik. Verwenden Sie die Methode Arrays.sort() :

 String[] strings = { " Hello ", " This ", "Is ", "Sorting ", "Example" }; Arrays.sort(strings); 

Ausgabe:

  Hello This Example Is Sorting 

Hier sollte das dritte Element des Arrays “is” “Is” sein, sonst wird es nach dem Sortieren zuletzt kommen. Weil die Sortiermethode intern den ASCII-Wert zum Sortieren von Elementen verwendet.

Abgesehen von den alternativen Lösungen, die hier gepostet wurden (die korrekt sind), hat niemand Ihre Frage beantwortet, indem er ansprach, was mit Ihrem Code nicht stimmt.

Es scheint, als ob Sie versuchten, einen Auswahlsortieralgorithmus zu implementieren. Ich werde nicht auf die Details eingehen, wie das Sortieren hier funktioniert, aber ich habe ein paar Links als Referenz hinzugefügt =)

Ihr Code war syntaktisch korrekt, aber logisch falsch. Sie haben Ihre Strings teilweise sortiert, indem Sie nur die einzelnen Strings mit den nachfolgenden Strings verglichen haben . Hier ist eine korrigierte Version (ich habe so viel von Ihrem ursprünglichen Code behalten, um zu illustrieren, was damit “falsch” war):

 static String Array[]={" Hello " , " This " , "is ", "Sorting ", "Example"}; String temp; //Keeps track of the smallest string's index int shortestStringIndex; public static void main(String[] args) { //I reduced the upper bound from Array.length to (Array.length - 1) for(int j=0; j < Array.length - 1;j++) { shortestStringIndex = j; for (int i=j+1 ; i 

Weiterführende Literatur

Das Problem bei diesem Ansatz ist, dass seine asymptotische Komplexität O (n ^ 2) ist . In vereinfachten Worten wird es sehr langsam, wenn die Größe des Arrays wächst (nähert sich der Unendlichkeit). Vielleicht möchten Sie nach besseren Möglichkeiten zum Sortieren von Daten wie Quicksort lesen.

Anstelle dieser Linie

 if(Array[i].compareTo(Array[j])<0) 

Benutze diese Linie

 if(Array[i].trim().compareTo(Array[j].trim())<0) 

und du bist gut zu gehen. Der Grund dafür, dass Ihr aktueller Code nicht funktioniert, wird bereits von anderen Benutzern erklärt. Dieser obige Ersatz ist ein Workaround unter mehreren, den Sie anwenden könnten.

Ich weiß, das ist eine späte Antwort, aber vielleicht kann es jemandem helfen.

Das Entfernen von Leerzeichen kann mit der function trimmen () erfolgen. Danach, wenn Sie das Array mit Groß- und Kleinschreibung sortieren möchten, können Sie einfach verwenden:

 Arrays.sort(yourArray); 

und für die Groß- / Kleinschreibung nicht:

 Arrays.sort(yourArray,String.CASE_INSENSITIVE_ORDER); 

Hoffe das hilft!

Ausgehend von Java 8 können Sie auch parallelSort was nützlich ist, wenn Sie Arrays mit vielen Elementen haben.

Beispiel:

 public static void main(String[] args) { String[] strings = { "x", "a", "c", "b", "y" }; Arrays.parallelSort(strings); System.out.println(Arrays.toString(strings)); // [a, b, c, x, y] } 

Wenn Sie den Fall ignorieren möchten, können Sie Folgendes verwenden:

 public static void main(String[] args) { String[] strings = { "x", "a", "c", "B", "y" }; Arrays.parallelSort(strings, new Comparator() { @Override public int compare(String o1, String o2) { return o1.compareToIgnoreCase(o2); } }); System.out.println(Arrays.toString(strings)); // [a, B, c, x, y] } 

sonst wird B vor a .

Wenn Sie die nachgestellten Leerzeichen während des Vergleichs ignorieren möchten, können Sie trim() :

 public static void main(String[] args) { String[] strings = { "x", " a", "c ", " b", "y" }; Arrays.parallelSort(strings, new Comparator() { @Override public int compare(String o1, String o2) { return o1.trim().compareTo(o2.trim()); } }); System.out.println(Arrays.toString(strings)); // [ a, b, c , x, y] } 

Siehe :

" Hello " , " This " , "is ", "Sorting ", "Example"

Zuerst haben Sie Leerzeichen in " Hello " und " This " , Leerzeichen haben einen niedrigeren Wert als alphabetische Zeichen in Unicode, daher wird es zuerst gedruckt. (Der Rest der Charaktere wurde alphabetisch sortiert).

Großbuchstaben haben jetzt einen niedrigeren Wert als Kleinbuchstaben in Unicode, so dass “Example” und “Sorting” gedruckt werden, dann ist "is " der höchste Wert.

Wenn du benutzt:

 if (Array[i].compareToIgnoreCase(Array[j]) < 0) 

Sie erhalten:

 Example Hello is Sorting This 

was ich denke, ist die Ausgabe, nach der Sie gesucht haben.

Ihr Problem besteht zunächst darin, dass Sie die Methode `compareTo () verwenden, bei der die Groß- / Kleinschreibung beachtet wird. Das bedeutet, dass die Großbuchstaben von der Kleinschreibung getrennt sind. Der Grund ist, dass es in Unicode übersetzt wurde, wo die Großbuchstaben mit Zahlen dargestellt werden, die kleiner sind als die angegebene Kleinbuchstabenzahl. Daher sollten Sie `compareToIgnoreCase ()` so viele verwenden, wie auch in früheren Posts erwähnt.

Dies ist mein vollständiger Beispielansatz, wie Sie es effektiv machen können

Nachdem Sie ein Objekt des Comparators erstellt haben , können Sie es in dieser Version von `sort ()` übergeben, die in java.util.Arrays definiert ist.

 staticvoid sort(T[]array,Comparator< ?super T>comp) 

Sieh dir Super an. Dies stellt sicher, dass das Array, in das hineingegangen wird, mit dem Komparatortyp kompatibel ist.

Der magische Teil dieses Weges ist, dass Sie das Array von Strings leicht in umgekehrter Reihenfolge sortieren können.

 return strB.compareToIgnoreCase(strA); 

 import java.util.Comparator; public class IgnoreCaseComp implements Comparator { @Override public int compare(String strA, String strB) { return strA.compareToIgnoreCase(strB); } } 

  import java.util.Arrays; public class IgnoreCaseSort { public static void main(String[] args) { String strs[] = {" Hello ", " This ", "is ", "Sorting ", "Example"}; System.out.print("Initial order: "); for (String s : strs) { System.out.print(s + " "); } System.out.println("\n"); IgnoreCaseComp icc = new IgnoreCaseComp(); Arrays.sort(strs, icc); System.out.print("Case-insesitive sorted order: "); for (String s : strs) { System.out.print(s + " "); } System.out.println("\n"); Arrays.sort(strs); System.out.print("Default, case-sensitive sorted order: "); for (String s : strs) { System.out.print(s + " "); } System.out.println("\n"); } } 

  run: Initial order: Hello This is Sorting Example Case-insesitive sorted order: Hello This Example is Sorting Default, case-sensitive sorted order: Hello This Example Sorting is BUILD SUCCESSFUL (total time: 0 seconds) 

Alternative Wahl

Die Methode compareToIgnoreCase() , obwohl es mit vielen Gelegenheiten gut funktioniert (genau wie Vergleichsstring in Englisch), wird es nicht gut mit allen Sprachen und Standorten funktionieren. Dies macht es automatisch zu einer ungeeigneten Wahl für den Gebrauch. Um sicherzustellen, dass es überall unterstützt wird, sollten Sie compare() von java.text.Collator verwenden .

Sie können einen Kollator für Ihren Standort finden, indem Sie die Methode getInstance() aufrufen. Danach sollten Sie die Festigkeitseigenschaft dieses Collators einstellen. Dies kann mit der Methode setStrength() zusammen mit Collator.PRIMARY als Parameter geschehen. Mit dieser Alternative kann der IgnocaseComp wie folgt geschrieben werden. Diese Codeversion generiert unabhängig vom Speicherort die gleiche Ausgabe

 import java.text.Collator; import java.util.Comparator; //this comparator uses one Collator to determine //the right sort usage with no sensitive type //of the 2 given strings public class IgnoreCaseComp implements Comparator { Collator col; IgnoreCaseComp() { //default locale col = Collator.getInstance(); //this will consider only PRIMARY difference ("a" vs "b") col.setStrength(Collator.PRIMARY); } @Override public int compare(String strA, String strB) { return col.compare(strA, strB); } }