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

我有一个包含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++;
        }

intaux；
aux=底端长度；
对于（int i=0；i如果我是你，我会给每个数组一个索引，然后制作一个包含这些索引的存储桶，然后从存储桶中随机选取一个索引，执行复制工作，并从存储桶中删除这个使用过的索引。
你可以尝试创建一个包含所有较小数组的ArrayList：

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

ArrayList数组=新的ArrayList（）；
数组。添加（ocho）；
数组。添加（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);
}        

Random rand=new Random（）；
而（！arrays.isEmpty（））{
int index=rand.nextInt（array.size（））；
short[]s=arrays.get（索引）；
对于（int i=0；i

这将以随机顺序将每个数组添加到大数组中。
在伪代码中：


将数组放入列表中
使用集合洗牌列表。洗牌（列表）

迭代列表，用每个数组的元素填充最后一个数组

---

您是否有试图填充另一个数组以容纳这些数组的代码？如果有，请在此处编辑并发布。不清楚。只需随机添加数组，或同时添加所有数组的值？您的最终目标是什么？@UDKOX我认为这些值，因为数组的大小是相同的。假设您有数组

a=[1,1]

和

b=[2,2]

。所谓“用较小的数组填充”是指

c=[1,1,2,2]

和

c=[2,2,1,1]

（我们直接放置数组，如

a，b

和

b，a

）或者

c=[1,2,1,2]

？