scala排序——ordering vs ordered

最新推荐文章于 2025-02-27 18:02:04 发布

通凡

最新推荐文章于 2025-02-27 18:02:04 发布

阅读量3.6k

点赞数 3

CC 4.0 BY-SA版权

分类专栏： scala 文章标签： ordering ordered scala排序 case class spark sortBy

本文链接：https://blog.csdn.net/wangxiaotongfan/article/details/82856870

scala 专栏收录该内容

8 篇文章

订阅专栏

本文深入探讨Scala中的排序机制，包括核心接口Ordering和Ordered的使用，集合排序方法sorted、sortWith及sortBy的详解，以及RDD排序应用。通过案例演示如何自定义排序规则，提升代码效率。

在最近探索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.Sorting
    val 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 age
    object 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) < 0
     case _ => 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.orderingToOrdered
      override 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.orderingByName
    val 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.orderingById
    people.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)