JAVA从数组更改为列表并使用shuffle方法
我的任务是创建一副牌，然后随机发五张牌。我终于让它“工作”，但我需要一些帮助。我刚刚读到java现在有了一个shuffle方法来洗牌列表。我们现在在数组上，所以我想我们需要数组。有没有一种方法可以对数组使用shuffle方法？如果没有，有人能指导我切换到列表吗？我想这将有助于回答我的下一个问题。我唯一要做的就是在5张随机牌发完后，说明牌组中还有多少张牌。但是，看看我是如何使用阵列的，你不能从阵列中移除物品，因为它是固定的（对吗？），我想看看是否有一种方法可以模拟从阵列中移除卡片，这样它们就不会再次被处理？还是将数组转换为列表/集合更容易 这是我的密码。非常感谢您的帮助。另外，我也会接受任何关于清理代码的建议JAVA从数组更改为列表并使用shuffle方法,java,arrays,list,methods,collections,Java,Arrays,List,Methods,Collections,我的任务是创建一副牌，然后随机发五张牌。我终于让它“工作”，但我需要一些帮助。我刚刚读到java现在有了一个shuffle方法来洗牌列表。我们现在在数组上，所以我想我们需要数组。有没有一种方法可以对数组使用shuffle方法？如果没有，有人能指导我切换到列表吗？我想这将有助于回答我的下一个问题。我唯一要做的就是在5张随机牌发完后，说明牌组中还有多少张牌。但是，看看我是如何使用阵列的，你不能从阵列中移除物品，因为它是固定的（对吗？），我想看看是否有一种方法可以模拟从阵列中移除卡片，这样它们就不会再
public class CardGame {
public static void main (String [] args) {
DeckOfCards deck = new DeckOfCards();
//call shuffle
deck.shuffle(1000);
Card b;
for (int i = 0; i < 5; i++) {
b = deck.deal();
System.out.println("Deal a card: " + b);
}
}
}
class Card {
public static final int SPADE = 4;
public static final int HEART = 3;
public static final int CLUB = 2;
public static final int DIAMOND = 1;
private static final String[] Suit = {"*", "Hearts", "Clubs", "Spades", "Diamonds"};
private static final String[] Rank = {"*", "*", "Ace", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King"};
private int cardSuit;
private int cardRank;
public Card( int suit, int rank ) {
if ( rank == 1 )
cardRank = 14; // Give Ace the rank 14
else
cardRank = (int) rank;
cardSuit = (int) suit;
}
public int suit() {
return ( this.cardSuit );
}
public String suitStr() {
return( this.Suit[ this.cardSuit ] );
}
public int rank() {
return ( this.cardRank );
}
public String rankStr() {
return ( Rank[ this.cardRank ] );
}
public String toString() {
return ( Rank[ this.cardRank ] + " of "+ Suit[ this.cardSuit ] );
}
}
class DeckOfCards {
public static final int NEWCARDS = 52;
private Card[] deckOfCards; // Contains all 52 cards
private int currentCard; // deal THIS card in deck
public DeckOfCards( ) {
deckOfCards = new Card[ NEWCARDS ];
int i = 0;
for (int suit = Card.DIAMOND; suit <= Card.SPADE; suit++)
for ( int rank = 1; rank <= 13; rank++ )
deckOfCards[i++] = new Card(suit, rank);
currentCard = 0;
}
//shuffle(n): shuffle the deck
public void shuffle(int n) {
int i, j, k;
for ( k = 0; k < n; k++ ){
i = (int) ( NEWCARDS * Math.random() ); // Pick 2 random cards
j = (int) ( NEWCARDS * Math.random() ); // in the deck
//swap these randomly picked cards
Card temp = deckOfCards[i];
deckOfCards[i] = deckOfCards[j];
deckOfCards[j] = temp;
}
currentCard = 0; // Reset current card to deal
}
//deal(): deal deckOfCards[currentCard] out
public Card deal() {
if (currentCard < NEWCARDS) {
return ( deckOfCards[currentCard++] );
}
else{
System.out.println("Out of cards error");
return ( null ); // Error;
}
}
public String toString() {
String s = "";
int k;
k = 0;
for ( int i = 0; i < 4; i++ ) {
for ( int j = 1; j <= 13; j++ )
s += (deckOfCards[k++] + " ");
s += "\n";
}
return (s);
}
}
公共类卡片游戏{
公共静态void main（字符串[]args）{
DeckOfCards deck=新的DeckOfCards（）；
//呼叫洗牌
牌组。洗牌（1000）；
b卡；
对于（int i=0；i<5；i++）{
b=deck.deal（）；
System.out.println（“交易a卡：+b”）；
}
}
}
班级卡{
公共静态最终整数SPADE=4；
公共静态最终int心脏=3；
公共静态最终积分俱乐部=2；
公共静态最终整数菱形=1；
私人静态最终字符串[]套装={“*”、“红心”、“梅花”、“黑桃”、“钻石”}；
私有静态最终字符串[]秩={“*”，“*”，“Ace”，“2”，“3”，“4”，“5”，“6”，“7”，“8”，“9”，“10”，“杰克”，“女王”，“国王”}；
私服；
私人int cardRank；
公共卡（国际诉讼、国际等级）{
如果（秩==1）
cardRank=14；//将等级14设为Ace
其他的
cardRank=（int）秩；
cardSuit=（int）suit；
}
公共诉讼{
退换货（这件衣服）；
}
公共字符串suitStr（）{
退货（这套衣服[这套卡片]）；
}
公共整数秩（）{
返回（this.cardRank）；
}
公共字符串rankStr（）{
返回（秩[this.cardRank]）；
}
公共字符串toString（）{
返回值（秩[this.cardRank]+“+Suit[this.cardSuit]）；
}
}
甲板类{
公共静态最终整数新卡=52；
私人卡[]deckOfCards；//包含所有52张卡
private int currentCard；//在牌组中处理此卡
公共甲板{
deckOfCards=新卡[新卡]；
int i=0；
对于（int suit=Card.DIAMOND；suit，这里有一个完全可用的示例程序，它演示了您需要的所有东西—洗牌和从阵列中移除牌
样本卡类别：
public class Card {
private String value = "";
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
public Card(String value) {
super();
this.value = value;
}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
public class CardGame {
public static void main(String[] args) {
List<Card> pack = new ArrayList<Card>();
Card c1 = new Card("c1");
Card c2 = new Card("c2");
Card c3 = new Card("c3");
pack.add(c1);
pack.add(c2);
pack.add(c3);
System.out.print("List : ");
CardGame.displayCardList(pack);
Card[] packArr = cardListToArray(pack);
System.out.print("Array : ");
CardGame.displayCardArray(packArr);
// http://stackoverflow.com/questions/4228975/how-to-randomize-arraylist
long seed = System.nanoTime();
Collections.shuffle(pack, new Random(seed));
System.out.print("Shuffle List : ");
CardGame.displayCardList(pack);
packArr = cardListToArray(pack);
System.out.print("Shuffle Array : ");
CardGame.displayCardArray(packArr);
System.out.print("Remove Card from Array : ");
CardGame.removeCardFromArray(packArr, new Card("c1"));
CardGame.displayCardArray(packArr);
}
public static boolean removeCardFromArray(Card[] packArr, Card card) {
boolean cardFound = false;
for (int i = 0; i < packArr.length; i++) {
if (packArr[i].getValue().equalsIgnoreCase(card.getValue())) {
packArr[i] = null;
cardFound = true;
break;
}
}
return cardFound;
}
public static Card[] cardListToArray(List<Card> pack) {
Card[] packArr = new Card[pack.size()];
for (int i = 0; i < pack.size(); i++) {
packArr[i] = pack.get(i);
}
return packArr;
}
public static void displayCardList(List<Card> pack) {
for (Card c : pack) {
System.out.print(c.getValue() + ", ");
}
System.out.println();
}
public static void displayCardArray(Card[] packArr) {
for (Card c : packArr) {
if (c == null) {
System.out.print("REMOVED, ");
} else {
System.out.print(c.getValue() + ", ");
}
}
System.out.println();
}
}
示例程序：
public class Card {
private String value = "";
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
public Card(String value) {
super();
this.value = value;
}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
public class CardGame {
public static void main(String[] args) {
List<Card> pack = new ArrayList<Card>();
Card c1 = new Card("c1");
Card c2 = new Card("c2");
Card c3 = new Card("c3");
pack.add(c1);
pack.add(c2);
pack.add(c3);
System.out.print("List : ");
CardGame.displayCardList(pack);
Card[] packArr = cardListToArray(pack);
System.out.print("Array : ");
CardGame.displayCardArray(packArr);
// http://stackoverflow.com/questions/4228975/how-to-randomize-arraylist
long seed = System.nanoTime();
Collections.shuffle(pack, new Random(seed));
System.out.print("Shuffle List : ");
CardGame.displayCardList(pack);
packArr = cardListToArray(pack);
System.out.print("Shuffle Array : ");
CardGame.displayCardArray(packArr);
System.out.print("Remove Card from Array : ");
CardGame.removeCardFromArray(packArr, new Card("c1"));
CardGame.displayCardArray(packArr);
}
public static boolean removeCardFromArray(Card[] packArr, Card card) {
boolean cardFound = false;
for (int i = 0; i < packArr.length; i++) {
if (packArr[i].getValue().equalsIgnoreCase(card.getValue())) {
packArr[i] = null;
cardFound = true;
break;
}
}
return cardFound;
}
public static Card[] cardListToArray(List<Card> pack) {
Card[] packArr = new Card[pack.size()];
for (int i = 0; i < pack.size(); i++) {
packArr[i] = pack.get(i);
}
return packArr;
}
public static void displayCardList(List<Card> pack) {
for (Card c : pack) {
System.out.print(c.getValue() + ", ");
}
System.out.println();
}
public static void displayCardArray(Card[] packArr) {
for (Card c : packArr) {
if (c == null) {
System.out.print("REMOVED, ");
} else {
System.out.print(c.getValue() + ", ");
}
}
System.out.println();
}
}
import java.util.ArrayList；
导入java.util.Collections；
导入java.util.List；
导入java.util.Random；
公开课纸牌游戏{
公共静态void main（字符串[]args）{
列表包=新的ArrayList（）；
卡c1=新卡（“c1”）；
卡c2=新卡（“c2”）；
卡c3=新卡（“c3”）；
包装。添加（c1）；
包装。添加（c2）；
包装。添加（c3）；
系统输出打印（“列表：”）；
卡片游戏。显示卡片列表（套装）；
卡片[]包装=卡片列表到阵列（包装）；
系统输出打印（“数组：”）；
CardGame.displayCardArray（Packager）；
// http://stackoverflow.com/questions/4228975/how-to-randomize-arraylist
长种子=System.nanoTime（）；
收集。洗牌（打包，新随机（种子））；
系统输出打印（“随机列表：”）；
卡片游戏。显示卡片列表（套装）；
packArr=卡片列表阵列（包装）；
系统输出打印（“随机数组：”）；
CardGame.displayCardArray（Packager）；
System.out.print（“从阵列中移除卡：”）；
CardGame.removeCardFromArray（Packager，新卡（“c1”））；
CardGame.displayCardArray（Packager）；
}
公共静态布尔removeCardFromArray（卡片[]包装，卡片）{
布尔cardFound=false；
对于（int i=0；i
卡
在Card类中，套装应该是一个枚举。您可以这样创建枚举
enum Suit {
SPADE,
HEART,
CLUB,
DIAMOND
};
那么这个类应该持有它当前的一个变量，比如
Suit suit;
您可以很容易地更改它的值
suit = Suit.HEART;
如果你必须使用索引来访问一套衣服，你可以使用
suit = Suit.values()[index];
return Rank[suit.ordinal()];
当获得你可以使用的卡的等级时
suit = Suit.values()[index];
return Rank[suit.ordinal()];
Card类中函数的名称不是您应该使用的典型名称。其中一些应该是getter。我建议使用GetSuiter（）和GetSuiteName（）这样的名称，您希望通过阅读这些名称就可以了解它们的功能。Suiter（）这样的名称有点困惑，他们没有告诉你他们在用西装做什么
DeckOfCards
在DeckOfCards类中，初始化甲板时，为套装的每个循环使用一个for
for (Suit suit : Suits.values()) {
...
}
deckOfCards.get(index);
Random random = new Random();
int i = random.nextInt(NEWCARDS);
int j = random.nextInt(NEWCARDS);
Card temp = deckOfCards[i];
deckOfCards[i] = deckOfCards[j];
deckOfCards[j] = temp;
Arrays.asList(new ArrayList<Card>());
list.toArray();//This will return an array of Objects[]
Card[] cards = new Card[NEWCARDS];
list.toArray(cards)//This will store the list into the array cards.
//Note if the lists is bigger than the array it is storing it in, the function will return a new array that can hold all of the elemnents in the list.
public DeckOfCards() {
i = (int) ( NEWCARDS * Math.random() );
//should be
i = (int) (NEWCARDS * Math.random());