shuffle(List<?> list, Random rnd)
/**
* Randomly permute the specified list using the specified source of
* randomness. All permutations occur with equal likelihood
* assuming that the source of randomness is fair.<p>
*
* This implementation traverses the list backwards, from the last element
* up to the second, repeatedly swapping a randomly selected element into
* the "current position". Elements are randomly selected from the
* portion of the list that runs from the first element to the current
* position, inclusive.<p>
*
* This method runs in linear time. If the specified list does not
* implement the {@link RandomAccess} interface and is large, this
* implementation dumps the specified list into an array before shuffling
* it, and dumps the shuffled array back into the list. This avoids the
* quadratic behavior that would result from shuffling a "sequential
* access" list in place.
*
* @param list the list to be shuffled.
* @param rnd the source of randomness to use to shuffle the list.
* @throws UnsupportedOperationException if the specified list or its
* list-iterator does not support the <tt>set</tt> operation.
*/
public static void shuffle(List<?> list, Random rnd) {
int size = list.size();
if (size < SHUFFLE_THRESHOLD || list instanceof RandomAccess) {
for (int i=size; i>1; i--)
swap(list, i-1, rnd.nextInt(i));
} else {
Object[] arr = list.toArray();
// Shuffle array
for (int i=size; i>1; i--)
swap(arr, i-1, rnd.nextInt(i));
// Dump array back into list
// instead of using a raw type here, it's possible to capture
// the wildcard but it will require a call to a supplementary
// private method
ListIterator it = list.listIterator();
for (int i=0; i<arr.length; i++) {
it.next();
it.set(arr[i]);
}
}
}
使用指定的随机源随机排列指定的列表。假设随机性来源是公平的，所有排列都以相同的可能性发生。
此实现向后遍历列表，从最后一个元素到第二个元素，反复将随机选择的元素交换到“当前位置”。元素是从列表中从第一个元素到当前位置（含）的部分中随机选择的。
该方法以线性时间运行。如果指定的列表未实现 {@link RandomAccess} 接口并且很大，则此实现会在打乱指定列表之前将其转储到数组中，并将打乱后的数组转储回列表中。这避免了因对“顺序访问”列表进行改组而导致的二次行为。
@param list 要洗牌的列表。
@param rnd 用于洗牌列表的随机性来源。
如果指定的列表或其列表迭代器不支持 set 操作，则抛出 UnsupportedOperationException。
shuffle(List<?> list)
/**
* Randomly permutes the specified list using a default source of
* randomness. All permutations occur with approximately equal
* likelihood.
*
* <p>The hedge "approximately" is used in the foregoing description because
* default source of randomness is only approximately an unbiased source
* of independently chosen bits. If it were a perfect source of randomly
* chosen bits, then the algorithm would choose permutations with perfect
* uniformity.
*
* <p>This implementation traverses the list backwards, from the last
* element up to the second, repeatedly swapping a randomly selected element
* into the "current position". Elements are randomly selected from the
* portion of the list that runs from the first element to the current
* position, inclusive.
*
* <p>This method runs in linear time. If the specified list does not
* implement the {@link RandomAccess} interface and is large, this
* implementation dumps the specified list into an array before shuffling
* it, and dumps the shuffled array back into the list. This avoids the
* quadratic behavior that would result from shuffling a "sequential
* access" list in place.
*
* @param list the list to be shuffled.
* @throws UnsupportedOperationException if the specified list or
* its list-iterator does not support the <tt>set</tt> operation.
*/
public static void shuffle(List<?> list) {
Random rnd = r;
if (rnd == null)
r = rnd = new Random(); // harmless race.
shuffle(list, rnd);
}
使用默认的随机源随机排列指定的列表。所有排列发生的可能性大致相等。
在前面的描述中使用对冲“大约”是因为默认的随机性源仅大约是独立选择的位的无偏源。如果它是随机选择位的完美来源，那么算法将选择具有完美均匀性的排列。
此实现向后遍历列表，从最后一个元素到第二个元素，反复将随机选择的元素交换到“当前位置”。元素是从列表中从第一个元素到当前位置（含）的部分中随机选择的。
该方法以线性时间运行。如果指定的列表未实现 {@link RandomAccess} 接口并且很大，则此实现会在打乱指定列表之前将其转储到数组中，并将打乱后的数组转储回列表中。这避免了因对“顺序访问”列表进行改组而导致的二次行为。
@param list 要洗牌的列表。
如果指定的列表或其列表迭代器不支持 set 操作，则抛出 UnsupportedOperationException。
使用示例
- 示例代码
public static void main(String[] args){
Random rand=new Random(47);
Integer[] ia={0,1,2,3,4,5,6,7,8,9};
List<Integer> list=new ArrayList<Integer>(Arrays.asList(ia));
System.out.println("Before shufflig: "+list);
Collections.shuffle(list,rand);
System.out.println("After shuffling: "+list);
System.out.println("array: "+Arrays.toString(ia));
List<Integer> list1=Arrays.asList(ia);
System.out.println("Before shuffling: "+list1);
Collections.shuffle(list1,rand);
System.out.println("After shuffling: "+list1);
System.out.println("array: "+Arrays.toString(ia));
}
- 运行结果
Before shufflig: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
After shuffling: [3, 5, 2, 0, 7, 6, 1, 4, 9, 8]
array: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Before shuffling: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
After shuffling: [8, 0, 5, 2, 6, 1, 4, 9, 3, 7]
array: [8, 0, 5, 2, 6, 1, 4, 9, 3, 7]
