blocks|key|1289235|text|Sorting.quickSort声明了接受数字或字符串数组的函数，但我假设您的意思是要对自己的类的对象列表进行排序？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1289236|我认为您正在查看的函数是|1289237|quickSort+[K](a+:+Array[K])(implicit+view$1+:+(K)+=>+Ordered[K])+:+Unit|code-block|syntax|javascript|1289238|如果我没理解错的话，这意味着数组中的对象必须具有Ordered特征。因此，您的类必须扩展Ordered+(或者必须混合它)，因此必须实现该特征的compare方法。|offset|length|style|CODE|1289239|所以从书中摘取一个例子：|1289240|class+MyClass(n:+Int)+extends+Ordered[MyClass]+{
+++...
++def+compare(that:+MyClass)+=
++++this.n+-+that.n
}|1289241|因此，给定一个ArrayMyClass，那么Sorting.quickSort应该可以工作。|1289242|entityMap^0|0|0|0|O|7|18|7|20|7|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@$K|10|L|11|M|N]|$K|12|L|13|M|N]|$K|14|L|15|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|17|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|18|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|V|$]]

Sorting.quickSort declares functions for taking an Array of numbers or Strings, but I'm assuming you mean you want to sort a list of objects of your own classes?

The function I think you're looking at is

<pre><code>quickSort [K](a : Array[K])(implicit view$1 : (K) =&gt; Ordered[K]) : Unit
</code></pre>

Which, if I'm reading this right, means that the objects in the Array must have the <code>Ordered</code> trait. So your class must extend <code>Ordered</code> (or must mix it in), and therefore must implement the <code>compare</code> method of that trait.

So to rip off an example from the book:

<pre><code>class MyClass(n: Int) extends Ordered[MyClass] {
 ...
 def compare(that: MyClass) =
 this.n - that.n
}
</code></pre>

So given an Array[MyClass], then Sorting.quickSort should work.

blocks|key|1289419|text|使用Scala+2.8或更高版本，可以执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1289420|List(3,7,5,2).sortWith(_+<+_)|code-block|syntax|javascript|1289421|这使用了java.util.Arrays.sort，quicksort的一个实现。|offset|length|1289422|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html#sort-T:A-java.util.Comparator-^0|0|0|4|L|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

With Scala 2.8 or later it is possible to do:

<pre><code>List(3,7,5,2).sortWith(_ &lt; _)
</code></pre>

that uses <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html#sort-T:A-java.util.Comparator-">java.util.Arrays.sort</a>, an implementation of quicksort.

blocks|key|1504113|text|现在这个也行得通：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1504114|List(3,7,5,2).sorted|offset|length|style|CODE|1504115|entityMap^0|0|0|K|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Nowadays this one works too:

<code>List(3,7,5,2).sorted</code>

blocks|key|1289151|text|val+array+=+Array((for(i+<-+0+to+10)+yield+scala.util.Random.nextInt):+_*)
scala.util.Sorting.quickSort(array)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1289152|Scala的“默认”数组是一个可变的数据结构，非常接近Java的Array。一般来说，这意味着“数组”并不是Scala风格的，即使是可变数据结构也是如此。不过，这是有目的的。如果数组是您需要的正确数据类型，那么您就可以对其进行排序。顺便说一句，关于对象排序，还有其他排序方法。|unstyled|1289153|我想我刚刚明白你的问题是什么了.您不需要传递任何隐式参数(毕竟它是隐式的)。该参数的存在是为了说明一定有某种方法可以将类型K转换为OrderedK。Scala的类已经存在这些定义，所以您不需要它们。|1289154|对于任意类，您可以这样定义它：|1289155|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)
+++++++++++++++++++++++++++++++++++%5E
scala>+class+OrderedPerson(val+person:+Person)+extends+Ordered[Person]+{
+++++%7C+def+compare(that:+Person)+=+person.name.compare(that.name)
+++++%7C+}
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))|1289156|现在，如果Person被命令开始，这不会是一个问题：|1289157|scala>+case+class+Person(name:+String)+extends+Ordered[Person]+{
+++++%7C+def+compare(that:+Person)+=+name.compare(that.name)
+++++%7C+}
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))|1289158|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|T|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$B|C]]|$1|M|3|N|5|F|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$B|C]]|$1|Q|3|-4|5|F|7|Z|8|@]|9|@]|A|$]]]|R|$]]

