用随机数填充数组[重复]

Question

我需要使用构造函数创建一个数组，添加一个将数组打印为序列的方法和一个用 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
    }
}

我正在努力弄清楚如何用我在 randomFill 方法中生成的随机数填充数组。谢谢！

Answer 1

您可以在 Random 类中使用自 java 8 起可用的 IntStream ints() 或 DoubleStream doubles()。像这样的东西会起作用，取决于你想要双精度还是整数等。

Random random = new Random();

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

你可以打印这个数组，你会得到 100000 个随机整数。

Answer 2

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

改变

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

到

 public static double[] list() {
    anArray = new double[10];
    for(int i=0;i<anArray.length;i++)
    {
        anArray[i] = randomFill();
    }
    return anArray;
}

然后就可以调用main方法中的list()和print()等方法生成随机的double值，并在控制台打印double[]数组。

 public static void main(String args[]) {

list();
print();
 }

一个结果如下：

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

Answer 3

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

• 考虑一个可以帮助您迭代数组的构造。是否有某种构造（可能是 循环？）可用于迭代数组中的每个位置？
• 在此构造中，对于循环的每次迭代，您都将randomFill() 返回的值分配给数组的当前位置。

注意：您的数组是double，但您从randomFill 返回ints。所以你需要在那里修复一些东西。

Answer 4

人们并没有在 Java 库中看到漂亮酷炫的 Stream 生产者。

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

Answer 5

试试这个：

public void double randomFill() {
    Random rand = new Random();
    for (int i = 0; i < this.anArray.length(); i++)
        this.anArray[i] = rand.nextInt();
}

Answer 6

您可以遍历数组并在每次迭代中调用 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();
    }
}

Answer 7

Arrays#setAll

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

样本运行的输出：

[0.1182317850027168, 0.9437573020895418, 0.2690505524813662, 0.6771923722130754, 0.04893586074165357, 0.42483010937765653, 0.16310798731469023, 0.2541941051963008, 0.98383420016574454, 08019574454, 90.

或者，

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

Answer 8

可能是 Java 8 中最简洁的方法：

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

Answer 9

我试图在 Java 中尽可能简单地做到这一点。这将创建一个包含 100 个变量的整数数组，并仅使用三行代码将其填充为 0 到 10 之间的整数。您也可以轻松更改随机数的范围！

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

Answer 10

快速简单

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

Answer 11

您可以像这样在循环中调用randomFill() 方法并将数组填充到main() 方法中。

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

然后您需要在您的randomFill() 方法中使用rand.nextDouble()，要填充的数组是double 数组。下面的 sn-p 应该可以帮助您将随机的 double 值填充到您的数组中。

double randomDoubleValue = rand.nextDouble();
return randomDoubleValue;

Answer 12

你可以简单地用for-loop解决它

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

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

Answer 13

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

package edu.iu.common;

import java.util.ArrayList;
import java.util.Random;

public class RandomCentroidLocator {

public static void main(String [] args){
	
	int min =0;
	int max = 10;
	int numCentroids = 10;
	ArrayList<Integer> values = randomCentroids(min, max, numCentroids);	
	for(Integer i : values){
		System.out.print(i+" ");
	}
	
}

private static boolean unique(ArrayList<Integer> arr, int num, int numCentroids) {

	boolean status = true;
	int count=0;
	for(Integer i : arr){
		if(i==num){
			count++;
		}
	}
	if(count==1){
		status = true;
	}else if(count>1){
		status =false;
	}
	

	return status;
}

// generate random centroid Ids -> these Ids can be used to retrieve data
// from the data Points generated
// simply we are picking up random items from the data points
// in this case all the random numbers are unique
// it provides the necessary number of unique and random centroids
private static ArrayList<Integer> randomCentroids(int min, int max, int numCentroids) {

	Random random = new Random();
	ArrayList<Integer> values = new ArrayList<Integer>();
	int num = -1;
	int count = 0;
	do {
		num = random.nextInt(max - min + 1) + min;
		values.add(num);
		int index =values.size()-1;
		if(unique(values, num, numCentroids)){				
			count++;
		}else{
			values.remove(index);
		}
		
	} while (!( count == numCentroids));

	return values;

}

}

Answer 14

这将为您提供一个包含 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];
        }



    }

}

}`

Answer 15

Java 8+

您可以使用ThreadLocalRandom 和Random#doubles 方法来生成一定数量的随机双精度数。

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

要在一定范围内生成随机双精度数，您可以向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)
}