Java Academy · Aula

Intervalos aleatórios e embaralhamento

Valores aleatórios limitados e embaralhamento de coleções.

Intervalos aleatórios e embaralhamento é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Intervalos e Embaralhamento

Programas reais raramente querem valores de 0 a bound-1. Esta lição aborda intervalos arbitrários, o embaralhamento aleatório de coleções e a escolha de elementos aleatórios.

Uma Fórmula para Intervalos Personalizados

Para produzir um int de min a max, inclusive, use 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 com Origem e Limite

O Java moderno permite chamar nextInt(origin, bound) diretamente: origin inclusivo e bound exclusivo. Isso evita a fórmula manual.

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 Aleatórios em um Intervalo

Para obter um double de lo a hi, use 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);
    }
}

Embaralhando uma Lista

Collections.shuffle(list) reorganiza aleatoriamente uma List no próprio lugar. É excelente para baralhos de cartas e questionários aleatórios.

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

Embaralhamentos Reproduzíveis

Passe um Random inicializado com uma semente como segundo argumento para obter um embaralhamento determinístico: 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);
    }
}

O Embaralhamento Precisa de uma Lista Mutável

List.of(...) cria uma lista imutável. Embaralhá-la lança UnsupportedOperationException. Primeiro, envolva-a em new ArrayList<>(...).

Escolhendo um Elemento Aleatório

Escolha um elemento aleatório gerando um índice aleatório e usando 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);
    }
}

Embaralhando um Vetor

Os vetores não têm um embaralhamento integrado. A abordagem clássica é o algoritmo de Fisher-Yates: troque cada elemento por aquele que estiver em um índice aleatório anterior ou igual.

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

Amostragem Aleatória

Para extrair vários itens distintos, embaralhe uma cópia e pegue os primeiros, ou use um Set para acompanhar os índices já escolhidos. Embaralhar e depois extrair um segmento é mais simples para listas pequenas.

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

Observações Práticas

Embaralhe quando precisar de uma reorganização aleatória completa; use uma fórmula personalizada de intervalo quando precisar de valores limitados. Lembre-se sempre do erro de um quando o limite superior deve ser inclusivo.

Verificação Rápida

Teste sua compreensão de intervalos e embaralhamento.

Recapitulação

Você aprendeu sobre intervalos e embaralhamento.

Use min + nextInt(max - min + 1) ou nextInt(origin, bound) para trabalhar com intervalos.
Collections.shuffle reorganiza uma lista mutável no próprio lugar.
Inicialize o embaralhamento com uma semente para obter reprodutibilidade.
Escolha elementos aleatórios usando um índice aleatório.

Perguntas Frequentes

A aula “Intervalos aleatórios e embaralhamento” é grátis?

Sim — o texto completo de “Intervalos aleatórios e embaralhamento” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Intervalos aleatórios e embaralhamento”?

Valores aleatórios limitados e embaralhamento de coleções. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Intervalos aleatórios e embaralhamento”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Java Academy