int[] solutionArray = {1, 2, 3, 4, 5, 6, 6, 5, 4, 3, 2, 1};
有没有函数可以做到这一点？
#1 楼
使用Collections改组原始类型的数组是有点过头了...它很容易自己实现，例如使用Fisher-Yates shuffle：
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
class Test
{
public static void main(String args[])
{
int[] solutionArray = { 1, 2, 3, 4, 5, 6, 16, 15, 14, 13, 12, 11 };
shuffleArray(solutionArray);
for (int i = 0; i < solutionArray.length; i++)
{
System.out.print(solutionArray[i] + " ");
}
System.out.println();
}
// Implementing Fisher–Yates shuffle
static void shuffleArray(int[] ar)
{
// If running on Java 6 or older, use `new Random()` on RHS here
Random rnd = ThreadLocalRandom.current();
for (int i = ar.length - 1; i > 0; i--)
{
int index = rnd.nextInt(i + 1);
// Simple swap
int a = ar[index];
ar[index] = ar[i];
ar[i] = a;
}
}
}
评论
最好使用Collections.shuffle（Arrays.asList（array））;然后洗牌。
–路易·洪
13年5月5日，0：12
@Louie Collections.shuffle（Arrays.asList（array））不起作用，因为Arrays.asList（array）返回Collection
–亚当·斯泰尔马斯奇克（Adam Stelmaszczyk）
2013年12月13日在12:33
@exhuma因为如果要排序的数组包含成千上万个原始值，那么在内存和CPU中将每个值包装到一个对象中只是为了进行排序会有点昂贵。
– PhiLho
2014年7月11日在11:11
这不是费舍尔·耶茨的洗牌。这称为Durstenfeld随机播放。原始的费舍尔-耶夫斯洗牌时间为O（n ^ 2），这非常慢。
–起搏器
14-10-31在12:39
@ ShoeLace1291如果我没记错的话，那你就不能用Java：没有一种方法可以使方法与原语（int）和对象（string）通用。您必须复制它。
– PhiLho
16-10-28在10:24
#2 楼
这是使用ArrayList的简单方法：List<Integer> solution = new ArrayList<>();
for (int i = 1; i <= 6; i++) {
solution.add(i);
}
Collections.shuffle(solution);
评论
您可以简单地Collectons.shuffle（Arrays.asList（solutionArray））;
–FindOutIslamNow
1月23日4:08
@Timmos你错了。 Arrays.asList环绕原始数组，因此对其进行修改将修改原始数组。这就是为什么不能添加或删除的原因，因为数组是固定大小的。
–土地
6月7日11:45
@不知道我在想什么，但是看看源代码，实际上Arrays.asList方法创建了一个由给定数组支持的ArrayList。感谢您指出。删除了我之前的评论（无法编辑）。
–提摩斯
6月8日12:25
#3 楼
这是一个有效且有效的Fisher–Yates随机播放数组函数：private static void shuffleArray(int[] array)
{
int index;
Random random = new Random();
for (int i = array.length - 1; i > 0; i--)
{
index = random.nextInt(i + 1);
if (index != i)
{
array[index] ^= array[i];
array[i] ^= array[index];
array[index] ^= array[i];
}
}
}
或
private static void shuffleArray(int[] array)
{
int index, temp;
Random random = new Random();
for (int i = array.length - 1; i > 0; i--)
{
index = random.nextInt(i + 1);
temp = array[index];
array[index] = array[i];
array[i] = temp;
}
}
评论
投票是因为我需要一个创建整数集合的高昂开销的解决方案
–mwk
13年9月30日在17:27
第二种实现方式是否有可能与自己的索引互换？ random.nextInt（int bound）是互斥的，但给定i +1作为参数将允许索引和i可能相同。
–bmcentee148
15年5月27日在2:42
@ bmcentee148以随机顺序交换元素是允许的。不了解这一点削弱了谜团，并帮助艾伦·图灵破解了它。 en.wikipedia.org/wiki/…
–艾伦·斯佩特斯（Ellen Spertus）
2015年6月9日在23:59
当CPU没有交换指令并且没有可用寄存器时，xor技巧非常适合交换CPU寄存器，但是对于循环内交换数组元素，我看不出任何好处。对于临时局部变量，没有理由在循环外声明它们。
–霍尔格
17年1月6日，18：46
在循环外声明temp变量稍微更有效。 XOR技巧应该比使用temp变量快，但这是确保它执行基准测试的唯一方法。
–丹·布雷
17年1月6日在20:08
#4 楼
Collections类具有一种有效的改组方法，可以对其进行复制，以免依赖它：/**
* Usage:
* int[] array = {1, 2, 3};
* Util.shuffle(array);
*/
public class Util {
private static Random random;
/**
* Code from method java.util.Collections.shuffle();
*/
public static void shuffle(int[] array) {
if (random == null) random = new Random();
int count = array.length;
for (int i = count; i > 1; i--) {
swap(array, i - 1, random.nextInt(i));
}
}
private static void swap(int[] array, int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
评论
以免不依赖它？如果那是唯一可能的话，我宁愿依靠它。
– shmosel
17年2月23日在21:18
@shmosel然后随意使用它。确保导入所需的类，并且已使用Arrays.asList将数组转换为列表。您也必须将结果列表转换为数组
– KitKat
18年6月9日在16:50
您不能在原始数组上使用Arrays.asList（）。而且您不需要将其转换回去，因为它只是包装器。
– shmosel
18年6月10日在4:12
#5 楼
看一下Collections类，特别是shuffle(...)。评论
您如何在Android中使用此Collections类？您需要进行特殊导入（CRTL SHIFT O不起作用）才能使用它吗？
–休伯特
09-10-5在12:23
@Hubert，它应该是包java.util的一部分。自v1.2起，它是标准库的一部分。
– MauganRa
17年2月2日在16:04
为了使您的答案更加独立，应包含示例代码。 IE：import java.util.Collections; shuffle（solutionArray）;
– Stevoisiak
17-4-23在17:49
#6 楼
您在这里有几个选择。列表在重排方面与数组有点不同。您可以在下面看到，数组比列表快，原始数组比对象数组快。 />
示例持续时间
List<Integer> Shuffle: 43133ns
Integer[] Shuffle: 31884ns
int[] Shuffle: 25377ns
下面是随机播放的三种不同实现。如果要处理集合，则应仅使用Collections.shuffle。无需将数组包装到集合中就可以对其进行排序。下面的方法很容易实现。
ShuffleUtil类
import java.lang.reflect.Array;
import java.util.*;
public class ShuffleUtil<T> {
private static final int[] EMPTY_INT_ARRAY = new int[0];
private static final int SHUFFLE_THRESHOLD = 5;
private static Random rand;
主要方法
public static void main(String[] args) {
List<Integer> list = null;
Integer[] arr = null;
int[] iarr = null;
long start = 0;
int cycles = 1000;
int n = 1000;
// Shuffle List<Integer>
start = System.nanoTime();
list = range(n);
for (int i = 0; i < cycles; i++) {
ShuffleUtil.shuffle(list);
}
System.out.printf("%22s: %dns%n", "List<Integer> Shuffle", (System.nanoTime() - start) / cycles);
// Shuffle Integer[]
start = System.nanoTime();
arr = toArray(list);
for (int i = 0; i < cycles; i++) {
ShuffleUtil.shuffle(arr);
}
System.out.printf("%22s: %dns%n", "Integer[] Shuffle", (System.nanoTime() - start) / cycles);
// Shuffle int[]
start = System.nanoTime();
iarr = toPrimitive(arr);
for (int i = 0; i < cycles; i++) {
ShuffleUtil.shuffle(iarr);
}
System.out.printf("%22s: %dns%n", "int[] Shuffle", (System.nanoTime() - start) / cycles);
}
改组泛型列表
// ================================================================
// Shuffle List<T> (java.lang.Collections)
// ================================================================
@SuppressWarnings("unchecked")
public static <T> void shuffle(List<T> list) {
if (rand == null) {
rand = new Random();
}
int size = list.size();
if (size < SHUFFLE_THRESHOLD || list instanceof RandomAccess) {
for (int i = size; i > 1; i--) {
swap(list, i - 1, rand.nextInt(i));
}
} else {
Object arr[] = list.toArray();
for (int i = size; i > 1; i--) {
swap(arr, i - 1, rand.nextInt(i));
}
ListIterator<T> it = list.listIterator();
int i = 0;
while (it.hasNext()) {
it.next();
it.set((T) arr[i++]);
}
}
}
public static <T> void swap(List<T> list, int i, int j) {
final List<T> l = list;
l.set(i, l.set(j, l.get(i)));
}
public static <T> List<T> shuffled(List<T> list) {
List<T> copy = copyList(list);
shuffle(copy);
return copy;
}
改组泛型数组
// ================================================================
// Shuffle T[]
// ================================================================
public static <T> void shuffle(T[] arr) {
if (rand == null) {
rand = new Random();
}
for (int i = arr.length - 1; i > 0; i--) {
swap(arr, i, rand.nextInt(i + 1));
}
}
public static <T> void swap(T[] arr, int i, int j) {
T tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
public static <T> T[] shuffled(T[] arr) {
T[] copy = Arrays.copyOf(arr, arr.length);
shuffle(copy);
return copy;
}
改组基元数组
// ================================================================
// Shuffle int[]
// ================================================================
public static <T> void shuffle(int[] arr) {
if (rand == null) {
rand = new Random();
}
for (int i = arr.length - 1; i > 0; i--) {
swap(arr, i, rand.nextInt(i + 1));
}
}
public static <T> void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
public static int[] shuffled(int[] arr) {
int[] copy = Arrays.copyOf(arr, arr.length);
shuffle(copy);
return copy;
}
实用程序方法
简单的实用程序方法可将数组复制并转换为列表，反之亦然。
// ================================================================
// Utility methods
// ================================================================
protected static <T> List<T> copyList(List<T> list) {
List<T> copy = new ArrayList<T>(list.size());
for (T item : list) {
copy.add(item);
}
return copy;
}
protected static int[] toPrimitive(Integer[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_INT_ARRAY;
}
final int[] result = new int[array.length];
for (int i = 0; i < array.length; i++) {
result[i] = array[i].intValue();
}
return result;
}
protected static Integer[] toArray(List<Integer> list) {
return toArray(list, Integer.class);
}
protected static <T> T[] toArray(List<T> list, Class<T> clazz) {
@SuppressWarnings("unchecked")
final T[] arr = list.toArray((T[]) Array.newInstance(clazz, list.size()));
return arr;
}
范围类
生成一系列值，类似于Python的
range函数。 // ================================================================
// Range class for generating a range of values.
// ================================================================
protected static List<Integer> range(int n) {
return toList(new Range(n), new ArrayList<Integer>());
}
protected static <T> List<T> toList(Iterable<T> iterable) {
return toList(iterable, new ArrayList<T>());
}
protected static <T> List<T> toList(Iterable<T> iterable, List<T> destination) {
addAll(destination, iterable.iterator());
return destination;
}
protected static <T> void addAll(Collection<T> collection, Iterator<T> iterator) {
while (iterator.hasNext()) {
collection.add(iterator.next());
}
}
private static class Range implements Iterable<Integer> {
private int start;
private int stop;
private int step;
private Range(int n) {
this(0, n, 1);
}
private Range(int start, int stop) {
this(start, stop, 1);
}
private Range(int start, int stop, int step) {
this.start = start;
this.stop = stop;
this.step = step;
}
@Override
public Iterator<Integer> iterator() {
final int min = start;
final int max = stop / step;
return new Iterator<Integer>() {
private int current = min;
@Override
public boolean hasNext() {
return current < max;
}
@Override
public Integer next() {
if (hasNext()) {
return current++ * step;
} else {
throw new NoSuchElementException("Range reached the end");
}
}
@Override
public void remove() {
throw new UnsupportedOperationException("Can't remove values from a Range");
}
};
}
}
}
评论
您不是在对相同的事物进行计时，而是对每个事物都进行一次计时（然后它们的订单计数，而您会忘记运行时优化）。您应该在任何时间之前调用range，toArray和toPrimitive，然后循环以得出任何结论（伪代码：执行几次{生成列表，arr和iarr；时间改组列表；时间改组arr；时间改组iarr}）。我的结果：第一名：列表：36017ns，arr：28262ns，iarr：23334ns。 100th：名单：18445ns，arr：19995ns，iarr：18657ns。它只是表明int []已通过代码进行了预优化，但是它们几乎等同于运行时优化。
– syme
16年7月3日在13:05
#7 楼
这是使用Collections.shuffle方法的完整解决方案：请注意，由于Java无法在int[]和Integer[]（以及int[]和List<Integer>）之间平滑转换，它受到了影响。 #8 楼
使用ArrayList<Integer>可以帮助您解决混洗问题，而无需花费太多逻辑并减少消耗的时间。这是我的建议：ArrayList<Integer> x = new ArrayList<Integer>();
for(int i=1; i<=add.length(); i++)
{
x.add(i);
}
Collections.shuffle(x);
评论
可能不是后者-消耗更少的时间。实际上，这肯定比上面的原始实现要慢。
–蜘蛛鲍里斯（Boris）
2014-09-22 9:18
对于有人复制代码的情况，请注意“ for cycle”，i = 1，也许您需要i = 0
– Boris Karloff
2015年3月7日15:36
#9 楼
以下代码将在数组上实现随机排序。// Shuffle the elements in the array
Collections.shuffle(Arrays.asList(array));
来自：http://www.programcreek.com/2012/02/java-method-to-shuffle-an-int-array-with-random -order /
#10 楼
您现在可以使用Java 8：Collections.addAll(list, arr);
Collections.shuffle(list);
cardsList.toArray(arr);
评论
此代码中没有Java8特定的内容。从Java2开始有效。好了，一旦您解决了第一次使用list和突然引用cardsList之间的不一致问题，它就会起作用。但是由于您需要创建已省略的临时列表，因此与Collections.shuffle（Arrays.asList（arr））;无关。这种方法在这里多次显示。从Java2开始也可以使用。
–霍尔格
17年1月6日，18：52
#11 楼
这是数组的泛型版本：import java.util.Random;
public class Shuffle<T> {
private final Random rnd;
public Shuffle() {
rnd = new Random();
}
/**
* Fisher–Yates shuffle.
*/
public void shuffle(T[] ar) {
for (int i = ar.length - 1; i > 0; i--) {
int index = rnd.nextInt(i + 1);
T a = ar[index];
ar[index] = ar[i];
ar[i] = a;
}
}
}
考虑到ArrayList基本上只是一个数组，建议使用ArrayList而不是显式数组并使用Collections.shuffle（）。但是，性能测试并未显示上述内容与Collections.sort（）之间有任何显着差异：
Shuffe<Integer>.shuffle(...) performance: 576084 shuffles per second
Collections.shuffle(ArrayList<Integer>) performance: 629400 shuffles per second
MathArrays.shuffle(int[]) performance: 53062 shuffles per second
Apache Commons实现MathArrays.shuffle仅限于int []并且性能损失可能是由于使用了随机数生成器。
评论
看起来您可以将新的JDKRandomGenerator（）传递给MathArrays.shuffle。我想知道这对性能有何影响？
–布兰登
16 Dec 16'在21:34
实际上...看起来MathArrays＃shuffle在其核心循环中有一个分配：int targetIdx = new UniformIntegerDistribution（rng，start，i）.sample（）;。奇怪
–布兰登
16 Dec 16'在21:40
#12 楼
Random rnd = new Random();
for (int i = ar.length - 1; i > 0; i--)
{
int index = rnd.nextInt(i + 1);
// Simple swap
int a = ar[index];
ar[index] = ar[i];
ar[i] = a;
}
顺便说一句，我注意到这段代码返回了数量为
ar.length - 1的元素，因此，如果您的数组有5个元素，则新的随机数组将有4个元素。发生这种情况是因为for循环显示i>0。如果更改为i>=0，那么所有元素都将被拖曳。评论
请注意，您可能需要将其移至问题的评论部分，因为如果将其保留为自己的答案，则可能会被标记出来。
–杰森D
2014年11月15日15:38
这似乎可以回答问题，所以我不确定您在说什么@JasonD
– Sumurai8
2014年11月15日下午16:42
代码正确，注释错误。如果将i> 0更改为i> = 0，则会通过将元素0与自身交换来浪费时间。
– jcsahnwaldt恢复莫妮卡
16-3-20在16:33
#13 楼
这是使用Apache Commons Math 3.x的解决方案（仅用于int []数组）：MathArrays.shuffle(array);
http://commons.apache.org/proper/commons -math / javadocs / api-3.6.1 / org / apache / commons / math3 / util / MathArrays.html＃shuffle（int []）
或者，Apache Commons Lang 3.6引入了新的shuffle方法来
ArrayUtils类（用于对象和任何原始类型）。ArrayUtils.shuffle(array);
http://commons.apache.org/proper/commons-lang/javadocs/api-release /org/apache/commons/lang3/ArrayUtils.html#shuffle-int:A-
#14 楼
我在某些答案中看到一些未命中的信息，所以我决定添加一个新的信息。Java集合Arrays.asList的类型为T
(T ...)的var-arg。如果传递原始数组（int数组），则asList方法将推断并生成List<int[]>，它是一个元素列表（一个元素是原始数组）。如果您对这一个元素列表进行混洗，将不会改变任何内容。为此，您可以使用apache.commons.lang中的ArrayUtils.toObject方法。然后将生成的数组传递给List并最终将其洗牌。 int[] intArr = {1,2,3};
List<Integer> integerList = Arrays.asList(ArrayUtils.toObject(array));
Collections.shuffle(integerList);
//now! elements in integerList are shuffled!
#15 楼
这是随机播放列表的另一种方法public List<Integer> shuffleArray(List<Integer> a) {
List<Integer> b = new ArrayList<Integer>();
while (a.size() != 0) {
int arrayIndex = (int) (Math.random() * (a.size()));
b.add(a.get(arrayIndex));
a.remove(a.get(arrayIndex));
}
return b;
}
从原始列表中选择一个随机数并将其保存在另一个列表中，然后从原始列表中删除该数字。直到所有元素都移到新列表之前，原始列表的百分比将继续减少一。
#16 楼
Groovy的一个简单解决方案：solutionArray.sort{ new Random().nextInt() }
这将对数组列表中的所有元素进行随机排序，从而存储对所有元素进行混洗所需的结果。
#17 楼
使用番石榴的Ints.asList()就像这样简单：Collections.shuffle(Ints.asList(array));
#18 楼
使用随机类 public static void randomizeArray(int[] arr) {
Random rGenerator = new Random(); // Create an instance of the random class
for (int i =0; i< arr.length;i++ ) {
//Swap the positions...
int rPosition = rGenerator.nextInt(arr.length); // Generates an integer within the range (Any number from 0 - arr.length)
int temp = arr[i]; // variable temp saves the value of the current array index;
arr[i] = arr[rPosition]; // array at the current position (i) get the value of the random generated
arr[rPosition] = temp; // the array at the position of random generated gets the value of temp
}
for(int i = 0; i<arr.length; i++) {
System.out.print(arr[i]); //Prints out the array
}
}
#19 楼
我正在考虑这个非常受欢迎的问题，因为没有人编写过shuffle-copy版本。样式是从Arrays.java大量借用的，因为这些天谁没有掠夺Java技术？包括通用和int实现。 /**
* Shuffles elements from {@code original} into a newly created array.
*
* @param original the original array
* @return the new, shuffled array
* @throws NullPointerException if {@code original == null}
*/
@SuppressWarnings("unchecked")
public static <T> T[] shuffledCopy(T[] original) {
int originalLength = original.length; // For exception priority compatibility.
Random random = new Random();
T[] result = (T[]) Array.newInstance(original.getClass().getComponentType(), originalLength);
for (int i = 0; i < originalLength; i++) {
int j = random.nextInt(i+1);
result[i] = result[j];
result[j] = original[i];
}
return result;
}
/**
* Shuffles elements from {@code original} into a newly created array.
*
* @param original the original array
* @return the new, shuffled array
* @throws NullPointerException if {@code original == null}
*/
public static int[] shuffledCopy(int[] original) {
int originalLength = original.length;
Random random = new Random();
int[] result = new int[originalLength];
for (int i = 0; i < originalLength; i++) {
int j = random.nextInt(i+1);
result[i] = result[j];
result[j] = original[i];
}
return result;
}
#20 楼
这是knuth随机播放算法。public class Knuth {
// this class should not be instantiated
private Knuth() { }
/**
* Rearranges an array of objects in uniformly random order
* (under the assumption that <tt>Math.random()</tt> generates independent
* and uniformly distributed numbers between 0 and 1).
* @param a the array to be shuffled
*/
public static void shuffle(Object[] a) {
int n = a.length;
for (int i = 0; i < n; i++) {
// choose index uniformly in [i, n-1]
int r = i + (int) (Math.random() * (n - i));
Object swap = a[r];
a[r] = a[i];
a[i] = swap;
}
}
/**
* Reads in a sequence of strings from standard input, shuffles
* them, and prints out the results.
*/
public static void main(String[] args) {
// read in the data
String[] a = StdIn.readAllStrings();
// shuffle the array
Knuth.shuffle(a);
// print results.
for (int i = 0; i < a.length; i++)
StdOut.println(a[i]);
}
}
#21 楼
还有另一种方式，尚未发布//that way, send many object types diferentes
public anotherWayToReciveParameter(Object... objects)
{
//ready with array
final int length =objects.length;
System.out.println(length);
//for ready same list
Arrays.asList(objects);
}
这种方式更简单，取决于上下文
#22 楼
数组中此随机混洗的最简单解决方案。String location[] = {"delhi","banglore","mathura","lucknow","chandigarh","mumbai"};
int index;
String temp;
Random random = new Random();
for(int i=1;i<location.length;i++)
{
index = random.nextInt(i+1);
temp = location[index];
location[index] = location[i];
location[i] = temp;
System.out.println("Location Based On Random Values :"+location[i]);
}
#23 楼
从
int[]到Integer[]的框使用
Arrays.asList方法将数组包装到列表中通过
Collections.shuffle方法进行随机播放int[] solutionArray = { 1, 2, 3, 4, 5, 6, 6, 5, 4, 3, 2, 1 };
Integer[] boxed = Arrays.stream(solutionArray).boxed().toArray(Integer[]::new);
Collections.shuffle(Arrays.asList(boxed));
System.out.println(Arrays.toString(boxed));
// [1, 5, 5, 4, 2, 6, 1, 3, 3, 4, 2, 6]
#24 楼
洗牌最简单的代码：import java.util.*;
public class ch {
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
ArrayList<Integer> l=new ArrayList<Integer>(10);
for(int i=0;i<10;i++)
l.add(sc.nextInt());
Collections.shuffle(l);
for(int j=0;j<10;j++)
System.out.println(l.get(j));
}
}
#25 楼
public class ShuffleArray {
public static void shuffleArray(int[] a) {
int n = a.length;
Random random = new Random();
random.nextInt();
for (int i = 0; i < n; i++) {
int change = i + random.nextInt(n - i);
swap(a, i, change);
}
}
private static void swap(int[] a, int i, int change) {
int helper = a[i];
a[i] = a[change];
a[change] = helper;
}
public static void main(String[] args) {
int[] a = new int[] { 1, 2, 3, 4, 5, 6, 6, 5, 4, 3, 2, 1 };
shuffleArray(a);
for (int i : a) {
System.out.println(i);
}
}
}
评论
请添加有关您的答案的一些相关描述。
–ankit suthar
17年9月26日在12:57
#26 楼
import java.util.ArrayList;
import java.util.Random;
public class shuffle {
public static void main(String[] args) {
int a[] = {1,2,3,4,5,6,7,8,9};
ArrayList b = new ArrayList();
int i=0,q=0;
Random rand = new Random();
while(a.length!=b.size())
{
int l = rand.nextInt(a.length);
//this is one option to that but has a flaw on 0
// if(a[l] !=0)
// {
// b.add(a[l]);
// a[l]=0;
//
// }
//
// this works for every no.
if(!(b.contains(a[l])))
{
b.add(a[l]);
}
}
// for (int j = 0; j <b.size(); j++) {
// System.out.println(b.get(j));
//
// }
System.out.println(b);
}
}
#27 楼
相似但不使用swap b Random r = new Random();
int n = solutionArray.length;
List<Integer> arr = Arrays.stream(solutionArray).boxed().collect(Collectors.toList());
for (int i = 0; i < n-1; i++) {
solutionArray[i] = arr.remove( r.nextInt(arr.size())); // randomize base on size
}
solutionArray[n-1] = arr.get(0);
#28 楼
解决方案之一是使用排列预先计算所有排列并存储在ArrayList中。Java 8在java.util.Random类中引入了新方法ints（）。 ints（）方法返回无限制的伪随机整数值流。您可以通过提供最小值和最大值来限制随机数在指定范围内。Random genRandom = new Random();
int num = genRandom.nextInt(arr.length);
借助生成随机数，您可以遍历循环并与具有随机数的当前索引交换。.
这就是生成具有O（1）空间复杂度的随机数的方法。
#29 楼
没有随机解： static void randomArrTimest(int[] some){
long startTime = System.currentTimeMillis();
for (int i = 0; i < some.length; i++) {
long indexToSwap = startTime%(i+1);
long tmp = some[(int) indexToSwap];
some[(int) indexToSwap] = some[i];
some[i] = (int) tmp;
}
System.out.println(Arrays.toString(some));
}
评论
这是您正在寻找Collections.shuffle（Arrays.asList（array））;的SDK方法；@Louie不，那是行不通的。这将创建一个包含一个条目的List
并不是对原始问题的真正答案，但是commons-math3库中的MathArrays.shuffle可以完成任务。
这还不足以提供答案，但我记得《 Graphics Gems》一书中的一篇很酷的文章，内容涉及伪随机顺序遍历数组。在我看来，首先必须真正洗牌。 C实现在github.com/erich666/GraphicsGems/blob/master/gems/Dissolve.c中找到
另请参阅以下密切相关的问题：stackoverflow.com/questions/2450954/…