Java 8+

Question

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

这是我到目前为止所做的：

import java.util.Random;


public class NumberList {


    private static double[] anArray;

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

    public static void print(){
        for(double n: anArray){
        System.out.println(n+" ");
        }
    }


    public static double randomFill(){

    Random rand = new Random();
    int randomNum = rand.nextInt();
    return randomNum;
    }

    public static void main(String args[]) {

    }


}

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

Answer 1

您需要使用 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值，并在console中打印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 2

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

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

注意：您的数组是double，但您要从int返回randomFill。所以你需要解决一些问题。

Answer 3

您可以在Random类中使用java 8中提供的IntStream ints()或DoubleStream doubles()。这样的事情会起作用，取决于你是想要双重还是投注等。

int[] array = new int[100000];

Random random = new Random();

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

你可以打印数组，你将获得100000个随机整数。

Answer 4

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

import java.util.Random;

public class NumberList {


    private static double[] anArray;

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

    public static void print(){
        for(double n: anArray){
            System.out.println(n+" ");
        }
    }


    public static double randomFill(){
        Random rand = new Random();
        int randomNum = rand.nextInt();
        return randomNum;
    }

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


}

Answer 5

我试图用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 6

`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.254194105819, 0.254194105819, 0.2541941058080.780.4080.4080.4080.3780.40595959

或者，

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 7

试试这个：

public void double randomFill(){

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

Answer 8

您可以在循环中调用randomFill()方法，并使用main()方法填充数组。

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

虽然您需要在rand.nextDouble()中使用randomFill()，因为您似乎要填充{{1}}数组。

double

Answer 9

您只需使用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]);
    }
}

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

Answer 10

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

＆＃13;

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

＆＃13;

Answer 11

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

在Java 8中可能是最干净的方法：

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

Answer 13

人们在Java库中看不到任何不错的Stream生产器。

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

Answer 14

快速简便

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

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

用随机数填充数组

15 个答案:

`Arrays#setAll`

或者，

或者，

Java 8+