Random

För att skapa slumpade tal så kan du använda klassen java.util.Random():

		
java.util.Random rand = new java.util.Random();

for(int i = 0; i < 100; ++i)
{
	System.out.println( (1 + rand.nextInt(40) ) );
}

Denna kod skriver ut 100 slumpade tal mellan 1-40.

Jo men problemet är att t.ex 5 kan dyka upp 2 eller t.o.m. 3ggr.

men då får du slupa ett tal, lagra den nånstans och sedan varje gång du slumpar ett nytt tal så måste du kolla om talet redan har slumptas. Ifall det har så får du slumpa fram ett nytt osv osv...

Skapa en rekursiv metod:

public class MinKlass {

private java.util.ArrayList arrayList;
private java.util.Random random;

public static void main( String[] args ) {
     new MinKlass();
}

public MinKlass() {
     this.random = new Random();
     this.arrayList = new ArrayList();
     setRandomNumbers();
     ...
}

public void setRandomNumbers() {
     for( int i = 0; i < 100; i++ ) {
          createRandomNumber();
     }
}

public void createRandomNumber() {
     int n = this.random.nextInt( 40 );

     if( this.arrayList.contains( n ) )
          createRandomNumber();
     else
          this.arrayList.add( n );
}

}

Går säkert att göra snyggare, men jag är trött just nu. ;)

Har inte sånt jätte grepp på Java än men skall se om jag får det att funka :)

För det första ska man se till att använda samma Random-objekt hela tiden (som SPiN gör), då får man bättre spridning på talen. SPiNs lösning funkar, men den är snyggare om man a) använder ett HashSet och sedan b) kollar returvärdet på add-metoden - returnerar den false finns redan objektet man försöker lägga till i den :)
Rekursion är kul men i detta fall onödigt ;)

Word, spango! Jag visste att jag missade något, det blev ju mycket bättre med HashSet. :)

Så här blev det och det verkar funka :)

import java.util.Random;
import java.util.*;

public class MyHash{
	private HashSet myHash = new HashSet();
	private Random random = new Random();
	private String myString = new String();
		
	public static void main( String[] args ) {
		new MyHash(2);
	}
	public MyHash(int value){
		for(int i=0; i<=value; i++){
			myString = String.valueOf(random.nextInt(40));
			myHash.add(myString);
		}
		displayset(myHash);
	}
	static void displayset(HashSet hs) {
		Iterator itr = hs.iterator();
		while (itr.hasNext()) {
			Object ob=itr.next();
			System.out.println(ob.toString());
		}
	}
}

För att kolla så du får ut rätt antal värden kan du lägga in en koll på att hashvärdet inte redan finns:

Ersätt:
myHash.add(myString);

Med:
if(!myHash.add(myString))
{
	i--;
}

När jag tänker efter behöver man inte utnyttja returvärdet från add... jag skulle nog gjort såhär:

import java.util.*;

public class RandomNumbers{
	private Set numbers = new HashSet();
	private Random random = new Random();
		
	public static void main( String[] args ) {
		new RandomNumbers(5, 1, 40);
	}
	public RandomNumbers(int size, int lowerBound, int upperBound){
		int genAmount = upperBound - lowerBound + 1;
		assert size <= genAmount : "för många tal";
		while(numbers.size() < size){
			int n = random.nextInt(genAmount) + lowerBound;
			numbers.add(new Integer(n));
		}
		display();
	}

	public void display() {
		System.out.println(numbers);
	}
}

Tack. Alltid är det nått man missar :)