我如何sortingScala中的数组？
我可以看到有一个sorting对象， Sorting ，使用quickSort方法quickSort 。
什么是使用它的代码示例，sorting任意types的对象的数组？ 看起来我需要传递Orderable特性的实现，但是我不确定语法。
此外，我更喜欢这样做的“斯卡拉方式”的答案。 我知道我可以使用Java库。
Sorting.quickSort声明了一个数组或string的函数，但是我假设你的意思是你想sorting你自己的类的对象列表？
我想你正在看的function是
quickSort [K](a : Array[K])(implicit view$1 : (K) => Ordered[K]) : Unit
其中，如果我正在读这个权利，意味着数组中的对象必须具有Ordered特征。 所以你的类必须扩展Ordered （或者必须混合），因此必须实现该特性的compare方法。
所以要撕掉这本书中的一个例子：
class MyClass(n: Int) extends Ordered[MyClass] { ... def compare(that: MyClass) = this.n - that.n }
所以给定一个数组[MyClass]，然后Sorting.quickSort应该工作。
使用Scala 2.8或更高版本，可以这样做：
List(3,7,5,2).sortWith(_ < _)
使用java.util.Arrays.sort ，一个quicksort的实现。
现在这个也工作：
List(3,7,5,2).sorted
如果你只是想sorting的东西，但没有特别与sorting对象结婚，你可以使用List的sorting方法。 它将一个比较函数作为参数，所以你可以在任何你想要的types上使用它：
List("Steve", "Tom", "John", "Bob").sort((e1, e2) => (e1 compareTo e2) < 0) List(1, 4, 3, 2).sort((e1, e2) => (e1 < e2))
列表可能有资格作为比数组“更粗糙”。
从scala api 文档 ：
def sort（lt：（A，A）=> Boolean）：List [A]
Sort the list according to the comparison function <(e1: a, e2: a) =>布尔值，如果e1小于e2，则应该为true。
val array = Array((for(i <- 0 to 10) yield scala.util.Random.nextInt): _*) scala.util.Sorting.quickSort(array)
Scala的“默认”数组是一个可变数据结构，非常接近Java的Array。 一般来说，这意味着即使可变的数据结构，“数组”也不是很“斯卡拉”（Scala-ish）。 尽pipe如此，它还是有用的。 如果array是你需要的正确的数据types，那么你就是这样sorting的。 顺便提一下，对象sorting还有其他的sorting方法。
我想我刚刚意识到你的问题是…你不需要传递任何隐含的参数（毕竟这是隐含的）。 该参数的存在是为了说明必须有某种方式将Ktypes转换为Ordered [K]。 这些定义已经存在于Scala的类中，所以你不需要它们。
对于一个任意的类，你可以这样定义它：
scala> case class Person(name: String) defined class Person scala> val array = Array(Person("John"), Person("Mike"), Person("Abe")) array: Array[Person] = Array(Person(John), Person(Mike), Person(Abe)) scala> scala.util.Sorting.quickSort(array) <console>:11: error: no implicit argument matching parameter type (Person) => Ordered[Person] was found. scala.util.Sorting.quickSort(array) ^ scala> class OrderedPerson(val person: Person) extends Ordered[Person] { | def compare(that: Person) = person.name.compare(that.name) | } defined class OrderedPerson scala> implicit def personToOrdered(p: Person) = new OrderedPerson(p) personToOrdered: (p: Person)OrderedPerson scala> scala.util.Sorting.quickSort(array) scala> array res8: Array[Person] = Array(Person(Abe), Person(John), Person(Mike))
现在，如果按照顺序开始，这不会是一个问题：
scala> case class Person(name: String) extends Ordered[Person] { | def compare(that: Person) = name.compare(that.name) | } defined class Person scala> val array = Array(Person("John"), Person("Mike"), Person("Abe")) array: Array[Person] = Array(Person(John), Person(Mike), Person(Abe)) scala> scala.util.Sorting.quickSort(array) scala> array res10: Array[Person] = Array(Person(Abe), Person(John), Person(Mike))
尽pipe接受的答案没有错，但是快速sorting方法提供了更多的灵活性。 我为你写了这个例子。
import System.out.println import scala.util.Sorting.quickSort class Foo(x:Int) { def get = x } //a wrapper around Foo that implements Ordered[Foo] class OrdFoo(x:Foo) extends Ordered[Foo] { def compare(that:Foo) = x.get-that.get } //another wrapper around Foo that implements Ordered[Foo] in a different way class OrdFoo2(x:Foo) extends Ordered[Foo] { def compare(that:Foo) = that.get-x.get } //an implicit conversion from Foo to OrdFoo implicit def convert(a:Foo) = new OrdFoo(a) //an array of Foos val arr = Array(new Foo(2),new Foo(3),new Foo(1)) //sorting using OrdFoo scala.util.Sorting.quickSort(arr) arr foreach (a=>println(a.get)) /* This will print: 1 2 3 */ //sorting using OrdFoo2 scala.util.Sorting.quickSort(arr)(new OrdFoo2(_)) arr foreach (a=>println(a.get)) /* This will print: 3 2 1 */
这显示了从Foo到扩展Ordered [Foo]的某些类的隐式和显式转换可以用来获得不同的sorting顺序。
