Newsgroup: it.comp.java
Titolo: Randomizzare chiamate di metodi HELLLLP ! ! !

Ciao a tutti... mi sono comprata un po' di libroni di Java e questa è
l'ultima cosa che vi chiedo: quando avrò una conoscenza maggiore
proverò anch'io a rispondere alle domande poste qui (per ora purtroppo
non ne sono in grado, e quindi chiedo l'ausilio di voi "macinatori di
codice"!!). La smetto con le ciance e passo al problema.....
all'interno di una  sottoclasse di Thread che possiamo chiamare
Gestore, definisco quattro metodi Funzione1 Funzione2 Funzione3 e
Funzione4.
Io vorrei poter invocare, all'interno del metodo RUN della classe
Gestore( che, ricordo, è una sottoclasse di thread e quindi RUN indica
le azioni che seguono un comando Gestore.start(). ), questi metodi in
un ordine random. Cioè vorrei poter avere per ogni esecuzione di
Gestore la possibilità di avere chiamate delle 4 funzioni in sequenze
random:     ( Funzione1-Funzione3-Funzione2-Funzione4,
Funzione3-Funzione1-Funzione4-Funzione2, eccetera...)
Come posso fare?
un GRAZIE immenso se mi poteste dare qualche "dritta" !
                     Barbara Mordenti

 un GRAZIE immenso se mi poteste dare qualche "dritta" !
Ciao.
Nel package java.util trovi l' oggetto random che puoi usare per estrarre
dei numeri random.
Poi basta che fai uno switch o una serie di else if in cui dici
if randNum == 3
    thread3.start();
Se sono stato troppo sintetico dimmelo che provo a chiarire.
Ciao

Funzione3-Funzione1-Funzione4-Funzione2, eccetera...)
Se ho ben capito dai tuoi esempi, quel che desideri e` una
_permutazione_ casuale delle quattro esecuzioni, cioe` i
quattro metodi vanno eseguiti una e una sola volta ciascuno,
ma vuoi che i quattro fattoriale == 24 possibili ordinamenti
siano tutti equiprobabili.
La generazione di numeri casuali in Java si ottiene in
due modi: la ricca classe java.util.Random(), o il semplice
metodo static random() della classe java.lang.Math; per
le tue esigenze, basta sicuramente il secondo.  Non c'e`
pero` direttamente la generazione di _permutazioni_
casuali; ma questa possiamo costruirla in vari modi,
specialmente con il noto algoritmo di "shuffling": per
avere una permutazione casuale dei numeri 0..N, a
partire da una funzione int randInt(int maxInt) che ci
torna un numero intero casuale da 0 a maxInt con
eguale probabilita`, possiamo procedere cosi`:
    -- generare un array x di N+1 int
    -- inizializzarlo ponendo i in x[i] per i in 0..N
    -- ripetere per j che scende da N a 1:
        -- generare k come randInt(j)
        -- scambiare x[j] con x[k]
La dimostrazione che questo algoritmo genera tutte
le permutazioni con eguale probabilita` (se e solo se
la randInt ritorna effettivamente una distribuzione
uniforme) e` piuttosto agevole e si fa per induzione
matematica (la dimostrazione e` piu` semplice per
la versione, trivialmente equivalente, recursiva e non
iterativa).
Per codificarlo in Java dobbiamo produrre la maxInt:
    static int randInt(int maxInt) {
        double rand = Math.random();
        return (int)(rand*(maxInt+1));
    }
(nell'ipotesi che Math.random torni un numero fra 0
compreso e 1 escluso, come mi pare sia da specifica)
e su questa base possiamo scrivere ad esempio:
    static int[] randPermut(int N) {
        // generiamo l'array 0..N
        int[] result = new int[N+1];
        // lo inizializziamo con "iota"
        int i;
        for(i=0; i<=N; ++i)
            result[i] = i;
        // generazione della permutazione
        int j;
        for(j=N; j>0; --j) {
            int k = randInt(j);
            // lo swap...:
            int temp = result[j];
            result[j] = result[k];
            result[k] = temp;
        }
        return result;
    }
Una volta ottenuta una permutazione degli indici 0..3
in un array, e` abbastanza agevole usarla, come tu
desideri, per chiamare in quel dato ordine i metodi.
Purtroppo Java non permette di fare un "array di
metodi", che offrirebbe la soluzione piu` elegante, ma
possiamo ottenere lo stesso risultato con uno switch,
ad esempio:
    void chiamaCasualmente() {
        int[] perm = randPermut(3);
        int i;
        for(i=0; i<4; ++i)
            switch(perm[i]) {
                case 0: Funzione1(); break;
                case 1: Funzione2(); break;
                case 2: Funzione3(); break;
                case 3: Funzione4(); break;
            }
    }
Facci sapere se questo tipo di approccio ti ha
permesso di risolvere il problema...!
Alex

Grazie davvero ad Alex Martelli e a Trz per le "dritte"...  Alex
addirittura mi ha pure scritto il codice necessario (e funziona tutto
alla perfezione!)
:-)
Non so proprio cosa dire, siete stati gentilissimi. 
Anzi, so cosa dire: GRAZIE !
                                             la newbie Barbara