如何以随机方式用较小的数组填充数组

Question

我有一个包含 225 个元素和 15 个较小数组的数组，它们的长度总和正好是 225。

关键是我需要用这些较小的数组填充较大的数组，但要以随机的方式。

 private final short datosdeNivel[]= new short[225];
 private final short diecinueve[]= {19, 19};
 private final short veintiseis[]= {26, 26, 26};
 private final short dieciocho[]= {18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18};
 private final short veintidos[]= {22, 22};
 private final short veintiuno[]={21, 21, 21, 21, 21, 21, 21, 21, 21, 21};
 private final short cero[]= {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 private final short diecisiete[]= {17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17};
 private final short dieciseis[]= {16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,16, 16, 16, 16, 16, 16, 16, 16, 16, 16,16, 16, 16, 16, 16, 16, 16, 16, 16, 16,16, 16, 16, 16, 16, 16, 16, 16, 16, 16,16, 16, 16, 16, 16, 16, 16, 16, 16, 16,16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16};
 private final short veinte[]= {20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20};
 private final short veinticuatro[]= {24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24};
 private final short veinticinco[]= {25, 25, 25, 25};
 private final short veintiocho[]= {28, 28};
 private final short uno[]= {1, 1, 1, 1, 1, 1, 1};
 private final short nueve[]= {1};
 private final short ocho[]= {9, 9, 9, 9, 9, 9, 9, 9, 9};

如何建立随机顺序，以便每次程序运行时，较小数组在较大数组中的放置顺序都不同？

这将是按顺序填充它的一种方法：

int aux;
        aux= diecinueve.length;
        for(int i=0; i<diecinueve.length; i++)
        {
            datosdeNivel[i]= diecinueve[i];
        }
        for(int i=0; i<veintiseis.length; i++)
        {
            datosdeNivel[aux]= veintiseis[i];
            aux++;
        }
        for(int i=0; i<dieciocho.length; i++)
        {
            datosdeNivel[aux]= dieciocho[i];
            aux++;
        }
        for(int i=0; i<veintidos.length; i++)
        {
            datosdeNivel[aux]= veintidos[i];
            aux++;
        }
        for(int i=0; i<veintiuno.length; i++)
        {
            datosdeNivel[aux]= veintiuno[i];
            aux++;
        }
        for(int i=0; i<cero.length; i++)
        {
            datosdeNivel[aux]= cero[i];
            aux++;
        }
        for(int i=0; i<diecisiete.length; i++)
        {
            datosdeNivel[aux]= diecisiete[i];
            aux++;
        }
        for(int i=0; i<dieciseis.length; i++)
        {
            datosdeNivel[aux]= dieciseis[i];
            aux++;
        }
        for(int i=0; i<veinte.length; i++)
        {
            datosdeNivel[aux]= veinte[i];
            aux++;
        }
        for(int i=0; i<veinticuatro.length; i++)
        {
            datosdeNivel[aux]= veinticuatro[i];
            aux++;
        }
        for(int i=0; i<veinticinco.length; i++)
        {
            datosdeNivel[aux]= veinticinco[i];
            aux++;
        }
        for(int i=0; i<veintiocho.length; i++)
        {
            datosdeNivel[aux]= veintiocho[i];
            aux++;
        }
        for(int i=0; i<uno.length; i++)
        {
            datosdeNivel[aux]= uno[i];
            aux++;
        }
        for(int i=0; i<nueve.length; i++)
        {
            datosdeNivel[aux]= nueve[i];
            aux++;
        }
        for(int i=0; i<ocho.length; i++)
        {
            datosdeNivel[aux]= ocho[i];
            aux++;
        }

Answer 1

您可以尝试创建一个包含所有较小数组的 ArrayList：

ArrayList<short[]> arrays = new ArrayList<>();
arrays.add(ocho);
arrays.add(veintiocho);
// ...

然后随机访问索引，每次添加到大型数组时从列表中删除：

Random rand = new Random();
while (!arrays.isEmpty()) {
    int index = rand.nextInt(array.size());
    short[] s = arrays.get(index);
    for(int i = 0; i < s.length; i++)
    {
        datosdeNivel[aux]= s[i];
        aux++;
    }
    arrays.remove(index);
}        

这将以随机顺序将每个数组添加到大数组中。

Answer 2

在伪代码中：

• 将数组放在列表中
• 使用Collections.shuffle(list)随机排列列表
• 遍历列表，用每个数组的元素填充最终数组

Answer 3

如果我是你，我会给每个数组一个索引，然后制作一个这些索引的桶，然后从桶中随机选择一个索引，执行复制工作，并从桶中删除这个使用的索引。