Dieses Programm schneller machen?

[MrXeth]

Jo moin, ich habe ein Programm geschrieben, welches aus einem 7Hand Pokerdeck die beste Kombination errechnet. Da wollte ich fragen, ob da wer mal rüberschauen kann, ob ich irgendwo unnützes Zeug eingebaut habe oder wie / ob man an den kommentierten Stellen einen Quicksort einbauen könnte.

package Game;

import java.util.ArrayList;
import java.util.Iterator;

public class management {

    // Notiz: als nächstes neue Funktionen machen, die die Blätter und andere die
    // die Beikarten returnen
// Notiz: getPairs noch richtig sortieren
    public static void main(String[] args) {
        management m = new management();
        m.alphaTest();

    }

    private ArrayList<card> cards;

    private ArrayList<player> players;
    // ArrayList<KI> KIs;
    private stack stack;
    public management() {
        cards = new ArrayList<card>();
        players = new ArrayList<player>();
        stack = new stack();
    }

    public boolean addCard() {
        if (cards.size() <= 5) {
            if (stack.dragCard() != null) {
                cards.add(stack.dragCard());
                return true;
            } else
                return false;
        } else
            return false;
    }

    public boolean addCards(int amount) {
        if (amount <= 5 - cards.size()) {
            for (int i = 0; i <= amount; i++) {
                card card = stack.dragCard();
                if (card != null) {
                    cards.add(card);
                } else
                    return false;
            }
            return true;
        } else
            return false;
    }

    public void addPlayer() {
        player p = new player();
        p.addCards(stack.dragCard(), stack.dragCard());
        players.add(p);
    }

    public void addPlayer(String name) {
        player p = new player(name);
        p.addCards(stack.dragCard(), stack.dragCard());
        players.add(p);
    }

    public void alphaTest() {
        addPlayer("Kai");
        addPlayer("Manfred");
        addPlayer("Manfred");
        addPlayer("Manfred");
        addPlayer("Manfred");
        addPlayer("Manfred"); // prüfen ob der gewettet hat

        players.get(0).bet(10);
        players.get(1).bet(10);
        players.get(2).bet(10);
        players.get(3).bet(10);
        players.get(4).bet(10);
        players.get(5).bet(10);
       
        cards.add(new card("Herz", "König")); // von Stapel nehmen damit keine Fehler auftreten
        cards.add(new card("Herz", "Bube"));
        cards.add(new card("Herz", "Ass"));
        cards.add(new card("Herz", "10"));
        cards.add(new card("Pik", "Dame"));
        win();
    }

    private ArrayList<card> arrayListOfPairs(ArrayList<ArrayList<card>> cards) {
        ArrayList<card> normalList = new ArrayList<card>();
        Iterator<ArrayList<card>> it = cards.iterator();
        while (it.hasNext()) {
            normalList.addAll(it.next());
        }
        return normalList;
    }

    private boolean assertConsecutiveRanks(card card1, card card2) {
        return card1.getValue() == card2.getValue() - 1 || (card1.getValue() == 14 && card2.getValue() == 2)
                || (card1.getValue() == card2.getValue());
    }

    private int compareCards(card card1, card card2) {
        if (card1.getValue() > card2.getValue())
            return 1;
        else if (card2.getValue() > card1.getValue())
            return 2;
        else
            return 0;
    }

    private player comparePlayers(player player1, player player2) {
        ArrayList<card> firstDeck = new ArrayList<card>(player1.getWholeDeck());
        ArrayList<card> secondDeck = new ArrayList<card>(player2.getWholeDeck());
        for (int i = 0; i < firstDeck.size() - 1; i++) {
            if (compareCards(firstDeck.get(0), secondDeck.get(0)) == 1) {
                return player1;
            } else if (compareCards(firstDeck.get(0), secondDeck.get(0)) == 2) {
                return player2;
            } else {
                firstDeck.remove(0);
                secondDeck.remove(0);
            }
        }
        return null;
    }

    private ArrayList<card> flushCards(ArrayList<card> cards) {
        ArrayList<card> Herz = new ArrayList<card>();
        ArrayList<card> Karo = new ArrayList<card>();
        ArrayList<card> Kreuz = new ArrayList<card>();
        ArrayList<card> Pik = new ArrayList<card>();

        for (card card : cards) {
            if (card.getKind() == "Herz") {
                Herz.add(card);
            } else if (card.getKind() == "Karo") {
                Karo.add(card);
            } else if (card.getKind() == "Kreuz") {
                Kreuz.add(card);
            } else if (card.getKind() == "Pik") {
                Pik.add(card);
            }
        }
        if (Herz.size() >= 5) {
            return Herz;
        } else if (Karo.size() >= 5) {
            return Karo;
        } else if (Kreuz.size() >= 5) {
            return Kreuz;
        } else if (Pik.size() >= 5) {
            return Pik;
        } else {
            return null;
        }
    }

    private ArrayList<player> getCombination(ArrayList<player> players, String combination) {
        ArrayList<player> winList = new ArrayList<player>();
        Iterator<player> it = players.iterator();
        while (it.hasNext()) {
            player player = it.next();
            String s = player.getDeck();
            if (combination.equals(player.getDeck())) {
                winList.add(player);
            }
        }
        return winList;
    }

