Java Academy · Lección

Rangos aleatorios y mezclado

Valores aleatorios acotados y mezclado de colecciones

Rangos aleatorios y mezclado es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

Rangos y barajado

En los programas reales, rara vez se necesita el rango del 0 a bound-1. Esta lección aborda rangos arbitrarios, el barajado aleatorio de colecciones y la selección de elementos aleatorios.

Una fórmula para rangos personalizados

Para producir un int desde min hasta max, ambos incluidos, 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 con origen y límite

Las versiones modernas de Java permiten invocar directamente nextInt(origin, bound): el origen está incluido y el límite, excluido. Así se evita la 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 aleatorios en un rango

Para obtener un double desde lo hasta 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);
    }
}

Barajar una lista

Collections.shuffle(list) reordena aleatoriamente una List directamente. Es muy útil para barajas de cartas y cuestionarios aleatorios.

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

Barajados reproducibles

Pase un Random inicializado con una semilla como segundo argumento para obtener un barajado determinista: 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);
    }
}

Para barajar se necesita una lista mutable

List.of(...) crea una lista inmutable. Al intentar barajarla se lanza UnsupportedOperationException. Envuélvala primero en new ArrayList<>(...).

Seleccionar un elemento aleatorio

Elija un elemento aleatorio generando un índice aleatorio y 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);
    }
}

Barajar un array

Los arrays no tienen un método de barajado integrado. El enfoque clásico es el algoritmo de Fisher-Yates: intercambiar cada elemento con un índice anterior o igual elegido al azar.

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

Muestreo aleatorio

Para extraer varios elementos distintos, baraje una copia y tome los primeros, o use un Set para llevar el control de los índices ya elegidos. Barajar y después tomar un segmento es lo más sencillo para listas pequeñas.

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

Notas prácticas

Baraje cuando necesite un reordenamiento aleatorio completo; use una fórmula de rango personalizada cuando necesite valores limitados. Recuerde siempre el desfase de uno cuando el límite superior deba estar incluido.

Comprobación rápida

Compruebe su comprensión de los rangos y el barajado.

Repaso

Aprendió sobre rangos y barajado.

Use min + nextInt(max - min + 1) o nextInt(origin, bound) para trabajar con rangos.
Collections.shuffle reordena directamente una lista mutable.
Inicialice el barajado con una semilla para que sea reproducible.
Seleccione elementos aleatorios mediante un índice aleatorio.

Preguntas frecuentes

¿La lección «Rangos aleatorios y mezclado» es gratis?

Sí — el texto completo de «Rangos aleatorios y mezclado» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Rangos aleatorios y mezclado»?

Valores aleatorios acotados y mezclado de colecciones Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Rangos aleatorios y mezclado»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Java Academy