如何在数组中生成随机双精度数？

Question

我的目标是询问用户一个数组长度并生成一个随机双精度列表来填充该数组。我不明白如何将 Math.random 放入我的数组中。我从一种不同的方法开始并放弃了它。为什么 double random = Math.random() * array;不将随机生成器导入我的数组？

import java.util.Scanner;
import java.util.Arrays;
import java.util.Random;

public class Average
{
  public static void main(String[] args)
  {
    /*Scanner in = new Scanner (System.in);

    System.out.println("Please enter your array size: ");
    int size = in.nextInt();
    int[] awnser = new int[size]; */
    Scanner scanner = new Scanner(System.in);

    System.out.println("Enter a number");

    double[] array = new double[scanner.nextDdouble()];
    double random = Math.random() * array;
    System.out.println(array.length);

    }
  }

Answer 1

使用您当前的解决方案，您需要使用从 0 开始并在给定大小之前结束的计数器进行迭代，并为每个数组元素分配一个 nextDouble 调用。

Java 不支持将数组对象乘以数字。

这是一个您可能喜欢的 Java-8 习惯用法：

DoubleStream
    .generate(ThreadLocalRandom.current()::nextDouble)
    .limit(yourGivenSize)
    .toArray();

这将为您提供大小为yourGivenSize 的double[]，其元素是随机生成的。

Answer 2

Java 8+

您可以将ThreadLocalRandom 与Random#doubles 方法一起使用。

import java.util.concurrent.ThreadLocalRandom;
//...
double[] randoms = ThreadLocalRandom.current().doubles(10).toArray();
//Generate 10 random doubles

double[] randoms = ThreadLocalRandom.current().doubles(10, 0, 5).toArray();
//Generate 10 random doubles between 0 (inclusive) and 5 (exclusive)

Answer 3

为什么 double random = Math.random() * array;不将随机生成器导入我的数组？

你误解了这个类的工作原理。 Here 很好地解释了这个类的作用。我相信你正在尝试做的事情是：

    Random rand = new Random();
    Scanner scanner = new Scanner(System.in);

    System.out.println("Enter a number");
    //create an array with the size entered by the user
    double[] array = new double[scanner.nextInt()];
    //populate the array with doubles
    for(int i =0; i < array.length; i++) {
        array[i] = rand.nextDouble();
    }

nextDouble 返回一个介于 0 和 1.0 之间的伪随机数，因此您需要将其乘以上限。 （即如果 100 是您的上限 rand.nextDouble() * 100;）

（确保import Random 类）

Answer 4

Arrays#setAll

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        double[] array = new double[10];
        Arrays.setAll(array, i -> Math.random());
        System.out.println(Arrays.toString(array));
    }
}

样本运行的输出：

[0.1182317810027168, 0.9437573020895418, 0.2690105524813662, 0.6771923722130754, 0.04893586074165357, 0.42483010937765653, 0.16310798731469023, 0.2541941051963008, 0.98383420019874454, 08019574454, 08016574454, 080.

或者，

import java.util.Arrays;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        double[] array = new double[10];
        
        array = IntStream.range(0, array.length)
                    .mapToDouble(i -> Math.random())
                    .toArray();
        
        System.out.println(Arrays.toString(array));
    }
}

或者，

import java.util.Arrays;
import java.util.Random;

public class Main {
    public static void main(String[] args) {
        double[] array = new Random().doubles(10).toArray();
        System.out.println(Arrays.toString(array));
    }
}

或者，

import java.util.Arrays;
import java.util.concurrent.ThreadLocalRandom;

public class Main {
    public static void main(String[] args) {
        double[] array = ThreadLocalRandom.current().doubles(10).toArray();
        System.out.println(Arrays.toString(array));
    }
}

或者，

import java.util.Arrays;
import java.util.concurrent.ThreadLocalRandom;

public class Main {
    public static void main(String[] args) {
        final int SIZE = 10;
        double[] array = new double[SIZE];

        for (int i = 0; i < SIZE; i++) {
            array[i] = ThreadLocalRandom.current().nextDouble();
        }
        
        System.out.println(Arrays.toString(array));
    }
}

或者，

import java.util.Arrays;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        Double[] array = Stream.generate(Math::random).limit(10).toArray(Double[]::new);
        System.out.println(Arrays.toString(array));
    }
}

或者，

import java.util.Arrays;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        double[] array = Stream.generate(Math::random).limit(10).mapToDouble(Double::valueOf).toArray();
        System.out.println(Arrays.toString(array));
    }
}

Answer 5

我不完全确定您要做什么，您要在数组中获取的值的范围是多少？无论如何，我认为这应该可以实现您想要做的事情，我在这里使用命令行参数来提供数组长度，请随时将其更改回扫描仪。

int arrayLength = Integer.parseInt(args[0]);

double[] array = new double[arrayLength];
for (int i = 0; i < arrayLength; i++)
    array[i] = Math.random() * arrayLength;
System.out.println(Arrays.toString(array));

生成特定范围的随机值：

Min + (int)(Math.random() * ((Max - Min) + 1))

Answer 6

我使用您最初的想法来计算您循环生成随机双数的次数。如您所知，数组索引（或位置）从零开始。所以我使用了一个 for 循环从零开始，一旦生成了这一行的数字：list[i] = num;将随机数放入数组的第一个索引（位置）并继续直到达到用户指定的大小。

package stack;

    import java.util.Scanner;
    import java.util.Random;

    public class Stack {

    public static void main(String[] args){

      Scanner input = new Scanner(System.in);
      System.out.println("enter a number");

    int size = input.nextInt();
       Double[] list = new Double[size];

       for(int i = 0; i < size; i++){
            Double num = Math.random();
            list[i] = num;
       }
     System.out.println(list.length);
    }
    }

/*  for(int i = 0; i< list.length; i++){
     System.out.println(list[i]);  }
*/

如果您想检查数组内容，我也包括在内。通过检查每个索引（位置）并显示它们，我创建了另一个与第一个循环具有相同概念的 for 循环。