Sorting string in alphabetical order

Question

The following code compiles, but the sortTitles() method does not sort the titles of the movies in alphabetical order as it is supposed to. How would you fix the compareTo() and sortTitles() methods?

Movie2 Class

public class Movie2 implements Comparable<Movie2> {
    // instance variables 
    private String title;
    private int year;
    private String studio;

    public Movie2(String title, int year, String studio) {
        // initialise instance variables
        this.title = title;
        this.year = year;
        this.studio = studio;
    }

    public String toString() {
        String listing;
        listing = title + ", " + year + ", " + studio;

        return listing;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getTitle() {
        return title;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getYear() {
        return year;
    }

    public void setStudio(String studio) {
        this.studio = studio;
    }

    public String getStudio() {
        return studio;
    }

    public int compareTo(Movie2 obj) {
        if (title < obj.getTitle()) {
            return -1;
        }
        else {
            return 1;
        }
    }
}

TestMovie2 class

public class TestMovie2 {
    public static void main(String[] args) {
        Movie2[] myMovies = new Movie2[10];
        Movie2[] sorted = new Movie2[10];

        myMovies[0] = new Movie2("The Muppets Take Manhattan", 2001, "Columbia Tristar");
        myMovies[1] = new Movie2("Mulan Special Edition", 2004, "Disney");
        myMovies[2] = new Movie2("Shrek 2", 2004, "Dreamworks");
        myMovies[3] = new Movie2("The Incredibles", 2004, "Pixar");
        myMovies[4] = new Movie2("Nanny McPhee", 2006, "Universal");
        myMovies[5] = new Movie2("The Curse of the Were-Rabbit", 2006, "Aardman");
        myMovies[6] = new Movie2("Ice Age", 2002, "20th Century Fox");
        myMovies[7] = new Movie2("Lilo & Stitch", 2002, "Disney");
        myMovies[8] = new Movie2("Robots", 2005, "20th Century Fox");
        myMovies[9] = new Movie2("Monsters Inc.", 2001, "Pixar");

        System.out.println("  Movies ");
        System.out.println("______________________________");
        System.out.println();
        printMovies(myMovies);
        System.out.println();
        System.out.println();

        Movie2[] dest = new Movie2[myMovies.length];
        sortTitles(myMovies, dest);

        System.out.println(" Sorted by title - ascending ");
        System.out.println("______________________________");
        System.out.println();
        printMovies(myMovies);
        System.out.println();
        System.out.println();

        sortYears(myMovies, sorted);
        System.out.println(" Sorted by year - descending");
        System.out.println("______________________________");
        System.out.println();
        printMovies(sorted);
        System.out.println();
        System.out.println();
    }

    public static void sortTitles(Movie2[] myMovies, Movie2[] dest) {
        for (int i = 0; i < myMovies.length; i++) {
            Movie2 next = myMovies[i];
            int insertIndex = 0;
            int k = i;
            while (k > 0 && insertIndex == 0) {
                if (myMovies[k].getTitle().compareTo(dest[k - 1].getTitle()) < 1) {
                    insertIndex = k;
                }
                else {
                    dest[k] = dest[k - 1];
                }
                k--;
            }
            dest[insertIndex] = next;
        }
    }

    public static void printMovies(Movie2[] sorted) {
        for (int i = 0; i < sorted.length; i++)
            System.out.println(sorted[i]);
    }

    public static void sortYears(Movie2[] myMovies, Movie2[] sorted) {
        for (int i = 0; i < myMovies.length; i++) {
            Movie2 next = myMovies[i];
            int insertindex = 0;
            int k = i;
            while (k > 0 && insertindex == 0) {
                if (next.getYear() < sorted[k - 1].getYear()) {
                    insertindex = k;
                }
                else {
                    sorted[k] = sorted[k - 1];
                }
                k--;
            }
            sorted[insertindex] = next;
        }
    }
}

Answer 1

Why are you comparing to String objects with a relational operator? Also you are naming your method same as the existing one. So what happens in your case is your code is not calling the method from TestingMovie2 class. It is calling the default java.lang.String method. Change the name and use the comapreTo method of String class. Modify for method as:

public int movieCompareTo(Movie2 obj)
{ 
  if (title.comapreTo(obj.getTitle()) < 0)
    return -1;
  else 
    return 1; 
}

comapreTo method: (From JavaDoc)

• The character sequence represented by this String object is compared lexicographically to the character sequence represented by the argument string.
• The result is a negative integer if this String object lexicographically precedes the argument string.
• The result is a positive integer if this String object lexicographically follows the argument string.
• The result is zero if the strings are equal

Answer 2

First fix your compareTo method in Movie2 (which you may have already done or it wouldn't even compile):

public int compareTo(Movie2 obj)
{
  return title.compareTo(obj.getTitle());
}

Then your sortTitles method in TestMovie2:

    public static void sortTitles(Movie2[] myMovies, Movie2[] dest)
    {
        for (int i = 0; i < myMovies.length; i++)
            {
                Movie2 next = myMovies[i];
                int insertIndex = 0;
                int k = i;
                while (k>0 && insertIndex == 0)
                    {
                        if (next.getTitle().compareTo(dest[k-1].getTitle()) > -1)
                            {
                                System.out.println("less than or equal");
                                insertIndex = k;
                            }
                        else 
                            {
                                System.out.println("greater than");
                                dest[k] = dest[k-1]; 
                            }
                        k--;
                    }
                dest[insertIndex] = next;
            } 
    }

With that you should get:

 Sorted by title - ascending 
______________________________

Ice Age, 2002, 20th Century Fox
Lilo & Stitch, 2002, Disney
Monsters Inc., 2001, Pixar
Mulan Special Edition, 2004, Disney
Nanny McPhee, 2006, Universal
Robots, 2005, 20th Century Fox
Shrek 2, 2004, Dreamworks
The Curse of the Were-Rabbit, 2006, Aardman
The Incredibles, 2004, Pixar
The Muppets Take Manhattan, 2001, Columbia Tristar

Answer 3

Use String#compareTo() method as

public int compareTo(Movie2 obj)
{
    if (title != null)
        return title.compareTo(obj.getTitle());
    else
        return obj.getTitle() == null ? 0 : -1;
}

Java doesn't support operator overloading. So, you can't compare Strings with relational operators. You should get a compile-time error there.

Answer 4

Use already defined compareTo method of String like:

public int compareTo(Movie2 obj) { 
    return this.getTitle().compareTo(obj.getTitle());
}

And in sortTitles method, use

Arrays.sort(myMovies);//you dont need seperate dest array