Java 解释代码

代码如下：

基本上，这个代码打印出52张带有西服+等级的卡片

package javaapplication52;

public class JavaApplication52 {

    public static void deck() {

        String[] suit = { "Clubs", "Diamonds", "Hearts", "Spades" };
        String[] rank = { "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack",
                "Queen", "King", "Ace" };

        // avoid hardwired constants
        int SUITS = suit.length;
        int RANKS = rank.length;
        int N = SUITS * RANKS;
        // initialize deck
        String[] deck = new String[N];
        for (int i = 0; i < RANKS; i++) {
            for (int j = 0; j < SUITS; j++) {
                deck[SUITS * i + j] = rank[i] + " of " + suit[j];

            }
        }
        // shuffle
        for (int i = 0; i < N; i++) {
            int r = i + (int) (Math.random() * (N - i));
            String t = deck[r];
            deck[r] = deck[i];
            deck[i] = t;
        }

        // print shuffled deck
        for (int i = 0; i < N; i++) {
            System.out.println(deck[i]);

        }

    }

    public static void main(String[] arg) {

        JavaApplication52 d = new JavaApplication52();

        d.deck();

    }
}

我不明白的是，为什么它们会相乘，然后我加上j。让人困惑的是诉讼（等于4），乘以i（等于13），然后再加上j（值为4），根本不等于52。

---

请解释一下这个函数是如何工作的。

索引“i”将取0到12之间的值。i变量将仅在0到12之间，j变量将在0到3之间，因此索引的最大值为4*12+3=51，这是组的最大索引。这样的组将有52个元素，对于一组卡来说是有意义的。

//避免硬连线常量
// avoid hardwired constants
    int SUITS = suit.length;
    int RANKS = rank.length;
    int N = SUITS * RANKS;
    // initialize deck
    String[] deck = new String[N];
    for (int i = 0; i < RANKS; i++) {
        for (int j = 0; j < SUITS; j++) {
            deck[SUITS * i + j] = rank[i] + " of " + suit[j];

        }
    }

int SUITS=suit.length；
int RANKS=rank.length；
int N=诉讼*等级；
//初始化甲板
字符串[]组=新字符串[N]；
for（int i=0；i

西装的长度为4，军衔的长度为12，N的尺寸为52（这意味着String[]牌组有52个位置）

因此，

inti=0；i

将从0变为12，

intj=0；j

将从0变为3

---

因此，

4*12+3

是51-或卡片52。

将二维数组放入一维数组是一种常见的习惯用法，如下所示：

for (row = 0; row < ROWS; ++row) {
    for (col = 0; col < COLUMNS; ++col) {
        array[row * ROWSIZE + col] = . . .
    }
}

. . . array[col * ROWS + row] = . . .

0 1 2 3 4 5 6 7 8 9 10 11

0 4 8 1 5 9 2 6 10 3 7 11

假设您有3行4列。第一个代码将填充数组，如下所示：

for (row = 0; row < ROWS; ++row) {
    for (col = 0; col < COLUMNS; ++col) {
        array[row * ROWSIZE + col] = . . .
    }
}

. . . array[col * ROWS + row] = . . .

0 1 2 3 4 5 6 7 8 9 10 11

0 4 8 1 5 9 2 6 10 3 7 11

后者将按如下方式填充数组：

for (row = 0; row < ROWS; ++row) {
    for (col = 0; col < COLUMNS; ++col) {
        array[row * ROWSIZE + col] = . . .
    }
}

. . . array[col * ROWS + row] = . . .

0 1 2 3 4 5 6 7 8 9 10 11

0 4 8 1 5 9 2 6 10 3 7 11

…但由于他接下来要做的就是洗牌数组，所以创建数组的顺序无关紧要

---

另一方面，使用字符串来制作纸牌是一个糟糕的主意。在洗牌之前，请查看。

；它基本上是一个二维数组，而不是一个线性数组

ARRAY[CURRENT_ROW][CURRENT_COLUMN]

= ARRAY[(NUMBER_OF_COLUMNS * CURRENT_ROW) + CURRENT_COLUMN]

---

当索引

CURRENT_ROW

和

CURRENT_COLUMN

从0开始时，

i

的最大值为12，

j

为3。因此4*12+3=51（数组的第52个值）.WriteLine（“deck[{0}]={1}”，suites*I+j，deck[suites*I+j]）（请将其转换为基于Java的控制台输出（或命令提示符）…然后试着理解..你应该访问我拿出了套装*1+j，替换为52；这给了我一个错误，它们有区别吗？@pur3extme对不起，代表我的是糟糕的数学。数组中有52个位置-但是数组是0索引的，所以51是你可以使用的最大位置。我将编辑我的帖子。如果替换适合*i+j一个固定的数字，只有该数组位置才会被赋值。数组中的每一个其他值都会被输出为null。@pur3extrme上面的代码工作正常，它的解释只是让你的头在

i

和

j

的范围内，同时记住数组是0索引的。我是intri你提到了行主顺序，但我无法将你的行主顺序公式与所提供的公式联系起来。如果我将西装与行、等级与列联系起来，那么你的公式就不合适，反之亦然。在维基百科上，行主顺序公式不同：行*列大小+列。你能有一个厕所吗我看不到你提到的文本。我看到的维基百科文章说，

offset=row*NUMCOLS+column

，这是正确的。（正如我所说，“行大小”和“列数”是一样的）@jesses.co.tt事实上，如果你仔细看这个问题，你会发现我将是13。“乘以我（13），”@jesses.co.tt有时越少越好，朋友