Pourquoi mon tri boucle semblent ajouter un élément où il ne devrait pas?

En dehors de l'alternative des solutions qui ont été postées ici (qui est correct), personne n'a vraiment répondu à votre question d'aborder ce qui était incorrect avec votre code.

Il semble comme si vous essayiez de mettre en œuvre un tri de la sélection algorithme. Je n'entrerai pas dans les détails de la façon dont le tri fonctionne ici, mais j'ai inclus quelques liens utiles pour votre référence =)

Votre code est syntaxiquement correct, mais logiquement faux. Vous avez été partiellement tri de vos chaînes par la comparaison de chaque chaîne avec les chaînes qui est venu après, il. Voici une version corrigée (j'ai retenu le plus de ton code d'origine, pour illustrer ce qui était "mal" avec elle):

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<Array.length; i++)
     {
         //We keep track of the index to the smallest string
         if(Array[i].trim().compareTo(Array[shortestStringIndex].trim())<0)
         {
             shortestStringIndex = i;  
         }
     }
     //We only swap with the smallest string
     if(shortestStringIndex != j)
     {
         String temp = Array[j];
         Array[j] = Array[shortestStringIndex]; 
         Array[shortestStringIndex] = temp;
     }
 }
}

Lecture

Le problème avec cette approche est que son complexité asymptotique est O(n^2). Dans simplifiée des mots, il devient très lent, comme la taille de la matrice augmente (approche de l'infini). Vous pouvez lire à propos de de meilleures façons de trier les données, comme quicksort.

Je sais que c'est une réponse tardive, mais peut-être que ça peut aider quelqu'un.

La suppression des espaces blancs peut être fait en utilisant la fonction trim ().
Après cela, si vous souhaitez trier le tableau avec la casse manière, vous pouvez simplement utiliser:

Arrays.sort(yourArray);

et pour le cas de manière insensible:

Arrays.sort(yourArray,String.CASE_INSENSITIVE_ORDER);

Espérons que cette aide!

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

Tout d'abord, vous fourni des espaces dans " Hello " et " This ", les espaces ont une valeur inférieure à celle des caractères alphabétiques en Unicode, et il est imprimé en premier. (Le reste des personnages ont été triées par ordre alphabétique).

Maintenant majuscules ont une valeur inférieure à celle d'une lettre minuscule en Unicode, donc "Exemple" et "Tri" est imprimé, puis à la fin "is " qui a la valeur la plus élevée.

Pour commencer, votre problème est que vous utilisez la méthode compareTo() qui est sensible à la casse. Cela signifie que les majuscules sont triés en dehors de la baisse des cas. La raison en est qu'il traduit en Unicode où les majuscules sont présentés avec des chiffres qui sont moins que le nombre de cas inférieur. Ainsi, vous devez utiliser `compareToIgnoreCase()` autant également mentionné dans les messages précédents.

C'est mon exemple de l'approche de la façon dont vous pouvez le faire effecively

Après vous créez un objet de la Comparateur vous pouvez la passer dans cette version de " trier()` qui sont définis dans java.util.Les tableaux.

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

jetez un coup d'oeil à super. Cela permet de s'assurer que le tableau qui est transmis est combatible avec le type de comparateur.

La magie de la partie de cette voie est que vous pouvez facilement trier le tableau de chaînes de caractères dans les l'ordre Inverse vous pouvez facilement le faire par:

return strB.compareToIgnoreCase(strA);

import java.util.Comparator;

    public class IgnoreCaseComp implements Comparator<String> {

        @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 De Choix

La méthode compareToIgnoreCase(), bien que cela fonctionne bien avec de nombreuses occasions(tout comme la comparaison de chaînes en anglais),il aura l'habitude de bien travailler avec tous les langues et les lieux. Cela le rend automatiquement une inapte choix pour les utiliser. Assurez-vous qu'il sera suppoorted partout où vous devez utiliser compare() de java.texte.Collateur.

Vous pouvez trouver un collateur de votre emplacement, par l'appel de la méthode getInstance(). Après cela, vous devez définir cette Collateur de la force de la propriété. Cela peut être fait avec le setStrength() méthode avec Collator.PRIMARY comme paramètre. Avec cette alternative de choix le IgnocaseComp peut être écrit comme ci-dessous. Cette version de code génère le même résultat, indépendamment de l'emplacement

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<String> {

    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);
    }

}