    private ArrayList<card> getDeck(player player) {
        ArrayList<card> linkedList = new ArrayList<card>();
        linkedList.addAll(cards);
        linkedList.addAll(player.getCards());
        return linkedList;
    }

    private int getNumberOfPairs(ArrayList<ArrayList<card>> pairs) {
        return pairs.size();
    }

    // general principle of pairs from:
    // https://github.com/dwdyer/poker/blob/master/game/src/java/main/org/uncommons/poker/game/cards/SevenCardHandEvaluator.java

    private ArrayList<ArrayList<card>> getPairs(ArrayList<card> cards) {
        ArrayList<ArrayList<card>> pairs = new ArrayList<ArrayList<card>>();
        ArrayList<card> pair = new ArrayList<card>();
       
        int prevValue = cards.get(0).getValue();
       
        pair.add(cards.get(0));
       
        for (int i = 1; i < cards.size(); i++) {
           
            int value = cards.get(i).getValue();
           
            if (value == prevValue) {
               
                pair.add(cards.get(i));
                System.out.print("Value: ");
                System.out.println(value);
               
            } else if(i+1 == cards.size()) {
               
                pair.add(cards.get(i));
                System.out.println("größe pair: "+pair.size()+"");
                System.out.print("Value: ");
                System.out.println(value);
                pairs.add(pair); System.out.println("runned");
                pair = new ArrayList<card>();
               
            }
           
            else {
               
                pairs.add(pair);
                System.out.println("größe pair: "+pair.size()+"");
                pair = new ArrayList<card>();
               
                pair.add(cards.get(i));
               
                prevValue = value;
               
            }
        }
        ArrayList<ArrayList<card>> newList = new ArrayList<ArrayList<card>>(sortPairs(pairs)); // vielleicht besser umsetzen
       
        System.out.println("Größtes pair");
        System.out.println(newList.get(0).size());
        System.out.println(newList.get(1).size());
        System.out.println(newList.get(2).size());
        System.out.println(newList.get(3).size());
        System.out.println(newList.get(4).size());
        System.out.println(newList.size());
        return newList;
    }

    public void newRound() {
        stack.addCards(cards);
        for (player player : players) {
            stack.addCards(player.getCards());
            player.resetCards();
        }
        stack.mixCards();
        addCards(3);
        for (player player : players) {
            player.addCards(stack.dragCard(), stack.dragCard());
        }
    }

    private String pairToRank(int pairs, int biggestGroup) {
        System.out.println();
        System.out.println(biggestGroup);
        switch (biggestGroup) {
        case 1:
                System.out.println("Pairs: "+pairs+"");
                return "High Card";

        case 2:
            System.out.println("Pairs: "+pairs+"");
            if (pairs == 1)
                return "Pair";
            else
                return "Two Pair";
        case 3:
            if (pairs == 5)
                return "Three of a Kind";
            else
                return "Full House";
        case 4:
            return "Four of a Kind";
        default:
            System.out.println("Error");
            return "";
        }
    }

    private void playerDeck(player player) {
        boolean straight = false;
        boolean flush = false;
        ArrayList<card> deck = new ArrayList<card>();
        deck.addAll(getDeck(player));
        System.out.println(deck.size());
        String rank;

        deck = sortAfterValue(deck);

        ArrayList<ArrayList<card>> pairs = getPairs(deck);
        rank = pairToRank(getNumberOfPairs(pairs), returnSizeOfBiggestPair(pairs));
        System.out.println(rank);
       
        if (straightCards(deck).size() >= 5) {
            deck = straightCards(deck);
            toFive(deck);
            straight = true;
            System.out.println("Straight");
        }

       
        if (flushCards(deck) != null && flushCards(deck).size() >= 5) {
            flush = true;
            toFive(deck);
            System.out.println("Flush");
        }
       
        if (rank != "Four of a Kind" && rank != "Full House") {
            if (straight == true) {
                rank = "Straight";
            } else if (flush == true) {
                rank = "Flush";
            }
        }

        if (straight == true && flush == true) {
            if (deck.get(0).getValue() == 14) {
                rank = "Royal Flush";
            } else {
                rank = "Straight Flush";
            }
        }
        toFive(deck);
        player.setDeck(rank);
        player.setWholeDeck(deck);
        System.out.println(deck.get(0).getValue());
        System.out.println(player.getDeck());
    }

    public boolean removePlayer(int index) {
        try {
            players.remove(index);
        } catch (IndexOutOfBoundsException e) {
            return false;
        }
        return true;
    }

    private int returnSizeOfBiggestPair(ArrayList<ArrayList<card>> pairs) {
        return pairs.get(0).size();
    }

    private ArrayList<card> sortAfterValue(ArrayList<card> cards) {
        ArrayList<card> sortedList = new ArrayList<card>();
        int maxVal = 14;
        // maybe later: quicksort
        for (int i = maxVal; i > 1; i--) {
            for (int k = 0; k < cards.size(); k++) {
                if (cards.get(k).getValue() == i) {
                    sortedList.add(cards.get(k));
                }
            }
        }
        return sortedList;
    }

