Scala高阶：详解关于scala中的比较器

引导

scala中的排序，底层使用的java中的排序

所以在scala的排序之前，先看看java是如何使用接口 进行自定义排序的

1.使用comparator方法进行排序

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * 排序:comparator 方法进行排序
 */
public class Man1 {
    private String name;
    private int age;

    private Man1(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Man{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public static void main(String[] args) {
        Man1 man1 = new Man1("man1", 32);
        Man1 man2 = new Man1("man2", 18);
        Man1 man3 = new Man1("man3", 36);

        List<Man1> mans = new ArrayList<>();

        mans.add(man1);
        mans.add(man2);
        mans.add(man3);

        Collections.sort(mans, new Comparator<Man1>() {
            @Override
            public int compare(Man1 o1, Man1 o2) {
                return o1.age - o2.age;
            }
        });

        //自定义排序规则，按照最简单的升序排序
        for (Man1 Man : mans) {
            System.out.println(Man);
        }
    }
}

2.使用Comparable方法进行排序

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * 排序
 * 1）comparator 方法进行排序
 * 2）comparable 方法进行排序
 */
public class Man2 implements Comparable<Man2>{

    public static void main(String[] args) {
        Man2 man1 = new Man2("man1",32);
        Man2 man2 = new Man2("man2",18);
        Man2 man3 = new Man2("man3",36);

        List<Man2> mans = new ArrayList<>();

        mans.add(man1);
        mans.add(man2);
        mans.add(man3);

        Collections.sort(mans);

        for (Man2 Man :mans){
            System.out.println(Man);
        }

    }

    private String name;
    private int age;

    private Man2(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Man{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    //自定义排序规则，按照最简单的升序排序
    @Override
    public int compareTo(Man2 o) {
        return this.age - o.age;
    }
}

scala中的自定义排序

scala中的自定义排序，都是继承了java的自定义排序接口 

在Ordering.scala和 Ordered.scala的源码中可以看到

• Ordering继承了Comparator接口
• Ordered继承了Comparable接口

去注释后的源码如下：

package scala
package math

import java.util.Comparator

trait Ordering[T] extends Comparator[T] with PartialOrdering[T] with Serializable {
 ······
}

package scala
package math

import scala.language.implicitConversions

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

  def compare(that: A): Int

  def <  (that: A): Boolean = (this compare that) <  0

  def >  (that: A): Boolean = (this compare that) >  0

  def <= (that: A): Boolean = (this compare that) <= 0

  def >= (that: A): Boolean = (this compare that) >= 0

  def compareTo(that: A): Int = compare(that)
}

object Ordered {
  implicit def orderingToOrdered[T](x: T)(implicit ord: Ordering[T]): Ordered[T] =
    new Ordered[T] { def compare(that: T): Int = ord.compare(x, that) }
}

同样我们使用scala实现上面java的例子

1.使用Orderding实现

object SortedApp {

  def main(args: Array[String]): Unit = {

    //实现思路，Man继承Ordeed里的compared方法实现的，里面有隐式转换
    val man1 = new Man("man1", 32)
    val man2 = new Man("man2", 18)

    implicit val comparator: Ordering[Man] = new Ordering[Man] {
      override def compare(x: Man, y: Man): Int = x.age - y.age
    }

    println(new MaxValue(man1, man2).compare)
  }
}

class Man(val name: String, val age: Int) {

  override def toString: String = s"$name\t$age"
}

// : 为上下文界定
class MaxValue[T: Ordering](x: T, y: T)(implicit comparator: Ordering[T]) {

  //comparator为隐式参数
  def compare: T = if (comparator.compare(x, y) < 0) x else y
}

2.使用Orderded实现

object SortedApp {

  def main(args: Array[String]): Unit = {
    //实现思路，Man继承Ordeed里的compared方法实现的，里面有隐式转换
    val man1 = new Man("man1", 32)
    val man2 = new Man("man2", 18)

    println(new MaxValue(man1, man2).compare)
  }
}

class Man(val name: String, val age: Int) extends Ordered[Man] {
  override def compare(that: Man): Int = this.age - that.age

  override def toString: String = s"$name\t$age"
}

class MaxValue[T <: Ordered[T]](x: T, y: T) {

  def compare: T = if (x.compareTo(y) < 0) x else y
}

在上面的例子，在Man的类中，Man继承了Ordered这个类，里面发生了隐式转换，我们也可以自己手动实现隐式转换

object SortedApp2 {

  def main(args: Array[String]): Unit = {

    implicit def userToOrderedUser(man:Man): Ordered[Man] = new Ordered[Man]{
      override def compare(that: Man): Int = man.age - that.age
    }

    //实现思路，Man继承Ordeed里的compared方法实现的，里面有隐式转换
    val man1 = new Man("man1", 32)
    val man2 = new Man("man2", 18)

    println(new MaxValue(man1, man2).compare)


  }
}

class Man(val name: String, val age: Int) {

  override def toString: String = s"$name\t$age"
}

class MaxValue[T <% Ordered[T]](x: T, y: T) {

  def compare: T = if (x.compareTo(y) < 0) x else y
}