Java Academy · Leçon

Plages aléatoires et mélange

Valeurs aléatoires bornées et mélange de collections

Plages aléatoires et mélange est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Plages et mélange

Les programmes réels veulent rarement une valeur de 0 à bound-1. Cette leçon couvre les plages arbitraires, le mélange aléatoire des collections et la sélection d’éléments aléatoires.

Formule pour une plage personnalisée

Pour produire un int compris entre min et max, bornes incluses, utilisez 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 avec une origine et une borne

Les versions modernes de Java permettent d’appeler directement nextInt(origin, bound) : l’origine est incluse et la borne est exclue. Cela évite la formule manuelle.

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

Doubles aléatoires dans une plage

Pour obtenir un double entre lo et hi, utilisez 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);
    }
}

Mélanger une liste

Collections.shuffle(list) réordonne aléatoirement une List sur place. C’est idéal pour les jeux de cartes et les questionnaires aléatoires.

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

Mélanges reproductibles

Transmettez un générateur aléatoire initialisé avec une graine comme deuxième argument pour obtenir un mélange déterministe : 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);
    }
}

Le mélange nécessite une liste modifiable

List.of(...) crée une liste immuable. La mélanger lève une UnsupportedOperationException. Encapsulez-la d’abord dans new ArrayList<>(...).

Sélectionner un élément aléatoire

Choisissez un élément aléatoire en générant un indice aléatoire et en utilisant 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);
    }
}

Mélanger un tableau

Les tableaux ne disposent d’aucune fonction de mélange intégrée. L’approche classique est l’algorithme de Fisher-Yates : échangez chaque élément avec un indice aléatoire antérieur ou égal.

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

Échantillonnage aléatoire

Pour tirer plusieurs éléments distincts, mélangez une copie et prenez les premiers, ou utilisez un Set pour suivre les indices déjà sélectionnés. Mélanger puis extraire une portion est la solution la plus simple pour les petites listes.

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

Remarques pratiques

Mélangez lorsque vous avez besoin d’un réordonnancement entièrement aléatoire ; utilisez une formule de plage personnalisée lorsque vous avez besoin de valeurs bornées. N’oubliez jamais le décalage d’une unité lorsque la borne supérieure doit être incluse.

Vérification rapide

Vérifiez votre compréhension des plages et du mélange.

Récapitulatif

Vous avez appris à utiliser les plages et le mélange.

Utilisez min + nextInt(max - min + 1) ou nextInt(origin, bound) pour créer des plages.
Collections.shuffle réordonne sur place une liste modifiable.
Initialisez le mélange avec une graine pour le rendre reproductible.
Sélectionnez des éléments aléatoires au moyen d’un indice aléatoire.

Questions Fréquemment Posées

La leçon « Plages aléatoires et mélange » est-elle gratuite ?

Oui — le texte complet de « Plages aléatoires et mélange » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Plages aléatoires et mélange » ?

Valeurs aléatoires bornées et mélange de collections Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Plages aléatoires et mélange » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Java Academy