如何在 Scala 数组上使用 Java Collections.shuffle()？

Question

我有一个想要随机排列的数组。在Java中，有一个方法Collections.shuffle()可以随机打乱List的元素。它也可以用在数组上：

String[] array = new String[]{"a", "b", "c"};

// Shuffle the array; works because the list returned by Arrays.asList() is backed by the array
Collections.shuffle(Arrays.asList(array));

我尝试在 Scala 数组上使用它，但是 Scala 解释器给出了一个冗长的答案：

scala> val a = Array("a", "b", "c")
a: Array[java.lang.String] = Array(a, b, c)

scala> java.util.Collections.shuffle(java.util.Arrays.asList(a))
<console>:6: warning: I'm seeing an array passed into a Java vararg.
I assume that the elements of this array should be passed as individual arguments to the vararg.
Therefore I follow the array with a `: _*', to mark it as a vararg argument.
If that's not what you want, compile this file with option -Xno-varargs-conversion.
       java.util.Collections.shuffle(java.util.Arrays.asList(a))
                                                             ^
<console>:6: error: type mismatch;
 found   : Array[java.lang.String]
 required: Seq[Array[java.lang.String]]
       java.util.Collections.shuffle(java.util.Arrays.asList(a))
                                                             ^

这里到底发生了什么？我不想用特殊标志（-Xno-varargs-conversion）编译我的代码，如果这根本就是解决方案，只是因为这个。

那么，如何在 Scala 数组上使用 Java 的 Collections.shuffle() 呢？

与此同时，我在 Scala 中编写了自己的 shuffle 方法：

// Fisher-Yates shuffle, see: http://en.wikipedia.org/wiki/Fisher–Yates_shuffle
def shuffle[T](array: Array[T]): Array[T] = {
    val rnd = new java.util.Random
    for (n <- Iterator.range(array.length - 1, 0, -1)) {
        val k = rnd.nextInt(n + 1)
        val t = array(k); array(k) = array(n); array(n) = t
    }
    return array
}

它对数组进行洗牌，并返回数组本身以方便使用。

Answer 1

java.util.Collections.shuffle(java.util.Arrays.asList(a:_*))

为了使上述方法正确工作，a 的元素类型必须是 scala.AnyRef 的子类（相当于 java.lang.Object），因为 Arrays.asList() 使用传入的数组作为结果 java.util 的后备存储。 List 和 java.util.List 只能包含对象引用（而不是原始值）。*

这也是为什么 Collections.shuffle() 会打乱传入的 java.util.List 实际上会打乱数组的原因。*

*：参见 下面的注释

例如

scala> val a = Array[java.lang.Integer](1, 2, 3) // note the type parameter                  
a: Array[java.lang.Integer] = Array(1, 2, 3)

scala> java.util.Collections.shuffle(java.util.Arrays.asList(a:_*))

scala> a
res43: Array[java.lang.Integer] = Array(1, 3, 2)

scala> java.util.Collections.shuffle(java.util.Arrays.asList(a:_*))

scala> a
res45: Array[java.lang.Integer] = Array(1, 2, 3)

：注意：上面的代码片段使用的是 Scala 2.7.5。正如 Daniel 所演示的，Scala 2.8.0 表现出不同的行为。为了安全起见，不要依赖于数组被打乱的事实，而是依赖于从 Arrays.asList() 返回的列表被打乱的事实。

scala> val a = Array[java.lang.Integer](1, 2, 3)
a: Array[java.lang.Integer] = Array(1, 2, 3)

scala> val b = java.util.Arrays.asList(a:_*)
b: java.util.List[java.lang.Integer] = [1, 2, 3]

scala> java.util.Collections.shuffle(b)

scala> b
res50: java.util.List[java.lang.Integer] = [2, 1, 3]

scala> java.util.Collections.shuffle(b)

scala> b
res52: java.util.List[java.lang.Integer] = [3, 1, 2]

Answer 2

在可变参数方面，Scala 似乎做了一些与 Java 不同的事情。至少，我无法以任何方式洗牌该数组。据说，列表上的洗牌会洗牌数组，因为列表是数组支持的。嗯，看来 Scala 在将 vararg 参数传递给 Java 时会创建一个新数组，因此使上述示例毫无用处。

scala> val b = java.util.Arrays.asList(a: _*)
b: java.util.List[java.lang.String] = [a, b, c]

scala> java.util.Collections.shuffle(b); println(a.toString+" "+b.toString)
Array(a, b, c) [a, b, c]

scala> java.util.Collections.shuffle(b); println(a.toString+" "+b.toString)
Array(a, b, c) [c, b, a]

scala> java.util.Collections.shuffle(b); println(a.toString+" "+b.toString)
Array(a, b, c) [a, c, b]

scala> java.util.Collections.shuffle(b); println(a.toString+" "+b.toString)
Array(a, b, c) [b, a, c]

scala> java.util.Collections.shuffle(b); println(a.toString+" "+b.toString)
Array(a, b, c) [a, b, c]

scala> java.util.Collections.shuffle(b); println(a.toString+" "+b.toString)
Array(a, b, c) [c, a, b]

尽管另有声明，它确实适用于 Ints：

scala> val a = Array(1,2,3)
a: Array[Int] = Array(1, 2, 3)

scala> val b = java.util.Arrays.asList(a: _*)
b: java.util.List[Int] = [1, 2, 3]

scala> java.util.Collections.shuffle(b); println(a.toString+" "+b.toString)
Array(1, 2, 3) [2, 3, 1]

scala> java.util.Collections.shuffle(b); println(a.toString+" "+b.toString)
Array(1, 2, 3) [3, 2, 1]

scala> java.util.Collections.shuffle(b); println(a.toString+" "+b.toString)
Array(1, 2, 3) [3, 2, 1]

scala> java.util.Collections.shuffle(b); println(a.toString+" "+b.toString)
Array(1, 2, 3) [1, 2, 3]

在 Scala 2.8 上，有一种更简单的方法：

scala> scala.util.Random.shuffle(a)
res32: Sequence[Int] = Array(1, 2, 3)

scala> scala.util.Random.shuffle(a)
res33: Sequence[Int] = Array(2, 1, 3)

scala> scala.util.Random.shuffle(a)
res34: Sequence[Int] = Array(3, 2, 1)

请注意，以 Scala 方式，它不会更改原始数组。

Answer 3

回答“这里究竟发生了什么？”部分：

当您说 java.util.Arrays.asList(a) 时，您正在调用一个静态 Java 方法，该方法被定义为采用可变数量的参数（Java 中的 vararg ... 语法）：

public static <T> List<T> asList(T... a) 

在 Scala 中，当您创建调用 asList 您传递的是单个 Array[String] 而不是三个字符串参数。即使 Scala 将 T* 表示为 Array[T]，您也需要告诉编译器您真正的意思是传递三个参数，而不是单个参数（即包含三个内容的列表）。

Scala 有一种方便的方法将 Array[String] 转换为 String,String,String：您使用 _* 符号，如 Walter Chang 的答案所示。每当您将某些内容传递给 vararg 函数时，您都可以使用它。

《Scala 编程》第 188 和 189 页对此进行了概述。

您还会在模式匹配中看到 _* 来匹配列表中的零个或多个元素。