Ik moet een array maken met behulp van een constructor, een methode toevoegen om de array als een reeks af te drukken en een methode om de array te vullen met willekeurige getallen van het type double.

Dit is wat ik tot nu toe heb gedaan:

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

Ik heb moeite om erachter te komen hoe ik de array kan vullen met de willekeurige getallen die ik heb gegenereerd in de randomFill-methode. Bedankt!

Antwoord 1, autoriteit 100%

Je moet logica toevoegen om willekeurige waarden toe te wijzen aan de dubbele[]-array met behulp van de randomFill-methode.

Wijzigen

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

Naar

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

Vervolgens kun je methoden aanroepen, waaronder list() en print() in de hoofdmethode om willekeurige dubbele waarden te genereren en de dubbele[] array in de console af te drukken.

public static void main(String args[]) {
list();
print();
 }

Eén resultaat is als volgt:

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

Antwoord 2, autoriteit 90%

U kunt IntStream ints()of DoubleStream doubles()beschikbaar vanaf java 8 in Random-klasse. zoiets als dit zal werken, hangt ervan af of je double of ints enz. wilt.

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

je kunt de array afdrukken en je krijgt 100.000 willekeurige gehele getallen.

Antwoord 3, autoriteit 25%

Dit lijkt een beetje op huiswerk. Dus ik zal je wat tips geven. Het goede nieuws is dat je er bijna bent! Je hebt het meeste harde werk al gedaan!

• Denk aan een constructie die u kan helpen de array te herhalen. Is er een soort constructie (misschien een lus?) die u kunt gebruiken om elke locatie in de array te herhalen?
• Binnen deze constructie wijst u voor elke iteratie van de lus de waarde toe die wordt geretourneerd door randomFill()aan de huidige locatie van de array.

Opmerking:Uw array is double, maar u retourneert ints van randomFill. Er is dus iets dat u daar moet oplossen.

Antwoord 4, autoriteit 25%

Mensen zien de leuke coole Stream-producenten niet overal in de Java-bibliotheken.

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

Antwoord 5, autoriteit 25%

Je zou door de array kunnen lopen en in elke iteratie de randomFill-methode kunnen aanroepen. Check it out:

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

Antwoord 6, autoriteit 25%

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

Uitvoer van een proefrun:

[0.1182317850027168, 0.9437573020895418, 0.2690505524813662,
0,6771923722130754, 0,04893586074165357, 0,42483010937765653, 0,16310798731469023, 0,2541941051963008, 0,9838342001474454, 0,8595732419005068]

Als alternatief,

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

Als alternatief,

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

Antwoord 7, autoriteit 12%

Waarschijnlijk de schoonste manier om het te doen in Java 8:

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

Antwoord 8, autoriteit 12%

Ik heb geprobeerd dit zo eenvoudig mogelijk te maken in Java. Dit maakt een geheeltallige array van 100 variabelen en vult deze met gehele getallen tussen 0 en 10 met slechts drie regels code. Je kunt de grenzen van het willekeurige getal ook gemakkelijk veranderen!

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

Antwoord 9, autoriteit 12%

Snel en gemakkelijk

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

Antwoord 10, autoriteit 12%

Probeer dit:

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

Antwoord 11, Autoriteit 12%

U kunt de randomFill()-methode in een lus bellen en uw array invullen in de main()methode zoals deze.

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

U zou dan moeten gebruiken rand.nextDouble()in uw randomFill()Methode De te vullen array is een doublearray . Het onderstaande fragment moet u helpen om willekeurig te worden doublewaarden die in uw array moeten worden gevuld.

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

Antwoord 12

U kunt het eenvoudig oplossen met een 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]);
    }
}

Gebruik de volgende keer de zoekfunctie van deze site, want dit is een veel voorkomende vraag op deze site en je kunt ook veel oplossingen op Google vinden.

Antwoord 13

Als de willekeur op deze manier wordt gecontroleerd, kan er altijd een willekeurig aantal gegevenspunten van een bepaald bereik worden gegenereerd. Als de willekeurige methode in Java alleen wordt gebruikt, kunnen we niet garanderen dat alle getallen uniek zijn.

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

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

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