Kartenobjekte im Handobjekt sortieren

Question

Ich habe fast alles bereit für mein Pokerspiel. Was ich als nächstes machen möchte, ist Karten in Spielerhand nach Rangwert zu sortieren. Sie wissen, dass "zwei" ist Byte 2, "drei" ist Byte 3 etc ... Das ist meine Enum CardRank Klasse

public enum CardRank { 
    TWO((byte)2, "Two"), 
    THREE((byte)3, "Three"), 
    FOUR((byte)4, "Four"), 
    FIVE((byte)5, "Five"), 
    SIX((byte)6, "Six"), 
    SEVEN((byte)7, "Seven"), 
    EIGHT((byte)8, "Eight"), 
    NINE((byte)9, "Nine"), 
    TEN((byte)10, "Ten"), 
    JACK((byte)11, "Jack"), 
    QUEEN((byte)12, "Queen"), 
    KING((byte)13, "King"), 
    ACE((byte)14, "Ace"); 

    private final byte rankValue; 
    private final String rankValueName; 

    //Constructor 
    private CardRank(byte rankValue, String rankValueName){ 
     this.rankValue=rankValue; 
     this.rankValueName = rankValueName; 
    } 

    //reusable methods 
    protected byte getRankValue(){ 
     return rankValue; 
    } 

    protected String getRankValueName(){ 
     return rankValueName; 
    } 
} 

Ich brauche einen Weg zu finden sortiere sie mit enum-Werten, aber um ehrlich zu sein, ich weiß nicht wirklich wie. Diese Methode liefert ENUM-Werte von Spielerhandkarten:

protected void sortHand(){ 
    for (Hand playerHand: players){ 
     i = 0; 
     while(i<5){ 
      System.out.println(playerHand.cards.get(i).getRankValue()); 
      i++; 
     } 
    } 
} 

Ich kann nicht Kollektionen von einem sehr offensichtlichen Grund verwenden: Die Methode sort (List) in der Art Collections ist nicht anwendbar für die Argumente (Hand)

Und das ist meine Hand Klasse

import java.util.ArrayList; 

    public class Hand { 

     protected ArrayList<Card> cards; 
     private String handCards; 

     // Constructor 
     protected Hand() { 
      cards = new ArrayList<Card>(5); 
     } 

     // reusable methods 

     protected void add(Card card) { 
      cards.add(card); 
     } 

     protected void emptyHand() { 
      cards.clear(); 
     } 

     protected void flipHandCards() { 
      for (Card card : cards) { 
       card.flipCard(); 
      } 
     } 

     protected String displayHand() { 
      handCards = ""; 
      for (Card i : cards) { 
       handCards += i.toString() + "\n"; 
      } 
      return handCards; 
     } 

     protected boolean giveCard(Card card, Hand differentHand) { 
      if (!cards.contains(card)) { 
       return false; 
      } else { 
       cards.remove(card); 
       differentHand.add(card); 
       return true; 
      } 
     } 
    } 

Und das ist meine Klasse Karte

public class Card { 

    private CardSuit suit; 
    private CardRank rank; 
    private String cardName; 
    private boolean visibility; 

    //Constructor 
    protected Card(CardRank rank, CardSuit suit){ 
     this.rank = rank; 
     this.suit = suit; 
    } 

    //reusable methods 
    protected String getCardSuit(){ 
     return suit.getCardSuit(); 
    } 

    protected byte getRankValue(){ 
     return rank.getRankValue(); 
    } 
    protected void flipCard(){ 
     visibility = !visibility; 
    } 

    public String toString(){ 
     if (visibility){ 
      cardName=""; 
      cardName+=rank.getRankValueName() + " of " + suit.getCardSuit(); 
     } 
     else{ 
      cardName = "You cannot see your opponents card"; 
     } 
     return cardName; 
    } 
} 

Hilfe. Ich schätze jede Hilfe, die mich in die richtige Richtung lenken wird.

Answer 1

Sie sagen, dass Sie Guava (Google Sammlungen) nicht verwenden können, scheint dies für den Nennwert falsch. Gib einfach eine Sortiermethode, die es mit Karten interagieren lässt (was eine ArrayList ist).

