Java - SuperEnalotto su console

Attraverso un numero n di elementi numerici, devo fare un random del numero di gruppi g di sestine di quel vettore vett.
io ho partorito questo, ma mi potete spiegare perché non va
Comunque anche se avete una soluzione spartana la accetto comunque perché mi serve come punto di inizio per un altro progetto!!

/**
 * @(#)SuperEnalotto.java
 *
 * SuperEnalotto application
 *
 * @author bububs
 * @version 1.00 2010/10/28
 */
import java.util.*;
import java.io.*;
import javax.swing.*;

public class SuperEnalotto{
	private static int n;
	private static int[] vett;
	private static Vector<Integer> rand;
    
    public static void main(String[] args){
    	Scanner tastiera=new Scanner(System.in);
    	System.out.println("\t\t\t\t\t\t\t\t\t\t\t\tEstrazioni SuperEnalotto  -  Created  by Bubu_93\n");
    	rand=new Vector<Integer>();
    	System.out.print("Inserisci i numeri su cui fare riferimento per l'estrazione:  ");
    	n=Integer.parseInt(tastiera.nextLine());
    	if(n>0){
    		vett=new int[n];
    		for(int i=0; i<n; i++){
		    	System.out.print("Inserisci il "+(i+1)+"° numero:  ");
		    	vett[i]=Integer.parseInt(tastiera.nextLine());
    		}
	    	System.out.print("Inserisci il numero di sestine totali:  ");
	    	int g=Integer.parseInt(tastiera.nextLine());
	    	int cont=-1;
	    	if(g>0){
	    		for(int i=0; i<g; i++){
    				System.out.println("\n>>>>>>>>>>>>>>  Sestina N°: "+(i+1));
    				for(int j=0; j<6; j++){
    					cont++;
	    				rand.addElement(vett[generaSestina(j,cont-1)]);
    					System.out.print(rand.get(cont)+"  ");
    				}
	    			System.out.println("");
	    		}
	    		System.exit(0);
	    	}
	    	else{
	    		System.out.println("\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tNumero non valido\n");
	    	}
    	}
    	else{
    		System.out.println("\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tNumero non valido\n");
    	}
    }
    
    public static int generaSestina(int j, int pos){
    	int cas=0;
    	if(j==0){
    		JOptionPane.showMessageDialog(null,pos);
    		cas=new Random().nextInt(n);
    	}
    	else if(j==1){
    		JOptionPane.showMessageDialog(null,pos);
		    while(true){
	    		cas=new Random().nextInt(n);
	    		int prec1=rand.get(pos);
		        if(cas!=prec1){
					break;
				}
		    }
    	}
    	else if(j==2){
    		JOptionPane.showMessageDialog(null,pos);
		    while(true){
	    		cas=new Random().nextInt(n);
	    		int prec1=rand.get(pos);
	    		int prec2=rand.get(pos-1);
		        if(cas!=prec1 && cas!=prec2){
					break;
				}
		    }
    	}
    	else if(j==3){
    		JOptionPane.showMessageDialog(null,pos);
		    while(true){
	    		cas=new Random().nextInt(n);
	    		int prec1=rand.get(pos);
	    		int prec2=rand.get(pos-1);
	    		int prec3=rand.get(pos-2);
		        if(cas!=prec1 && cas!=prec2 && cas!=prec3){
					break;
				}
		    }
    	}
    	else if(j==4){
    		JOptionPane.showMessageDialog(null,pos);
		    while(true){
	    		cas=new Random().nextInt(n);
	    		int prec1=rand.get(pos);
	    		int prec2=rand.get(pos-1);
	    		int prec3=rand.get(pos-2);
	    		int prec4=rand.get(pos-3);
		        if(cas!=prec1 && cas!=prec2 && cas!=prec3 && cas!=prec4){
					break;
				}
		    }
    	}
    	else if(j==5){
    		JOptionPane.showMessageDialog(null,pos);
		    while(true){
	    		cas=new Random().nextInt(n);
	    		int prec1=rand.get(pos);
	    		int prec2=rand.get(pos-1);
	    		int prec3=rand.get(pos-2);
	    		int prec4=rand.get(pos-3);
	    		int prec5=rand.get(pos-4);
		        if(cas!=prec1 && cas!=prec2 && cas!=prec3 && cas!=prec4 && cas!=prec5){
					break;
				}
		    }
    	}
	    return cas;
    }
}

Mi permetto di stravolgere il codice. Innanzitutto ti conviene creare una classe estrattrice al quale bisogna passare in input l'array di interi dal quale estrarre.

Comunque ecco il codice della classe. Per provare ho creato un array di base con i numeri da 1 a 90 e ho fatto estrarre 6 sestine:

import java.util.Random;

public class Estrattore {

    private int[] base;
    private boolean[] scelti;

    public Estrattore(int[] pBase) {
        this.base = new int[pBase.length];
        this.scelti = new boolean[pBase.length];
        System.arraycopy(pBase, 0, this.base, 0, pBase.length);
    }

    public int[] estrai(int pNum) {
        if (pNum > this.base.length) {
            throw new IllegalArgumentException("Impossibile estrarre un array casuale più grande dell'array di base");
        }
        int[] retval = new int[pNum];
        Random rand = new Random();
        int random = 0;
        for (int i = 0; i < pNum; i++) {
            do {
                random = rand.nextInt(this.base.length);
            } while (this.scelti[random]);
            retval[i] = this.base[random];
            this.scelti[random] = true;
        }
        return retval;
    }

    public void resetScelti(){
        this.scelti=new boolean[this.base.length];
    }

    public static void main(String... args) {
        int[] base = new int[90];
        for (int i = 0; i < 90; i++) {
            base[i] = i + 1;
        }
        Estrattore estrai = new Estrattore(base);
        int[] ret= new int[6];
        for (int i = 0; i < 6; i++) {
            ret=estrai.estrai(ret.length);
            System.out.print("Sestina numero "+(i+1)+": ");
            for (int j = 0; j < ret.length; j++) {
                System.out.print(ret[j] + " ");
            }
            System.out.println();
            estrai.resetScelti();
        }
    }
}

Come puoi vedere usa una matrice di booleani per controllare che un dato valore non sia scelto due volte e lancia una eccezione nel caso in cui si richieda al programma di estrarre un'array di valori casuali più grande dell'array di base (difatti in questo modo potrai anche farti estrarre più o meno di 6 numeri). Inoltre dopo ogni sestina fa il reset dei numeri scelti in modo che possa scegliere nuovamente un numero.

Ti ringrazio vivamente!!

Di nulla!!

Ciao, so che è un post vecchio, ma l'ho trovato solo ora

Avrei solo un domanda, il metodo che viene usato (da quanto ho capito è "random" per avere le combinazioni di numeri, può restituire combinazioni uguali?
Mi spiego meglio, se imposto 1.000.000 di righe saranno sicuramente combinazioni differenti tra loro o può capitare che ce ne siano di uguali?


Grazie 1000!

è probabile che ne escano di uguali, più sono le sestine estratte e maggiore sarà la probabilità che ne esca una uguale.

Grazie per la risposta!
Ci sono altri metodi che posso garantire che le combinazioni siano tutte diverse tra loro?

Grazie!

basta inserire un controllo sulle sestine estratte