golang和java中的shuffle

a := []int{1, 2, 3, 4, 5, 6, 7, 8}
rand.Seed(time.Now().UnixNano())
rand.Shuffle(len(a), func(i, j int) { a[i], a[j] = a[j], a[i] })

[5 8 6 4 3 7 2 1]

// Shuffle pseudo-randomizes the order of elements.
// n is the number of elements. Shuffle panics if n < 0.
// swap swaps the elements with indexes i and j.
func (r *Rand) Shuffle(n int, swap func(i, j int)) {
	if n < 0 {
		panic("invalid argument to Shuffle")
	}

	// Fisher-Yates shuffle: https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle
	// Shuffle really ought not be called with n that doesn't fit in 32 bits.
	// Not only will it take a very long time, but with 2³¹! possible permutations,
	// there's no way that any PRNG can have a big enough internal state to
	// generate even a minuscule percentage of the possible permutations.
	// Nevertheless, the right API signature accepts an int n, so handle it as best we can.
	i := n - 1
	for ; i > 1<<31-1-1; i-- {
		j := int(r.Int63n(int64(i + 1)))
		swap(i, j)
	}
	for ; i > 0; i-- {
		j := int(r.int31n(int32(i + 1)))
		swap(i, j)
	}
}

public static void shuffle(List<?> list) {
    Random rnd = r;
    if (rnd == null) {
        r = rnd = new Random();
    }

    shuffle(list, rnd);
}

public static void shuffle(List<?> list, Random rnd) {
    int size = list.size();
    if (size >= 5 && !(list instanceof RandomAccess)) {
        Object[] arr = list.toArray();

        for(int i = size; i > 1; --i) {
            swap(arr, i - 1, rnd.nextInt(i));
        }

        ListIterator it = list.listIterator();

        for(int i = 0; i < arr.length; ++i) {
            it.next();
            it.set(arr[i]);
        }
    } else {
        for(int i = size; i > 1; --i) {
            swap(list, i - 1, rnd.nextInt(i));
        }
    }

}