protected void sortHand(){ 
    for (Hand playerHand: players){ 
     List<Card> sortedHand = playerHand.getSortedCards(); 
     // Do whatever 
    } 
} 

Hand.java

public class Hand { 
    ... 

    public List<Card> getSortedCards() { 
     Collections.sort(cards); 
     return cards; // Consider deep copying. 
    } 
} 

Von dort machen Karte implementieren Vergleichbare finden Sie die Liste lassen sortieren.

Card.java

public class Card implements Comparable<Card> 
{ 
    ... 

    @Override 
    public int compareTo(Card o) { 
     if (this.rank.getRankValue() < o.rank.getRankValue()) { 
      return -1; 
     } 
     else if (o.rank.getRankValue() < this.rank.getRankValue()) { 
      return 1; 
     } 
     return 0; 
    } 
} 

Answer 2

protected void sortHand(){ 
    for (Hand playerHand: players){ 
     i = 0; 
     int []arr = new int[5]; 
     while(i<5){ 
      System.out.println(playerHand.cards.get(i).getRankValue()); 
      arr[i] = playerHand.cards.get(i).getRankValue(); 
      i++; 
     } 
     Arrays.sort(arr); 
    } 
} 

können Sie versuchen, es zu einem Array hinzufügen und Array.sort() nennen. Dabei nehme ich an, dass getRankvalue einen int zurückgibt. versuchen Sie dies

Answer 3

Arraylisten kann leicht sortiert, um eine Comparator verwenden.
Sie würden dann so etwas wie dieses:

cards.sort(new Comparator<Card>() { 
    @Override 
    public int compare(Card card1, Card card2) { 
     // return -1 if card1 should come before card2 
     // return 0 if card1 and card2 have equal values 
     // return 1 if card1 should come after card2 
    } 
}); 

Answer 4

Ich schlage vor, Sie ein statisches Array verwenden Hand zu speichern Karten in:

public class Hand { 
    private static final int MAX_CARD = 5;//modify with your value 

    protected Card[] cards; 
    private int currentCardNumber; 
    private String handCards; 

    // Constructor 
    protected Hand() { 
     cards = new Card[MAX_CARD]; 
     currentCardNumber = 0; 
    } 

    // reusable methods 

    protected void add(Card card) { 
     if (currentCardNumber == MAX_CARD - 1) { return; } 
     cards[currentCardNumber] = card; 
     currentCardNumber++; 
    } 

    protected void emptyHand() { 
     for (int i = 0; i < MAX_CARD; i++) { 
      cards[i] = null; 
     } 
     currentCardNumber = 0; 
    } 

    protected void flipHandCards() { 
     for (int i = 0; i < currentCardNumber; i++) { 
      cards[i].flipCard(); 
     } 
    } 

    protected String displayHand() { 
     handCards = ""; 
     for (int i = 0; i < currentCardNumber; i++) { 
      handCards += cards[i].toString() + "\n"; 
     } 
     return handCards; 
    } 
    protected boolean giveCard(Card card, Hand differentHand) { 
     int index = getCardIndex(card); 
     if (index == -1) { 
      return false; 
     } else { 
      differentHand.add(remove(index)); 
      return true; 
     } 
    } 

    protected void sortHand() { 
     for(int i = 0; i < currentCardNumber; i++) { 
      for(int j = i + 1; j < currentCardNumber; j++) { 
       if(cards[j].getRankValue() < cards[i].getRankValue()) { 
        Card tmp = cards[j]; 
        cards[j] = cards[i]; 
        cards[i] = tmp; 
       } 
      } 
     } 
    } 

    private int getCardIndex(Card card) { 
     for (int i = 0; i < currentCardNumber; i++) { 
      if(card.equals(cards[i]) { 
       return i; 
      } 
     } 
     return -1; 
    } 

    private Card remove(int cardIndex) { 
     if (currentCardNumber == 0) { return null; } 
     Card tmp = cards[cardIndex]; 
     for (int i = cardIndex + 1; i < currentCardNumber; i++) { 
      cards[i - 1] = cards[i]; 
     }    
     cards[currentCardNumber - 1] = null; 
     currentCardNumber--; 
     return tmp; 
    } 
} 

Oder Sie können Ihre eigene Liste erstellen und Ihre eigene Art anwenden Methode.