sorting function - how can this be improved

I have the following code for sorting. Can this be improved?

import java.util.*;
class Church {
    private String name;
    private String pastor;
    public Church(String name, String pastor) {
        this.name = name;
        this.pastor = pastor;
    }
    public String getPastor() {
        return pastor;
    }
    public String getName() {
        return name;
    }
    public void setPastor(String pastor) {
        this.pastor = pastor;
    }
    public String toString() {
        return getName() + " is Pastored by "+getPastor();
    }
    public int compareByPastor(Church c) {
        int x = pastor.compareTo(c.getPastor());
        return x;
    }
    public int compareByName(Church c) {
        int x = name.compareTo(c.getName());
        return x;
    }
}

class Churches {
    private final List<Church> churches;

    public Churches() {
        churches = new ArrayList<Church>();
    }
    public void addWithoutSorting(Church c) {
        churches.add(c);
    }

    //You could always add using this method
    public void addWithSorting(Church c) {

    }
    public void display() {
        for(int j = 0; j < churches.size(); j++) {
            System.out.print(churches.get(j).toString());
            System.out.println("");
        }
   }
   public List<Church> getChurches() {
       return churches;
   }
   public void sortBy(String s) {
       for (int i = 1; i < churches.size(); i++) {
           int j;
           Church val = churches.get(i);
           for (j = i-1; j > -1; j--) {
               Church temp = churches.get(j);
               if(s.equals("Pastor")) {
                   if (temp.compareByPastor(val) <= 0) {
                       break;
                   }
               }
               else if(s.equals("Name")) {
                   if (temp.compareByName(val) <= 0) {
                          break;
                   }
               }
               churches.set(j+1, temp);
            }
            churches.set(j+1, val);
       }
     }

    public static void main(String[] args) {
        Churches baptists = new Churches();
        baptists.addWithoutSorting(new Church("Pac", "Pastor G"));
        baptists.addWithoutSorting(ne开发者_如何学Gow Church("New Life", "Tudor"));
        baptists.addWithoutSorting(new Church("My Church", "r035198x"));
        baptists.addWithoutSorting(new Church("AFM", "Cathy"));
        System.out.println("**********************Before Sorting***********************");
        baptists.display();
        baptists.sortBy("Pastor");
        System.out.println("**********************After sorting by Pastor**************");
        baptists.display();
        baptists.sortBy("Name");
        System.out.println("**********************After sorting by Name****************");
        baptists.display();

    }

  }

Take a look at Collections.sort(list, comparator) http://download.oracle.com/javase/6/docs/api/java/util/Collections.html

class Churches
{
    public void sortBy(String attribute) 
    {
      Comparator<Church> c = null;

      if ("Name".equals(attribute)) c = new ChurchNameComparator();
      else if ("Pastor".equals(attribute)) c = new ChurchNameComparator();
      else System.out.println("unexpected sort attribute : '" + attribute + "'");

      if (c != null) Collections.sort(churches, c);
    }

    private static final class ChurchNameComparator implements Comparator<Church> 
    {
      public int compare(Church c1, Church c2)
      {
        return c1.getName().compareTo(c2.getName());
      }
    }

    private static final class ChurchPastorComparator implements Comparator<Church> 
    {
      public int compare(Church c1, Church c2)
      {
        return c1.getPastor().compareTo(c2.getPastor());
      }
    }
}

The real answer here is pretty much in line with iluxa's: you want to implement a Comparator interface on your Church objects (sample code here, though you'll want to decide what constitutes greater than/less than for a church...), and then you can use Collections.sort() to sort them. That will get the job done, at the end of the day.

Of course, you just asked for advice about sorting on Stack Overflow, so I feel compelled to ask you if you need an in-place sort, what kind of Big-O performance you're looking for, and then ask you to choose between Quicksort, IntroSort, HeapSort, MergeSort, and StoogeSort for what will work best for you.

For kicks, I once coded up a few sorts in Java:

• This one forces Quicksort into quadratic time, which was harder to do than I'd originally assumed,
• This one shows how to implement MergeSort,
• and this one demonstrates a HeapSort

I did these for my own enjoyment and education. As a general rule, you want to stick with the standard library for these sorts of things.