Sorting an array of Strings with Java

Instead of this line

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

use this line

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

and you are good to go. The reason your current code is not working is explained by other users already. This above replacement is one workaround amongst several that you could apply.

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

First of all you provided spaces in " Hello " and " This ", spaces have a lower value than alphabetic characters in Unicode, so it gets printed first. (The rest of the characters were sorted alphabetically).

Now upper case letters have a lower value than lower case letter in Unicode, so "Example" and "Sorting" gets printed, then at last "is " which has the highest value.

You are having leading space in Hello and this. Try removing them and it will work.

Apart from leading spaces, your logic works fine. Just for your information, java provides built in api for sorting,

java.util.Arrays.sort(arrays);

Apart from the alternative solutions that were posted here (which are correct), no one has actually answered your question by addressing what was wrong with your code.

It seems as though you were trying to implement a selection sort algorithm. I will not go into the details of how sorting works here, but I have included a few links for your reference =)

Your code was syntactically correct, but logically wrong. You were partially sorting your strings by only comparing each string with the strings that came after it. Here is a corrected version (I retained as much of your original code to illustrate what was "wrong" with it):

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

Further Reading

The problem with this approach is that its asymptotic complexity is O(n^2). In simplified words, it gets very slow as the size of the array grows (approaches infinity). You may want to read about better ways to sort data, such as quicksort.

public static void main(String[] args) {
    String Array[] = { " f ", " c ", " a ", " g ", " d " };
    boolean swap = true;
    int j = 0;
    while (swap) {
        swap = false;
        j++;
        for (int i = 0; i < Array.length - j; i++) {
            if (Array[i].compareTo(Array[i + 1]) > 0) {
                String tmp = Array[i];
                Array[i] = Array[i + 1];
                Array[i + 1] = tmp;
                swap = true;
            }

        }

    }
}

In Your Example Please change if(Array[i].compareTo(Array[j])<0) to if(Array[i].compareTo(Array[j])>0) :

    String str="mahesh ramesh aasas baas Aass Bsdd wwewer aaa";
    String[] strArr=str.split(" ");

    for(int i=0;i<strArr.length;i++)
    {

        for(int j=i+1;j<strArr.length;j++)
        {
            if(strArr[i].compareTo(strArr[j])>0)
            {
                String temp=strArr[i];
                strArr[i]=strArr[j];
                strArr[j]=temp;
            }

        }
    }

    for(String ss:strArr)
    {

        System.out.println(ss);
    }