Java Academy · Lektion

Zufallsbereiche und Mischen

Begrenzte Zufallszahlen und das Mischen von Collections

Zufallsbereiche und Mischen ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Bereiche und Mischen

In echten Programmen werden selten nur Werte von 0 bis bound-1 benötigt. In dieser Lektion geht es um beliebige Bereiche, das zufällige Mischen von Collections und die Auswahl zufälliger Elemente.

Eine Formel für benutzerdefinierte Bereiche

Um einen int-Wert von min bis einschließlich max zu erzeugen, verwenden Sie 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 mit Start- und Endgrenze

Modernes Java ermöglicht den direkten Aufruf von nextInt(origin, bound): origin ist inklusive, bound exklusive. Dadurch vermeiden Sie die manuelle Formel.

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

Zufällige Double-Werte in einem Bereich

Für einen double-Wert von lo bis hi verwenden Sie 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);
    }
}

Eine Liste mischen

Collections.shuffle(list) bringt eine List direkt im Array zufällig in eine neue Reihenfolge. Das eignet sich hervorragend für Kartenstapel und zufällig angeordnete Quizfragen.

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

Reproduzierbares Mischen

Übergeben Sie als zweites Argument ein initialisiertes Random-Objekt, um ein deterministisches Mischen zu erhalten: 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);
    }
}

Zum Mischen wird eine veränderliche Liste benötigt

List.of(...) erstellt eine unveränderliche Liste. Beim Mischen wird UnsupportedOperationException ausgelöst. Verpacken Sie die Liste zuerst in new ArrayList<>(...).

Ein zufälliges Element auswählen

Wählen Sie ein zufälliges Element aus, indem Sie einen zufälligen Index erzeugen und get verwenden.

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

Ein Array mischen

Arrays verfügen über keine integrierte Mischfunktion. Der klassische Ansatz ist der Fisher-Yates-Algorithmus: Vertauschen Sie jedes Element mit einem zufälligen Index, der kleiner oder gleich dem aktuellen Index ist.

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

Zufällige Stichproben

Um mehrere verschiedene Elemente auszuwählen, mischen Sie eine Kopie und nehmen die ersten Elemente oder verwenden Sie ein Set, um bereits ausgewählte Indizes zu speichern. Für kleine Listen ist das Mischen mit anschließendem Ausschneiden am einfachsten.

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

Praktische Hinweise

Mischen Sie, wenn Sie eine vollständige zufällige Neuordnung benötigen; verwenden Sie eine eigene Bereichsformel, wenn Sie Werte innerhalb von Grenzen brauchen. Denken Sie immer an den Off-by-one-Fehler, wenn die obere Grenze inklusive sein soll.

Kurzer Test

Testen Sie Ihr Verständnis von Bereichen und dem Mischen.

Zusammenfassung

Sie haben Bereiche und das Mischen kennengelernt.

Verwenden Sie min + nextInt(max - min + 1) oder nextInt(origin, bound) für Bereiche.
Collections.shuffle ordnet eine veränderliche Liste direkt neu an.
Initialisieren Sie den Zufallsgenerator für reproduzierbares Mischen mit einem Startwert.
Wählen Sie zufällige Elemente über einen zufälligen Index aus.

Häufig gestellte Fragen

Ist die Lektion „Zufallsbereiche und Mischen“ kostenlos?

Ja — der vollständige Text von „Zufallsbereiche und Mischen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Zufallsbereiche und Mischen“?

Begrenzte Zufallszahlen und das Mischen von Collections Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Zufallsbereiche und Mischen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Java Academy