    private ArrayList<ArrayList<card>> sortPairs(ArrayList<ArrayList<card>> pairs) {
        ArrayList<ArrayList<card>> sortedList = new ArrayList<ArrayList<card>>();
        int maxVal = 14;
        // maybe later: quicksort
        for (int i = 4; i > 0; i--) { // length
            for (int j = maxVal; j > 1; j--) { // value
                for (int k = 0; k < pairs.size(); k++) { // go through for every pair
                    if (pairs.get(k).size() == i && pairs.get(k).get(0).getValue() == j) {
                        sortedList.add(pairs.get(k));
                    }
                }
            }
        }
       
        return sortedList;
    }

    private ArrayList<card> straightCards(ArrayList<card> cards) { // zuerst sortieren und 5 karten eingeben, da
                                                                    // ansonsten ungenauigkeiten auftreten
        ArrayList<card> straightCards = new ArrayList<card>();
        card highestCard = cards.get(0);
        if (highestCard.getValue() == 14 && cards.get(cards.size() - 1).getValue() == 2) {
            cards = new ArrayList<card>(cards);
            cards.add(highestCard); // höchste karte ans ende bringen
            cards.remove(0);
            highestCard = cards.get(0);
        }
        straightCards.add(highestCard);
        card prevCard = highestCard;
        for (int i = 1; i < cards.size(); i++) {
            card card = cards.get(i);
            if (assertConsecutiveRanks(card, prevCard)) {
                if (card.getValue() != prevCard.getValue())
                    straightCards.add(card);
                if (straightCards.size() == 5) {
                    return straightCards;
                }
            } else {
                straightCards.clear();
                straightCards.add(highestCard);
            }
            prevCard = card;
        }
        return straightCards;
    }

    private ArrayList<card> toFive(ArrayList<card> cards) {
        for (int i = cards.size(); i > 5; i--) {
            cards.remove(cards.size() - 1);
        }
        return cards;
    }

    public void win() {

        ArrayList<player> wonList = new ArrayList<player>();
        int pot = 0;

        for (int i = 0; i < players.size(); i++) {
            player player = players.get(i);
            if (player.getEntry() != 0 || player.getAction() != null || player.getAction() != "call") {
                playerDeck(player);
                pot += player.getEntry();
                player.looseEntry();
            }
        }

        if (getCombination(players, "Royal Flush").size() != 0) {
            wonList.addAll(getCombination(players, "Royal Flush"));
        } else if (getCombination(players, "Straight Flush").size() != 0) {
            wonList.addAll(getCombination(players, "Straight Flush"));
        } else if (getCombination(players, "Four of a Kind").size() != 0) {
            wonList.addAll(getCombination(players, "Four of a Kind"));
        } else if (getCombination(players, "Full House").size() != 0) {
            wonList.addAll(getCombination(players, "Full House"));
        } else if (getCombination(players, "Flush").size() != 0) {
            wonList.addAll(getCombination(players, "Flush"));
        } else if (getCombination(players, "Straight").size() != 0) {
            wonList.addAll(getCombination(players, "Straight"));
        } else if (getCombination(players, "Three of a Kind").size() != 0) {
            wonList.addAll(getCombination(players, "Three of a Kind"));
        } else if (getCombination(players, "Two Pair").size() != 0) {
            wonList.addAll(getCombination(players, "Two Pair"));
        } else if (getCombination(players, "Pair").size() != 0) {
            wonList.addAll(getCombination(players, "Pair"));
        } else {
            wonList.addAll(getCombination(players, "High Card"));
        }
        System.out.println(wonList.get(0).getDeck());

        if (wonList.size() > 1) {
            for (int i = 0; i < wonList.size(); i++) { // jeden Spieler mit jedem vergleichen
                player player1 = wonList.get(i);
                for (int j = 0; j < wonList.size(); j++) {
                    player player2 = wonList.get(j);
                    player comp = comparePlayers(player1, player2);
                    if (comp != null) {
                        if (comp.equals(player1)) {
                            wonList.remove(player2);
                        } else if (comp.equals(player2)) {
                            wonList.remove(player1);
                            break;
                        }
                    }
                }
            }
        }
        if (true) {
            pot /= wonList.size();
            Iterator<player> it = wonList.iterator();
            while (it.hasNext()) {
                player player = it.next();
                player.addChips(pot);
                System.out.println(player.getName());
                System.out.println(pot);
            }
        }
    }

}

Danke für Hilfe!

 

[mrBrown]

Ganz generell solltest du an deinem Stil Arbeiten und Konventionen einhalten: Klassen groß schreiben, Variablen klein schreiben, Strings mit equals und nicht mit == vergleichen.

Was soll man zum Quicksort einbauen mehr sagen, als das Quicksort an den Stellen genutzt werden soll? Implementieren solltest du das schon selbst, und mehr muss da nichts gemacht werden

 

[VfL_Freak]

Moin,
außerdem: wer soll sich hier durch soviel Code wühlen, der nicht mal ansatzweise kommentiert ist??
VG Klaus