实现完美洗牌的10个Java函数

1. Fisher–Yates shuffle 算法

Fisher-Yates 算法也被称为 Knuth-Shuffle 算法，是一种无偏的洗牌算法。它的实现如下：

public static void fisherYatesShuffle(int[] arr) {
    Random rand = ThreadLocalRandom.current();
    for (int i = arr.length - 1; i > 0; i--) {
        int j = rand.nextInt(i + 1);
        swap(arr, i, j);
    }
}

private static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

2. Knuth shuffle 算法

Knuth shuffle 算法也是一种无偏的洗牌算法。它的实现如下：

public static void knuthShuffle(int[] arr) {
    Random rand = ThreadLocalRandom.current();
    for (int i = 0; i < arr.length; i++) {
        int j = rand.nextInt(i + 1);
        swap(arr, i, j);
    }
}

private static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

3. Durstenfeld shuffle 算法

Durstenfeld 算法是 Fisher-Yates 算法的一种变体，它将交换操作移到了循环的起始处。它的实现如下：

public static void durstenfeldShuffle(int[] arr) {
    Random rand = ThreadLocalRandom.current();
    for (int i = arr.length - 1; i > 0; i--) {
        int j = rand.nextInt(i + 1);
        if (i != j) {
            swap(arr, i, j);
        }
    }
}

private static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

4. Collections shuffle() 方法

Java 的标准库提供了一个实现洗牌的方法 Collections.shuffle()，它的实现如下：

public static void collectionsShuffle(List<?> list) {
    Random rand = ThreadLocalRandom.current();
    for (int i = list.size() - 1; i > 0; i--) {
        int j = rand.nextInt(i + 1);
        Collections.swap(list, i, j);
    }
}

5. Apache Commons Collections shuffle() 方法

Apache Commons Collections 是 Apache 基金会的一个开源项目，提供了一系列实用的工具类和数据结构。它的 shuffle() 方法实现了洗牌操作：

public static void apacheShuffle(List<?> list) {
    Random rand = ThreadLocalRandom.current();
    Collections.shuffle(list, rand);
}

6. Guava shuffle() 方法

Guava 是 Google 的一个开源项目，它的 shuffle() 方法实现了洗牌操作：

public static void guavaShuffle(List<?> list) {
    Random rand = ThreadLocalRandom.current();
    Collections.shuffle(list, rand);
}

7. Math.random() 方法

Math.random() 是 Java 标准库提供的一个随机数生成方法，它可以用来实现洗牌操作：

public static void mathRandomShuffle(int[] arr) {
    for (int i = arr.length - 1; i > 0; i--) {
        int j = (int)(Math.random() * (i + 1));
        swap(arr, i, j);
    }
}

private static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

8. SecureRandom 方法

SecureRandom 是 Java 标准库提供的一个安全的随机数生成器，它可以用于实现洗牌操作：

public static void secureRandomShuffle(int[] arr) {
    SecureRandom rand = new SecureRandom();
    for (int i = arr.length - 1; i > 0; i--) {
        int j = rand.nextInt(i + 1);
        swap(arr, i, j);
    }
}

private static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

9. XORShift 算法

XORShift 算法是一种高效的伪随机数生成算法，可以用于实现洗牌操作：

public static void xorShiftShuffle(int[] arr) {
    int seed = (int) System.currentTimeMillis();
    for (int i = arr.length - 1; i > 0; i--) {
        seed ^= (seed << 13);
        seed ^= (seed >>> 17);
        seed ^= (seed << 5);
        int j = seed % (i + 1);
        if (j < 0) j += (i + 1);
        swap(arr, i, j);
    }
}

private static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

10. Mersenne Twister 算法

Mersenne Twister 算法是一种高效而准确的伪随机数生成算法，可以用于实现洗牌操作：

public static void mersenneTwisterShuffle(int[] arr) {
    MersenneTwister rand = new MersenneTwister();
    for (int i = arr.length - 1; i > 0; i--) {
        int j = rand.nextInt(i + 1);
        swap(arr, i, j);
    }
}

private static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}