在最近探索scala的过程中，发现一个比较重要的问题，那就是排序，排序在业务代码中还是很常见的，最常用的排序就是对集合调用sorted[B >: A](implicit ord: Ordering[B])接口，但是用久了很想问为什么，这篇博客目的是解释清楚scala中的排序问题。

两大神器

scala中提供的排序比较接口，ordering和ordered。话不多说，先贴一点源码看看：

trait Ordering[T] extends Comparator[T] with PartialOrdering[T] with Serializable

Ordering中集成了java中Comparator，并且同时实现了偏排序和序列化，看到Comparator相信熟悉java的观众朋友们肯定会很高兴，心底默念一句原来是这样；那真的是这样吗？是也不是，继续往下看。

trait Ordered[A] extends Any with java.lang.Comparable[A]

在Ordered中继承了java中的Comparable接口，类似于java中Comparable的用法；

排序

Sorting

在scala中比较简单的排序就是Sorting，这个排序的接口只是对java中的Arrays.sort的简单封装，该接口源码中比较重要就是用递归的方式实现了一次快排，可以查看相关源码，下面是对该接口的测试。

"Sorting test " should "be success" in {import scala.util.Sortingval pairs = Array(("a", 5, 2), ("c", 3, 1), ("a", 1, 3))// 单一字段从原类型到目标类型Sorting.quickSort(pairs)(Ordering.by[(String, Int, Int), Int](_._2))pairs.foreach(println)// 多个字段，只需要指定目标类型Sorting.quickSort(pairs)(Ordering[(String, Int)].on(x => (x._1, x._2)))pairs.foreach(println)assert(pairs.head._2 == 1, true)case class Person(name: String, age: Int)val people = Array(Person("bob", 30), Person("ann", 32), Person("carl", 19))// sort by ageobject AgeOrdering extends Ordering[Person] {def compare(a: Person, b: Person): Int = a.age compare b.age}Sorting.quickSort(people)(AgeOrdering)people.foreach(println)
}

运行结果：

(a,1,3)
(c,3,1)
(a,5,2)
(a,1,3)
(a,5,2)
(c,3,1)
Person(carl,19)
Person(bob,30)
Person(ann,32)

Sorting中提供了Boolean类型的排序实现，贴出来只是其注释很有意思

// Why would you even do this?private def booleanSort(a: Array[Boolean]): Unit = {...}

集合排序

除了上面的排序方式外，在集合层面，scala提供了三种排序接口，分别是

def sorted[B >: A](implicit ord: Ordering[B])
def sortWith(lt: (A, A) => Boolean)
def sortBy[B](f: A => B)(implicit ord: Ordering[B])

若调用sorted函数做排序，则需要指定Ordering隐式参数：

val p1 = new Person("rain", 24)
val p2 = new Person("rain", 22)
val p3 = new Person("Lily", 15)
val list = List(p1, p2, p3)
implicit object PersonOrdering extends Ordering[Person] {override def compare(p1: Person, p2: Person): Int = {p1.name == p2.name match {case false => -p1.name.compareTo(p2.name)case _ => p1.age - p2.age}}
}
list.sorted
// res3: List[Person] = List(name: rain, age: 22, name: rain, age: 24, name: Lily, age: 15)

若使用sortWith，则需要定义返回值为Boolean的比较函数：

list.sortWith { (p1: Person, p2: Person) =>p1.name == p2.name match {case false => p1.name.compareTo(p2.name) < 0case _ => p1.age - p2.age < 0}
}
// res4: List[Person] = List(name: rain, age: 22, name: rain, age: 24, name: Lily, age: 15)

若使用sortBy，也需要指定Ordering隐式参数：

implicit object PersonOrdering extends Ordering[Person] {override def compare(p1: Person, p2: Person): Int = {p1.name == p2.name match {case false => -p1.name.compareTo(p2.name)case _ => p1.age - p2.age}}
}
list.sortBy[Person](t => t)

上面介绍的都是在操作层面上对已定义好的对象进行的排序，在scala灵活的语法规则中，还有以下方式的针对对象的排序定义，具体代码如下：

"Ordered sort " should "" in {case class Persons(name: String, age: Int) extends Ordered[Persons] {import scala.math.Ordered.orderingToOrderedoverride def compare(that: Persons): Int = (this.name, this.age) compare (that.name, that.age)}val people = Array(Persons("a", 12),Persons("a", 10),Persons("b", 9),Persons("b", 12))people.sorted.foreach(println)}
result :
Persons(a,10)
Persons(a,12)
Persons(b,9)
Persons(b,12)

