返回一个由n个随机数组成的整数ArrayList？

5 回答

• 0

  ArrayLists的工作方式与数组的工作方式大致相同，只是它们可以根据需要增长（或缩小），并且不支持通过 [] 运算符进行访问/检索（即，您无法在ArrayList上执行 n[i1] ） . 而是使用其 add() 方法向其添加元素，并使用 get() 方法访问元素 .

  回复于 2024-04-25T06:28:23+08:00
• 1

  你的意思是这样的：

  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;
  }
  

  回复于 2024-04-25T06:28:23+08:00
• 0

  尝试这样的事情

  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;
  
  }
  

  回复于 2024-04-25T06:28:23+08:00
• 1

  主方法包含示例用法

  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));
      }
  }
  

  回复于 2024-04-25T06:28:23+08:00
• 0

  这比你要求的要多，但它与切线相关，可能会帮助人们遇到这个问题 .

  当你想要一个 ArrayList 的随机整数时，你通常只需要一些随机数，并且不需要将它们存储在任何地方 . 在这种情况下，您可能只需返回一个 Iterator<Integer> ，它会返回随机整数流，尽可能多 . 这很容易用Guava库（现在应该是每个Java代码库的一部分） .

  您可以轻松定义 Iterator<Integer> ，它可以为您提供所需数量的随机数（或您想要的任何其他数据类型）：

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

  或者，如果要使用 Random.nextInt(int max) 方法：

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

  有没有浪费时间或空间计算任何东西，垃圾收集器会在你完成时为你清理它 . 我们使用 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);
  }
  

  使用此模式生成随机数据通常会使您的代码更清晰，更精简，更易于阅读 . 试试看 ：）

  回复于 2024-04-25T06:28:23+08:00