Java 用随机数填充数组

我需要使用构造函数创建一个数组，添加一个方法将数组打印为序列，并添加一个方法用double类型的随机数填充数组

以下是我迄今为止所做的工作：

import java.util.Random;

public class NumberList {
    private static double[] anArray;

    public static double[] list() {
        return new double[10];
    }
    
    public static void print(){
        System.out.println(String.join(" ", anArray);
    }

    public static double randomFill() {
        return (new Random()).nextInt();
    }
    
    public static void main(String args[]) {
        // TODO
    }
}

我正在努力找出如何用随机填充方法生成的随机数填充数组。谢谢

试试这个：

public void double random fill（）{
Random rand=新的Random（）；
for（int i=0；i

您可以在循环中调用

randomFill（）

方法，并像这样在

main（）

方法中填充数组

public static void main(String args[]) {
    for (int i = 0; i < anArray.length; i++) {
        anArray[i] = randomFill();
    }
}

---

这看起来有点像家庭作业。所以我会给你一些提示。好消息是你就快到了！你已经完成了大部分艰苦的工作

• 考虑一个可以帮助您迭代数组的构造。是否有某种构造（可能是循环？）可用于迭代数组中的每个位置
• 在这个构造中，对于循环的每次迭代，您将把

  randomFill（）

  返回的值分配给数组的当前位置

---

注意：您的数组是

double

，但您正在从

randomFill

返回

int

s。因此，这里有一些问题需要解决。

您可以在数组中循环，并在每次迭代中调用randomFill方法。请查看：

import java.util.Random;

public class NumberList {
    private static double[] anArray;

    public static double[] list() {  
        return new double[10];
    }

    public static void print() {
        System.out.println(String.join(" ", anArray));
    }


    public static double randomFill() {
        return (new Random()).nextInt();
    }

    public static void main(String args[]) {
        list();
        for(int i = 0; i < anArray.length; i++)
            anArray[i] = randomFill();

        print();
    }
}

import java.util.Random；
公共类数学家{
私有静态双[]阵列；
公共静态双[]列表（）{
返回新的双精度[10]；
}
公共静态无效打印（）{
System.out.println（String.join（“，anArray））；
}
公共静态双随机填充（）{
return（newrandom（））.nextInt（）；
}
公共静态void main（字符串参数[]）{
list（）；
for（int i=0；i

您需要添加逻辑，以便使用randomFill方法将随机值分配给double[]数组

改变

 public static double[] list(){
    anArray = new double[10];   
    return anArray;
 }

到

结果如下：

-2.89783865E8 
1.605018025E9 
-1.55668528E9 
-1.589135498E9 
-6.33159518E8 
-1.038278095E9 
-4.2632203E8 
1.310182951E9 
1.350639892E9 
6.7543543E7 

---

您只需使用

for循环

private static double[] anArray;

public static void main(String args[]) {
    anArray = new double[10]; // create the Array with 10 slots
    Random rand = new Random(); // create a local variable for Random
    for (int i = 0; i < 10; i++) // create a loop that executes 10 times
    {
        anArray[i] = rand.nextInt(); // each execution through the loop
                                        // generates a new random number and
                                        // stores it in the array at the
                                        // position i of the for-loop
    }
    printArray(); // print the result
}

private static void printArray() {
    for (int i = 0; i < 10; i++) {
        System.out.println(anArray[i]);
    }
}

private静态双[]数组；
公共静态void main（字符串参数[]）{
anArray=new double[10]；//创建具有10个插槽的阵列
Random rand=new Random（）；//为Random创建一个局部变量
for（int i=0；i<10；i++）//创建一个执行10次的循环
{
anArray[i]=rand.nextInt（）；//循环中的每次执行
//生成一个新的随机数并
//将其存储在
//for循环的位置i
}
printArray（）；//打印结果
}
私有静态void printary（）{
对于（int i=0；i<10；i++）{
System.out.println（anArray[i]）；
}
}

---

下次，请使用本网站的搜索，因为这是本网站上一个非常常见的问题，你也可以在谷歌上找到很多解决方案。

如果随机性是这样控制的，则始终可以生成给定范围内任意数量的数据点。如果只使用java中的random方法，我们不能保证所有数字都是唯一的

包edu.iu.common；
导入java.util.ArrayList；
导入java.util.Random；
公共类随机质心定位器{
公共静态void main（字符串[]args）{
int min=0；
int max=10；
int numCentroids=10；
ArrayList值=随机质心（最小、最大、numcentroid）；
对于（整数i：值）{
系统输出打印（i+“”）；
}
}
私有静态布尔唯一（ArrayList arr、int num、int numcentroid）{
布尔状态=真；
整数计数=0；
for（整数i:arr）{
如果（i==num）{
计数++；
}
}
如果（计数=1）{
状态=真；
}否则，如果（计数>1）{
状态=假；
}
返回状态；
}
//生成随机质心ID->这些ID可用于检索数据
//从生成的数据点
//我们只是从数据点中选取随机项
//在这种情况下，所有随机数都是唯一的
//它提供了所需数量的唯一和随机质心
专用静态ArrayList随机质心（int-min、int-max、int-numcentroid）{
随机=新随机（）；
ArrayList值=新的ArrayList（）；
int num=-1；
整数计数=0；
做{
num=random.nextInt（max-min+1）+min；
添加（num）；
int index=values.size（）-1；
if（唯一（值、num、numcentroid））{
计数++；
}否则{
删除（索引）；
}
}而（！（count==numcentroid））；
返回值；
}
}

这将为您提供一个包含50个随机数的数组，并显示数组中的最小数。我在编程课上做了一个作业

public static void main(String args[]) {
    // TODO Auto-generated method stub

    int i;
    int[] array = new int[50];
    for(i = 0; i <  array.length; i++) {
        array[i] = (int)(Math.random() * 100);
        System.out.print(array[i] + "  ");

        int smallest = array[0];

        for (i=1; i<array.length; i++)
        {
        if (array[i]<smallest)
        smallest = array[i];
        }



    }

}

publicstaticvoidmain（字符串参数[]）{
//TODO自动生成的方法存根
int i；
int[]数组=新的int[50]；
对于（i=0；i
Random random = new Random();

int[] array = random.ints(100000, 10,100000).toArray();

您可以打印数组，您将获得100000个随机整数。
可能是Java 8中最干净的方法：

private int[] randomIntArray() {
   Random rand = new Random();
   return IntStream.range(0, 23).map(i -> rand.nextInt()).toArray();
}

人们在Java库中看不到很酷的流生产者

public static double[] list(){
    return new Random().ints().asDoubleStream().toArray();
}

我试图在Java中使其尽可能简单。这将生成一个包含100个变量的整数数组，并使用三行代码填充0到10之间的整数。您也可以轻松更改随机数的边界

int RandNumbers[]=new int[100];
for (int i=0;i<RandNumbers.length;i++)
    RandNumbers[i]=ThreadLocalRandom.current().nextInt(0,10);

int RandNumbers[]=新int[100]；
对于（inti=0；i快速简便

double[] anArray = new Random().doubles(10).toArray();

样本运行的输出：

[0.1182317850027168、0.9437573020895418、0.26905524813662、，
0.6771923722130754,
public static double[] list(){
    return new Random().ints().asDoubleStream().toArray();
}

int RandNumbers[]=new int[100];
for (int i=0;i<RandNumbers.length;i++)
    RandNumbers[i]=ThreadLocalRandom.current().nextInt(0,10);

double[] anArray = new Random().doubles(10).toArray();

import java.util.Arrays;

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

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

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

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

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

import java.util.concurrent.ThreadLocalRandom;
//...
public static double[] list() {
    return anArray = ThreadLocalRandom.current().doubles(10).toArray();
    //Generate 10 random doubles
}

import java.util.concurrent.ThreadLocalRandom;
//...
private static final double MIN = 0, MAX = 10;
public static double[] list() {
    return anArray = ThreadLocalRandom.current().doubles(10, MIN, MAX).toArray();
    //Generate 10 random doubles between MIN (inclusive) and MAX (exclusive)
}