上面这种方式类似于java中继承了Comparable接口的实体类，具有了比较的能力，再调用scala.math.Ordered.orderingToOrdered中的compare方法进行元组级别的比较，代码整体看起来比较简洁，而且功能有效，而下面这种方式更为普及。

case class Employee(id: Int, firstName: String, lastName: String)
object Employee {// Note that because `Ordering[A]` is not contravariant, the declaration// must be type-parametrized in the event that you want the implicit// ordering to apply to subclasses of `Employee`.implicit def orderingByName[A <: Employee]: Ordering[A] = Ordering.by(e => (e.lastName, e.firstName))val orderingById: Ordering[Employee] = Ordering.by(e => e.id)
}  "Ordering sort" should "" in {Employee.orderingByNameval people = Array(Employee(11, "b", "11"),Employee(9, "a", "11"),Employee(12,"c", "12"),Employee(10, "b", "12"),Employee(21, "a", "12"))people.sorted.foreach(println)println("******************************")implicit val ord = Employee.orderingByIdpeople.sorted.foreach(println)}
result :
Employee(9,a,11)
Employee(11,b,11)
Employee(21,a,12)
Employee(10,b,12)
Employee(12,c,12)
******************************
Employee(9,a,11)
Employee(10,b,12)
Employee(11,b,11)
Employee(12,c,12)
Employee(21,a,12)

这种方式在伴生对象中进行了排序规则的申明，而不是在具体排序的时候，这样做也能让代码整洁，而且可以下伴生对象中根据需要定义多种排序方式，在使用时根据具体的业务场景进行选取，适合大型项目。

扩展：RDD sort

RDD的sortBy函数，提供根据指定的key对RDD做全局的排序。sortBy定义如下：

def sortBy[K](f: (T) => K,ascending: Boolean = true,numPartitions: Int = this.partitions.length)(implicit ord: Ordering[K], ctag: ClassTag[K]): RDD[T]

仅需定义key的隐式转换即可：

scala> val rdd = sc.parallelize(Array(new Person("rain", 24),new Person("rain", 22), new Person("Lily", 15)))
scala> implicit object PersonOrdering extends Ordering[Person] {override def compare(p1: Person, p2: Person): Int = {p1.name == p2.name match {case false => -p1.name.compareTo(p2.name)case _ => p1.age - p2.age}}}
scala> rdd.sortBy[Person](t => t).collect()
// res1: Array[Person] = Array(name: rain, age: 22, name: rain, age: 24, name: Lily, age: 15)

总结

在scala中总体排序方式跟在java中感觉没有本质的区别，但是其本质区别在于scala中隐式转换的应用以及很多工具接口的实现，可以让你在此基础上来进行自定义，在代码位置合理的情况下，减少了代码。

scala排序——ordering vs ordered相关推荐

scala 排序接口Ordering
Ordering 特质入门简介排序是一种trait,其每个实例代表一种对类型实例进行排序的策略. trait Ordering[T] extends Comparator[T] with Parti ...
Scala 排序函数 sorted sortBy sortWith
排序方法在实际的应用场景中非常常见,Scala里面有三种排序方法,分别是: sorted,sortBy ,sortWith 分别介绍下他们的功能: (1)sorted 对一个集合进行自然排序,通过传递 ...
Scala比较器：Ordered与Ordering
在项目中,我们常常会遇到排序(或比较)需求,比如:对一个Person类 case class Person(name: String, age: Int) {override def toString ...
scala的三个排序方法
sorted 对一个集合进行自然排序,通过传递隐式的Ordering 无需参数 def sorted[B >: A](implicit ord: Ordering[B]): Repr scala ...
Scala 常用Sort排序
Scala 使用过程中经常要要用到排序模块,自带的方法有sorted,sortBy,sortWith,同时也提供了接口和类,例如Ordering,Ordered,Comparable,Comparat ...
scala Ordering
scala.math.Ordering 自定义排序方法. 例:(col : Int, row : Int, Value : Double )是一个Tuple3.排序默认按第一项作为Key. Order ...
Guava ---- Ordering排序工具
使用Guava的排序工具类, 快速实现对象的单变量排序和多变量排序, 让你的开发效率爆炸... import com.google.common.collect.Lists; import com.g ...
Ordering排序工具一
使用Guava的排序工具类, 快速实现对象的单变量排序和多变量排序, 让你的开发效率爆炸... import com.google.common.collect.Lists; import com.g ...
Spark-Core自定义排序规则
1.利用case特性,定义一个类,在类中进行排序 package day02import org.apache.spark.rdd.RDD import org.apache.spark.{Spark ...

scala排序——ordering vs ordered

两大神器

排序

Sorting

集合排序

扩展：RDD sort

总结

scala排序——ordering vs ordered相关推荐

最新文章

热门文章