Java Academy · Lektion

Slumpintervall och blandning

Begränsade slumptal och blandning av samlingar.

Lektion 3 av 413 steg

Slumpintervall och blandning är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 4 lektioner.

Intervall och blandning

I riktiga program vill man sällan ha värden från 0 till bound-1. Den här lektionen behandlar godtyckliga intervall, hur samlingar blandas slumpmässigt och hur slumpmässiga element väljs.

En anpassad intervallformel

Om du vill generera ett int från min till och med max använder du 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 med start och gräns

I moderna Java kan du anropa nextInt(origin, bound) direkt: startvärdet är inkluderat och gränsen är exkluderad. Då slipper du den manuella formeln.

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

Slumpmässiga doublevärden i ett intervall

För ett double-värde från lo till hi använder du 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);
    }
}

Blanda en lista

Collections.shuffle(list) ändrar ordningen på en List slumpmässigt och på plats. Det passar utmärkt för kortlekar och slumpmässiga frågesporter.

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

Reproducerbar blandning

Skicka ett Random med seed som andra argument för att få en deterministisk blandning: 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);
    }
}

Blandning kräver en muterbar lista

List.of(...) skapar en oföränderlig lista. Om du försöker blanda den kastas UnsupportedOperationException. Omslut den först med new ArrayList<>(...).

Välja ett slumpmässigt element

Välj ett slumpmässigt element genom att generera ett slumpmässigt index och använda 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);
    }
}

Blanda en array

Arrayer har ingen inbyggd blandningsmetod. Det klassiska tillvägagångssättet är Fisher-Yates-algoritmen: byt varje element mot ett slumpmässigt tidigare eller lika stort index.

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

Slumpmässigt urval

Om du vill välja flera unika element kan du blanda en kopia och ta de första, eller använda en Set för att hålla reda på redan valda index. Att blanda och sedan ta en del är enklast för små listor.

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

Praktiska råd

Blanda när du behöver en fullständig slumpmässig omordning, och använd en anpassad intervallformel när du behöver begränsade värden. Kom alltid ihåg skillnaden med ett steg när den övre gränsen ska vara inkluderande.

Snabbtest

Testa dina kunskaper om intervall och blandning.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Du har lärt dig om intervall och blandning.

Använd min + nextInt(max - min + 1) eller nextInt(origin, bound) för intervall.
Collections.shuffle ändrar ordningen på en muterbar lista på plats.
Initiera blandningen med ett seed för reproducerbarhet.
Välj slumpmässiga element via ett slumpmässigt index.

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 104
Lektioner: 374

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Slumpintervall och blandning” gratis?

Ja – hela texten till ”Slumpintervall och blandning” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Slumpintervall och blandning”?

Begränsade slumptal och blandning av samlingar. Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Java Academy?

Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Slumpintervall och blandning”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Java Academy-lektionen?

Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Java Academy