Scala的两种比较器Ordered于Ordering

scala中想要实现对一组自定义对象的排序，使用比较器的实现

1.自定义对象实现特质Ordered，同时实现Serializable的序列化

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

/**
  * Created by hqs on 2018/1/27.
  */
object SortDemo {

  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
      .setMaster("local")
      .setAppName(SortDemo.getClass.getName)
    val sc = new SparkContext(conf)

    val data: RDD[String] = sc.makeRDD(List("zhangsan 18 60", "lisi 21 70", "wangmazi 20 70", "kuangsan 26 99"))
    val file: RDD[(String, Int, Int)] = data.map({
      line => {
        val fields = line.split(" ")
        val name = fields(0)
        val age = fields(1).toInt
        val fv = fields(2).toInt
        (name, age, fv)
      }
    })

//    file.sortBy(t => (-t._3,t._2)).foreach(println)  元组的直接排序，最简单的方法。
    file.sortBy(t => new Person(t._1,t._2,t._3)).foreach(println)
  }
}

//通过自定义类重写compare的方法，来实现课比较的规则
class Person(val name:String,val age:Int,val fv:Int) extends Ordered[Person] with Serializable{
  override def compare(that: Person): Int = {
    if(this.fv == that.fv){
      this.age - that.age
    }else{
      that.fv - this.fv
    }
  }
}

2.通过隐式对象，隐式参数变量来实现Ordering的特质，重写compare的方法。实现比较。借用了自定义类。

//使用隐式对象，实现特质，重写比较方法。优先使用object
    implicit object obj extends Ordering[Person]{
      override def compare(x: Person, y: Person): Int = {
        if(x.fv == y.fv){
          x.age - y.age
        }else{
          y.fv - x.fv
        }
      }
    }
    //通过赋值一个隐式参数，重写比较方法，在进行排序的时候会找到这个隐式参数。
    implicit val obj1 = new Ordering[Person]{
      override def compare(x: Person, y: Person): Int = {
        if(x.fv == y.fv){
          x.age - y.age
        }else{
          y.fv - x.fv
        }
      }
    }
    file.sortBy(t => new Person(t._1,t._2,t._3)).foreach(println)

class Person(val name:String,val age:Int,val fv:Int) extends Serializable{
 //这个类也要实现序列化特质
}






总结：scala中Ordered和Ordering的不同的使用方法。都是特质。分别对应了java的Comparable<> 和Comparator<>,

实现的位置不一样