Java 返回由n个随机数组成的整数数组列表？

我如何创建方法RandomArray并让它接受整数n并返回由n个介于0和255之间的随机数组成的整数数组列表（换句话说：让返回的数组大小为n）？？？ （我正在使用JavaEclipse） 我已经创建了RandomArray，但是我不知道如何将其放入ArrayList中，这是我目前得到的：

    import java.util.Random;
    public class Lab6 {

    public static void main(String[] args) {

    Random random = new Random();
    int[] n = new int[1];

    for( int i = 0 ; i < n.length ; i++ ) { 
       for ( int i1 = 0 ; i1 < n.length ; i1++ ) { 
          n[i1] = random.nextInt(255);
       }
    }
    for( int a : n ) { 
        System.out.println( a );
    }
}
    }

import java.util.Random；
公共类Lab6{
公共静态void main（字符串[]args）{
随机=新随机（）；
int[]n=新的int[1]；
对于（int i=0；i

阵列列表的工作方式与阵列大致相同，只是它们可以根据需要增长（或收缩），并且不支持通过

[]

操作符进行访问/检索（即，不能在阵列列表上执行

n[i1]

）。相反，使用其

add（）

方法向其添加元素，并使用

get（）

方法访问元素。

您的意思是：

public ArrayList<Integer> randomArrayList(int n)
{
    ArrayList<Integer> list = new ArrayList<>();
    Random random = new Random();

    for (int i = 0; i < n; i++)
    {
        list.add(random.nextInt(255));
    }
    return list;
}

publicArrayList随机ArrayList（int n）
{
ArrayList=新建ArrayList（）；
随机=新随机（）；
对于（int i=0；i

试试这样的方法

private ArrayList<Integer> randomArray(int size){
Random random = new Random();

ArrayList<Integer> newArrayList = new ArrayList<Integer>();

for(int i=0; i<size; i++){
int next = random.nextInt(256);
newArrayList.add(next);
}

return newArrayList;

}

private ArrayList randomArray（整数大小）{
随机=新随机（）；
ArrayList newArrayList=新ArrayList（）；
for（inti=0；iMain方法包含一个示例用法

import java.security.*;
import java.util.*;


public class Util {

    public static void main(String[] args) {
        int n = 15;

        ArrayList<Integer> integers = RandomArray(n);

        for (Integer integer : integers) {
            System.out.println(integer);
        }


    }

    private static ArrayList<Integer> RandomArray(int n) {
        Random rand = new SecureRandom();
        byte[] b = new byte[n];
        rand.nextBytes(b);
        Integer[] ints = new Integer[b.length];
        for (int i = 0; i < b.length; i++) {
            ints[i] = b[i] & 0xFF;
        }
        return new ArrayList<Integer>(Arrays.asList(ints));
    }
}

导入java.security.*；
导入java.util.*；
公共类Util{
公共静态void main（字符串[]args）{
int n=15；
ArrayList整数=随机数组（n）；
for（整数：整数）{
System.out.println（整数）；
}
}
私有静态数组列表随机数组（int n）{
Random rand=新的SecureRandom（）；
字节[]b=新字节[n]；
兰特下字节（b）；
整数[]整数=新整数[b.length]；
for（int i=0；i
这比你要求的要多，但它与此无关，可能有助于人们理解这个问题

当你想要一个随机整数的
ArrayList
时，你通常只需要一些随机数，而不需要将它们存储在任何地方。在这种情况下，你可能只需要一个
迭代器
，该迭代器返回一个随机整数流，可以根据你的需要返回任意多个。使用该库很容易做到这一点（现在它应该是每个Java代码库的一部分）

您可以轻松定义一个
迭代器
，该迭代器根据需要提供任意多个随机整数（或任何其他数据类型）：

public static final Iterator<Integer> RAND_INT_ITER =
    new AbstractIterator<Integer>() {
        @Override
        protected Integer computeNext() {
            return ThreadLocalRandom.current().nextInt();
        }
    };

无论您需要在哪里调用此方法都没有问题，因为它不存储任何状态，您不会浪费时间或空间计算任何东西，垃圾收集器会在您完成后为您清理。我们使用
ThreadLocalRandom
确保这些方法是线程安全的，并避免在所有地方构建新的
Random
对象位置（以及引入的潜在数据竞争条件，尽管较新版本的Java在这方面非常聪明）。如果更合理的话，您可以同样轻松地使用现有的
Random
对象

一些例子：

// print random ints until we see one that's divisible by 100
while(true) {
    int rnd = RAND_INT_ITER.next();
    System.out.println(rnd);
    if(rnd % 100 == 0) {
        break;
    }
}

// Get an iterator of exactly 10 random ints, [0,255)
Iterator<Integer> tenRandInts = Iterators.limit(randIntIterator(255), 10);
while(tenRandInts.hasNext()) {
    System.out.println(tenRandInts.next());
}

// Note that the returned iterator above is still one-use, if you need to iterate
// Over the same numbers more than once, put them in a list first
// It's not a good idea to simply convert an Iterator into an Iterable, see:
// http://stackoverflow.com/a/14711323/113632
List<Integer> randIntLs = ImmutableList.copyOf(
                              Iterators.limit(randIntIterator(255), 10));
for(int rnd : randIntLs) {
    System.out.println(rnd);
}
for(int rnd : randIntLs) {
    System.out.println(rnd);
}

//打印随机整数，直到我们看到一个可以被100整除
while（true）{
int rnd=RAND_int_ITER.next（）；
系统输出打印项次（rnd）；
如果（rnd%100==0）{
打破
}
}
//获取正好为10个随机整数的迭代器[0255）
迭代器tenRandInts=Iterators.limit（randIntIterator（255），10）；
while（tenRandInts.hasNext（））{
System.out.println（tenRandInts.next（））；
}
//请注意，如果需要迭代，上面返回的迭代器仍然是一个用途
//对同一个数字进行多次测试，首先将其放入列表中
//简单地将迭代器转换为Iterable不是一个好主意，请参见：
// http://stackoverflow.com/a/14711323/113632
List randIntLs=ImmutableList.copyOf(
极限（randIntIterator（255），10））；
对于（内部rnd:randIntLs）{
系统输出打印项次（rnd）；
}
对于（内部rnd:randIntLs）{
系统输出打印项次（rnd）；
}

使用此模式生成随机数据通常会使代码更干净、更精简、更易于阅读。试试看：）
@user1086318 Np。不过，了解这里发生的事情很重要。我错过了家庭作业标签，通常我不会给出完整的解决方案，而是OOOO PS=Pthanks，是的，我肯定想知道发生了什么，否则这是毫无意义的！！！值得一提的是，在每个invoc上创建新的
随机
对象初始化不是一个好主意。尤其是在Java的早期版本中，这可能会导致返回非常不随机的数据。解决这一问题的简单方法是使用
ThreadLocalRandom.current（）
，但是存储单个静态
随机
对象对于单线程执行也同样有效。您正在尝试向Integer类型的集合添加int。这将导致编译器错误。我向您保证不会。编译器错误来自何方？除非Java的新版本将从int t执行隐式强制转换o Integer（自1.4.2以来，我没有做过很多工作）。您正在尝试将类型为
int
的变量
next
添加到类型化的泛型集合
newArrayList
，该集合需要类型为
Integer
的对象。Java 1.5及更高版本支持自动装箱，因此将为您执行此转换。
// print random ints until we see one that's divisible by 100
while(true) {
    int rnd = RAND_INT_ITER.next();
    System.out.println(rnd);
    if(rnd % 100 == 0) {
        break;
    }
}

// Get an iterator of exactly 10 random ints, [0,255)
Iterator<Integer> tenRandInts = Iterators.limit(randIntIterator(255), 10);
while(tenRandInts.hasNext()) {
    System.out.println(tenRandInts.next());
}

// Note that the returned iterator above is still one-use, if you need to iterate
// Over the same numbers more than once, put them in a list first
// It's not a good idea to simply convert an Iterator into an Iterable, see:
// http://stackoverflow.com/a/14711323/113632
List<Integer> randIntLs = ImmutableList.copyOf(
                              Iterators.limit(randIntIterator(255), 10));
for(int rnd : randIntLs) {
    System.out.println(rnd);
}
for(int rnd : randIntLs) {
    System.out.println(rnd);
}