Java Academy · Lezione

Intervalli casuali e mescolamento

Numeri casuali con limiti e mescolamento delle raccolte

Intervalli casuali e mescolamento è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Intervalli e mescolamento

Nei programmi reali, raramente si desiderano valori da 0 a bound-1. Questa lezione tratta gli intervalli arbitrari, il mescolamento casuale delle collezioni e la scelta di elementi casuali.

Una formula per un intervallo personalizzato

Per produrre un int da min a max inclusi, utilizzi min + rng.nextInt(max - min + 1).

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        Random rng = new Random();
        int min = 10, max = 20;
        int value = min + rng.nextInt(max - min + 1);
        System.out.println("10 to 20: " + value);
    }
}

nextInt con origine e limite

Le versioni moderne di Java consentono di chiamare direttamente nextInt(origin, bound): l'origine è inclusa e il limite è escluso. In questo modo si evita la formula manuale.

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        Random rng = new Random();
        int value = rng.nextInt(10, 21);
        System.out.println("10 to 20: " + value);
    }
}

Double casuali in un intervallo

Per ottenere un double da lo a hi, utilizzi lo + rng.nextDouble() * (hi - lo).

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        Random rng = new Random();
        double lo = 5.0, hi = 7.5;
        double value = lo + rng.nextDouble() * (hi - lo);
        System.out.println(value);
    }
}

Mescolare una lista

Collections.shuffle(list) riordina casualmente una List direttamente. È ideale per mazzi di carte e quiz randomizzati.

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> deck = new ArrayList<>(List.of(1, 2, 3, 4, 5));
        Collections.shuffle(deck);
        System.out.println(deck);
    }
}

Mescolamenti riproducibili

Passi un Random inizializzato con un seme come secondo argomento per ottenere un mescolamento deterministico: Collections.shuffle(list, new Random(seed)).

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

public class Main {
    public static void main(String[] args) {
        List<Integer> deck = new ArrayList<>(List.of(1, 2, 3, 4, 5));
        Collections.shuffle(deck, new Random(99));
        System.out.println(deck);
    }
}

Per il mescolamento serve una lista modificabile

List.of(...) crea una lista immutabile. Il mescolamento genera UnsupportedOperationException. La racchiuda prima in new ArrayList<>(...).

Scegliere un elemento casuale

Scelga un elemento casuale generando un indice casuale e utilizzando get.

import java.util.List;
import java.util.Random;

public class Main {
    public static void main(String[] args) {
        List<String> colors = List.of("red", "green", "blue");
        Random rng = new Random();
        String pick = colors.get(rng.nextInt(colors.size()));
        System.out.println("Chosen: " + pick);
    }
}

Mescolare un array

Gli array non dispongono di un mescolamento integrato. L'approccio classico è l'algoritmo di Fisher-Yates: scambi ogni elemento con un indice precedente o uguale scelto casualmente.

import java.util.Arrays;
import java.util.Random;

public class Main {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        Random rng = new Random(3);
        for (int i = arr.length - 1; i > 0; i--) {
            int j = rng.nextInt(i + 1);
            int tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
        }
        System.out.println(Arrays.toString(arr));
    }
}

Campionamento casuale

Per estrarre diversi elementi distinti, mescoli una copia e prenda i primi, oppure utilizzi un Set per tenere traccia degli indici già scelti. Mescolare e poi prendere una porzione è la soluzione più semplice per le liste piccole.

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> pool = new ArrayList<>(List.of(1, 2, 3, 4, 5, 6, 7, 8));
        Collections.shuffle(pool);
        List<Integer> sample = pool.subList(0, 3);
        System.out.println("Sample: " + sample);
    }
}

Note pratiche

Mescoli quando Le serve un riordinamento casuale completo; utilizzi una formula personalizzata per l'intervallo quando Le servono valori entro determinati limiti. Ricordi sempre l'errore off-by-one quando il limite superiore deve essere incluso.

Verifica rapida

Verifichi la Sua comprensione degli intervalli e del mescolamento.

Riepilogo

Ha imparato a usare gli intervalli e a mescolare gli elementi.

Utilizzi min + nextInt(max - min + 1) o nextInt(origin, bound) per gli intervalli.
Collections.shuffle riordina direttamente una lista modificabile.
Inizializzi il mescolamento con un seme per renderlo riproducibile.
Scelga gli elementi casuali tramite un indice casuale.

Domande Frequenti

La lezione «Intervalli casuali e mescolamento» è gratuita?

Sì — il testo completo di «Intervalli casuali e mescolamento» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Intervalli casuali e mescolamento»?

Numeri casuali con limiti e mescolamento delle raccolte Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Intervalli casuali e mescolamento»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Java Academy