Java Academy · Lekcja

Losowe zakresy i tasowanie

Losowe wartości z ograniczeniem i tasowanie kolekcji

Losowe zakresy i tasowanie to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 4 lekcji w sumie.

Zakresy i tasowanie

Rzeczywiste programy rzadko potrzebują zakresu od 0 do bound-1. Ta lekcja obejmuje dowolne zakresy, losowe tasowanie kolekcji i wybieranie losowych elementów.

Wzór dla własnego zakresu

Aby wygenerować wartość int od min do max włącznie, należy użyć 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 z początkiem i granicą

Nowoczesna Java pozwala bezpośrednio wywołać nextInt(origin, bound): początek jest włączny, a granica wyłączna. Pozwala to uniknąć ręcznego stosowania wzoru.

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

Losowe wartości double w zakresie

Aby uzyskać wartość double od lo do hi, należy użyć 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);
    }
}

Tasowanie listy

Collections.shuffle(list) losowo zmienia kolejność elementów obiektu List w miejscu. Doskonale nadaje się do talii kart i losowych quizów.

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

Powtarzalne tasowanie

Aby uzyskać deterministyczne tasowanie, należy przekazać zainicjowany konkretnym ziarnem obiekt Random jako drugi argument: 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);
    }
}

Tasowanie wymaga modyfikowalnej listy

List.of(...) tworzy niezmienną listę. Próba jej tasowania zgłasza UnsupportedOperationException. Najpierw należy opakować ją w new ArrayList<>(...).

Wybieranie losowego elementu

Losowy element można wybrać, generując losowy indeks i używając metody 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);
    }
}

Tasowanie tablicy

Tablice nie mają wbudowanej funkcji tasowania. Klasycznym rozwiązaniem jest algorytm Fishera-Yatesa: każdy element należy zamienić z losowo wybranym wcześniejszym lub równym indeksem.

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

Losowe próbkowanie

Aby wylosować kilka różnych elementów, należy przetasować kopię i pobrać kilka pierwszych elementów albo użyć Set do śledzenia już wybranych indeksów. Tasowanie, a następnie wybranie fragmentu jest najprostsze w przypadku małych list.

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

Uwagi praktyczne

Należy tasować, gdy potrzebne jest pełne losowe przestawienie kolejności, a użyć własnego wzoru zakresu, gdy potrzebne są wartości ograniczone. Zawsze trzeba pamiętać o różnicy o jeden, gdy górna granica ma być włączna.

Szybkie sprawdzenie

Proszę sprawdzić swoje rozumienie zakresów i tasowania.

Podsumowanie

Nauczyli się Państwo definiować zakresy i tasować elementy.

W zakresach należy używać min + nextInt(max - min + 1) lub nextInt(origin, bound).
Collections.shuffle zmienia kolejność elementów modyfikowalnej listy w miejscu.
Użycie ziarna podczas tasowania zapewnia powtarzalność.
Losowe elementy można wybierać za pomocą losowego indeksu.

Często zadawane pytania

Czy lekcja „Losowe zakresy i tasowanie” jest bezpłatna?

Tak — pełny tekst „Losowe zakresy i tasowanie” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Losowe zakresy i tasowanie”?

Losowe wartości z ograniczeniem i tasowanie kolekcji Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Java Academy?

Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Losowe zakresy i tasowanie”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?

Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Java Academy