Sorting in Java [duplicate]

You are using strings to do this work. This doesn't seem a good approach, I would suggest you to have an own type, something like

public class Card implements Comparable<Card>
{
  public enum Suit { SPADE, HEART, DIAMOND, CLUBS };
  public enum Value { ACE, TWO, THREE, ... };

  private Suit suit;
  private Value value;

  Card(Suit suit, Value value} { this.suit = suit; this.value = value };

  public String toString()
  {
    // return string representation like you want eg TC KC 7C
    // you can have enums with string parameters too
  }

  public int compareTo(Card card)
  { 
    // this is where you define the custom sorter
    // take a look to Comparable interface in Java API doc
    // basically this:
    //   return 0 if two cards are equal
    //   return 1 if this card is greater than passed one
    //   return -1 otherwise
  }
}

Once you defined how your card should be sorted compared to others you can let the Java API do the dirty work:

Card[] array = new Card[]{TC, KC, 7C, AC};
Arrays.sort(array);

This is how it should be done in Java.

The good thing about enums is that you can define them in the correct sorting order and then compare them directly so that you can do something like:

public int compareTo(Card card) {
  int sc = suit.compareTo(card.suit);

  if (sc != 0)
    return sc;
  else
    return value.compareTo(card.value);
}

An easy approach to this, would be to make this an object that implements the Comparable interface.

You can then take a list of Card objects and just use the Collections.sort

http://download.oracle.com/javase/1.5.0/docs/api/java/util/Collections.html#sort(java.util.List)

public class Card implements Comparable {
    String card;

    public compareTo(Object o) {
        if (o instanceof Card) {
            // check equal
            if (o.card.charAt(0) == this.card.charAt(0)) return 0; 
            // continue logic, returning -1 for lesser values and 1 for greater values               

        }
    }
}

ArrayList<String> list = 
    new ArrayList<String>(Arrays.asList("TC", "KC", "7C", "AC"));
Collections.sort(list);

If the natural ordering isn't what you're looking for, you could define your own Comparator class and pass that in:

Collections.sort(list, myComparator);

If your cards are always represented by 2 character strings, you could use something like this:

List<String> cards = new ArrayList<String>();
cards.add("TC");
cards.add("KC");
cards.add("7C");
cards.add("AC");

Collections.sort(cards, new Comparator<String>() {
    public int compare(String o1, String o2) {
        int i1 = "AKQT98765432".indexOf(o1.charAt(0));
        int i2 = "AKQT98765432".indexOf(o2.charAt(0));
        return i1 == i2 ? 0 : i1 < i2 ? -1 : 1;
    }
});

for (String card : cards) {
    System.out.println(card);
}

It appears that you are using an enum for the card identities. If this is the case, there is a natural order for your cards, the order in which the enum members are declared. If your enum is named "Card", You can declare a List cardList; and call Collections.sort(cardList) to sort it.

Here is a method that demonstrates that technique:

   public static void main(
      String[] args)
    {
        List cardList = new LinkedList();

        cardList.add(Card.CA);
        cardList.add(Card.CQ);
        cardList.add(Card.C7);
        cardList.add(Card.CJ);

        Collections.sort(cardList);

        for (Card current : cardList)
        {
            System.out.println(current);
        }
    }