<pre><code>val array = Array((for(i &lt;- 0 to 10) yield scala.util.Random.nextInt): _*)
scala.util.Sorting.quickSort(array)
</code></pre>

Scala's "default" array is a mutable data structure, very close to Java's Array. Generally speaking, that means an "array" is not very Scala-ish, even as mutable data structures go. It serves a purpose, though. If array is the right data type for your need, then that is how you sort it. There are other sorting methods on object Sorting, by the way.

I think I just realized what your question is... you don't need to pass any implicit parameter (it's implicit, after all). That parameter exists to say that there must be some way to convert the type K into an Ordered[K]. These definitions already exist for Scala's classes, so you don't need them.

For an arbitrary class you can define it this way:

<pre><code>scala&gt; case class Person(name: String)
defined class Person

scala&gt; val array = Array(Person("John"), Person("Mike"), Person("Abe"))
array: Array[Person] = Array(Person(John), Person(Mike), Person(Abe))

scala&gt; scala.util.Sorting.quickSort(array)
&lt;console&gt;:11: error: no implicit argument matching parameter type (Person) =&gt; Ordered[Person] was found.
 scala.util.Sorting.quickSort(array)
 ^
scala&gt; class OrderedPerson(val person: Person) extends Ordered[Person] {
 | def compare(that: Person) = person.name.compare(that.name)
 | }
defined class OrderedPerson

scala&gt; implicit def personToOrdered(p: Person) = new OrderedPerson(p)
personToOrdered: (p: Person)OrderedPerson

scala&gt; scala.util.Sorting.quickSort(array)

scala&gt; array
res8: Array[Person] = Array(Person(Abe), Person(John), Person(Mike))
</code></pre>

Now, if Person was Ordered to begin with, this wouldn't be a problem:

<pre><code>scala&gt; case class Person(name: String) extends Ordered[Person] {
 | def compare(that: Person) = name.compare(that.name)
 | }
defined class Person

scala&gt; val array = Array(Person("John"), Person("Mike"), Person("Abe"))
array: Array[Person] = Array(Person(John), Person(Mike), Person(Abe))

scala&gt; scala.util.Sorting.quickSort(array)

scala&gt; array
res10: Array[Person] = Array(Person(Abe), Person(John), Person(Mike))
</code></pre>

blocks|key|1504023|text|虽然公认的答案没有错，但快速排序方法提供了比这更灵活的方法。我为你写了这个例子。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1504024|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
*/|code-block|syntax|javascript|1504025|这展示了如何使用隐式和显式的从Foo到某个类扩展OrderedFoo的转换来获得不同的排序顺序。|1504026|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

While the accepted answer isn't wrong, the quicksort method provides more flexibility than that. I wrote this example for you.

<pre><code>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=&gt;println(a.get))
/*
This will print:
1
2
3
*/

//sorting using OrdFoo2
scala.util.Sorting.quickSort(arr)(new OrdFoo2(_))
arr foreach (a=&gt;println(a.get))
/*
This will print:
3
2
1
*/
</code></pre>

This shows how implicit and explicit conversions from Foo to some class extending Ordered[Foo] can be used to get different sort orders.

I can see there's a sorting object, <code>Sorting</code>, with a <a href="http://en.wikipedia.org/wiki/Quicksort" rel="noreferrer">quicksort</a> method, <code>quickSort</code>, on it.

What would be a code example of using it, sorting an array of object of arbitrary type? It looks like I need to pass in an implementation of the <code>Orderable</code> trait, but I am unsure of the syntax.

Also, I would prefer answers doing this the 'Scala way'. I know I can just use a Java library.

How do I sort an array in Scala?

数据结构

Java

我可以看到有一个排序对象Sorting，上面有一个方法quickSort。使用它，对任意类型的对象数组进行排序的代码示例是什么？看起来我需要传入一个Orderable特征的实现，但是我不确定语法。另外，我更喜欢用“Scala方式”来回答这个问题。我知道我可以只使用Java库。

问如何在Scala中对数组进行排序？
EN

回答 5

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Scala中对数组进行排序？EN

回答 5

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Scala中对数组进行排序？
EN