Java数组：关于大小的意外行为？

请看下面用于构造卡片组的代码。我使用xFactor“variable”（硬编码）从数组大小中减去1，以调整零索引。我注意到，在遇到“java.lang.ArrayIndexOutOfBoundsException:12”错误之前，我实际上可以减去40

如果输入39作为xFactor，它运行得非常好。它构造了整个牌组，全部52张牌，尽管奇怪的是，cards.length将等于deckTotal-xFactor，位于for-each循环的两侧？！？这是没有意义的，因为它需要达到51的索引才能构建整个甲板，它确实如此

public void constructDeck(){
    int deckTotal = SUITS.length * CARDS_PER_SUIT;
    System.out.println(deckTotal); // 52
    Card[] cards = new Card[deckTotal - xFactor]; 
    System.out.println(cards.length); // Prints deckTotal - xFactor
    for(String cardSuit : SUITS){
        int cardNum = 1;
        while(cardNum <= CARDS_PER_SUIT){
            String cardDesc = cardDescription(cardNum);
            int cardValue = cardNum;
            if(cardNum >= VALUE_CEILING){
                cardValue = VALUE_CEILING;
            }
            cards[cardNum -1] = new Card(cardDesc,cardSuit,cardValue);

            this.deck.addCard(cards[cardNum -1]);
            //System.out.println(cardDesc + " of " + cardSuit + " added to the deck");
            cardNum++;
        }
    }
    System.out.println(cards.length);  // prints: deckTotal - xFactor
}

public void constructiondeck（）{
int deckTotal=套装。长度*每套套装的卡片；
System.out.println（deckTotal）；//52
卡片[]卡片=新卡片[deckTotal-xFactor]；
System.out.println（cards.length）；//Prints deckTotal-xFactor
适用于（字符串卡片套装：套装）{
int-cardNum=1；
while（cardNum=值\上限）{
cardValue=价值\上限；
}
cards[cardNum-1]=新卡（cardDesc、cardSuit、cardValue）；
this.deck.addCard（cards[cardNum-1]）；
//系统输出打印LN（卡片组中添加了“+cardSuit+”的cardDesc+”；
cardNum++；
}
}
System.out.println（cards.length）；//打印：deckTotal-xFactor
}

我能想到的唯一一件事是，内存正在从阵列的开始处被削减，以便在后面添加新卡时腾出空间。这意味着ArrayIndexOutOfBoundsException实际上只是我的计算机处理循环和/或收集垃圾的速度的函数

我写这段代码只是为了测试Java类简介的一个非常基本的赋值。从JS背景开始，在使用之前声明数组的大小似乎有点奇怪（尽管我知道原因）。这里的行为真的出乎意料，我很好奇幕后发生了什么

更新： 谢谢你的建议。这是我根据你的建议编写的最终代码

public void constructDeck(){
    for(String cardSuit : SUITS){
        int cardNum = 1;
        while(cardNum <= CARDS_PER_SUIT){
            String cardDesc = cardDescription(cardNum);
            int cardValue = cardNum;
            if(cardNum >= VALUE_CEILING){
                cardValue = VALUE_CEILING;
            }
            this.deck.addCard(new Card(cardDesc,cardSuit,cardValue));
            cardNum++;
        }
    }
}

public void constructiondeck（）{
适用于（字符串卡片套装：套装）{
int-cardNum=1；
while（cardNum=值\上限）{
cardValue=价值\上限；
}
此.deck.addCard（新卡（cardDesc、cardSuit、cardValue））；
cardNum++；
}
}
}

您可以使用..访问卡阵列

cards[cardNum-1]

这意味着您只使用数组中的前12个元素。（不同的诉讼写在以前的诉讼上）

因此，只要xFactor允许至少存在12张卡，代码就可以工作。。（可能不像你想象的那样：））

看看代码，你根本不需要数组

       this.deck.addCard( new Card(cardDesc,cardSuit,cardValue) );

---

您可以使用..访问卡阵列

cards[cardNum-1]

这意味着您只使用数组中的前12个元素。（不同的诉讼写在以前的诉讼上）

因此，只要xFactor允许至少存在12张卡，代码就可以工作。。（可能不像你想象的那样：））

看看代码，你根本不需要数组

       this.deck.addCard( new Card(cardDesc,cardSuit,cardValue) );

---

您只填充包含范围[0，

每套卡数

-1]中的卡数数组 请看这一行：

cards[cardNum -1] = new Card(cardDesc,cardSuit,cardValue);

每个套装的变量

cardNum

都重置为1，因此您只需不断覆盖相同的范围

我认为您误解了数组的分配方式。你应该分配大小。只有指数应该止损。52个卡的阵列应分配52个大小，索引范围包括[0,51]，即52个插槽

我认为这更接近你想要的：

public void constructDeck(){
    int deckTotal = SUITS.length * CARDS_PER_SUIT;
    System.out.println(deckTotal); // 52
    Card[] cards = new Card[deckTotal]; //Allocate all the cards. 
    System.out.println(cards.length); // Prints deckTotal
    int suitOffset=0;
    for(String cardSuit : SUITS){
        int cardNum = 1;
        while(cardNum <= CARDS_PER_SUIT){
            String cardDesc = cardDescription(cardNum);
            int cardValue = cardNum;
            if(cardNum >= VALUE_CEILING){
                cardValue = VALUE_CEILING;
            }
            cards[suitOffset*CARDS_PER_SUIT+cardNum -1] = new Card(cardDesc,cardSuit,cardValue);

            this.deck.addCard(cards[cardNum -1]);
            //System.out.println(cardDesc + " of " + cardSuit + " added to the deck");
            cardNum++;
        }
        ++suitOffset;
    }
    System.out.println(cards.length);  // prints: deckTotal 
    //Now lets dump the cards to output and show we're dealing with a full deck!
    //I'm assuming Card.toString() has been overridden to return something useful like
    //the description.
    for(int i=0;i<cards.length;++i){
        System.out.println("cards["+i+"]="+cards[i].toString()); 
    }
}

public void constructiondeck（）{
int deckTotal=套装。长度*每套套装的卡片；
System.out.println（deckTotal）；//52
卡片[]卡片=新卡片[deckTotal]；//分配所有卡片。
System.out.println（cards.length）；//打印总数
int-suitOffset=0；
适用于（字符串卡片套装：套装）{
int-cardNum=1；
while（cardNum=值\上限）{
cardValue=价值\上限；
}
卡[SuiteOffset*每套卡+卡号-1]=新卡（cardDesc、cardSuit、cardValue）；
this.deck.addCard（cards[cardNum-1]）；
//系统输出打印LN（卡片组中添加了“+cardSuit+”的cardDesc+”；
cardNum++；
}
++偏移量；
}
System.out.println（cards.length）；//印刷品：deckTotal
//现在，让我们将这些卡片转储到输出，并显示我们正在处理一整副牌！
//我假设Card.toString（）已被重写以返回一些有用的内容，如
//描述。
对于（int i=0；i您只填充包含范围[0，
cards\u PER\u SUIT
-1]中的cards数组
请看这一行：

cards[cardNum -1] = new Card(cardDesc,cardSuit,cardValue);

每个套装的变量
cardNum
都重置为1，因此您只需不断覆盖相同的范围

我认为您误解了数组的分配方式。您应该分配大小。只有索引应该停止。52张卡的数组应该分配大小为52，索引范围包括[0,51]，即52个插槽

我认为这更接近你想要的：

public void constructDeck(){
    int deckTotal = SUITS.length * CARDS_PER_SUIT;
    System.out.println(deckTotal); // 52
    Card[] cards = new Card[deckTotal]; //Allocate all the cards. 
    System.out.println(cards.length); // Prints deckTotal
    int suitOffset=0;
    for(String cardSuit : SUITS){
        int cardNum = 1;
        while(cardNum <= CARDS_PER_SUIT){
            String cardDesc = cardDescription(cardNum);
            int cardValue = cardNum;
            if(cardNum >= VALUE_CEILING){
                cardValue = VALUE_CEILING;
            }
            cards[suitOffset*CARDS_PER_SUIT+cardNum -1] = new Card(cardDesc,cardSuit,cardValue);

            this.deck.addCard(cards[cardNum -1]);
            //System.out.println(cardDesc + " of " + cardSuit + " added to the deck");
            cardNum++;
        }
        ++suitOffset;
    }
    System.out.println(cards.length);  // prints: deckTotal 
    //Now lets dump the cards to output and show we're dealing with a full deck!
    //I'm assuming Card.toString() has been overridden to return something useful like
    //the description.
    for(int i=0;i<cards.length;++i){
        System.out.println("cards["+i+"]="+cards[i].toString()); 
    }
}

public void constructiondeck（）{
int deckTotal=套装。长度*每套套装的卡片；
System.out.println（deckTotal）；//52
卡片[]卡片=新卡片[deckTotal]；//分配所有卡片。
System.out.println（cards.length）；//打印总数
int-suitOffset=0；
适用于（字符串卡片套装：套装）{
int-cardNum=1；
while（cardNum=值\上限）{
cardValue=价值\上限；
}
卡[SuiteOffset*每套卡+卡号-1]=新卡（cardDesc、cardSuit、cardValue）；
this.deck.addCard（cards[cardNum-1]）；
//系统输出打印LN（卡片组中添加了“+cardSuit+”的cardDesc+”；
cardNum++；
}