sort

sorted：适合单集合的升降序

sortBy：适合对单个或多个属性的排序，代码量比较少，推荐使用这种

sortWith：适合定制化场景比较高的排序规则，比较灵活，也能支持单个或多个属性的排序，但代码量稍多，内部实际是通过java里面的Comparator接口来完成排序的。

package spark2021

import breeze.linalg.reverse

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


    //基于单集合单字段的排序
    val list = List(1,5,3,2,4)

    //sort排序:默认升序
    println(list.sorted)
    println(list.sorted,reverse)

    //sortBy
    println(list.sortBy(x=>x))
    println(list.sortBy(x=>x).reverse)

    //sortWith
    println(list.sortWith((x1,x2)=>x1<x2))
    println(list.sortWith(_<_))
    println(list.sortWith(_<_).reverse)



  }

}

 

package spark2021

import breeze.linalg.reverse

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


    //基于元组多字段的排序
    //按第三个字段升序，第一个字段降序
    val array = Array(("a",5,1),("c",3,1),("b",1,3))



    //sortBy
    val array_sortBy = array.sortBy(r=>(r._3,r._1))(Ordering.Tuple2(Ordering.Int,Ordering.String.reverse))
    array_sortBy.map(println)

    //sortWith

    val array_sortWith = array.sortWith({
      case(x1,x2)=>{
        if (x1._3==x2._3){
          x1._1>x2._1
        }else{
          x1._3<x2._3
        }
      }
    })

    array_sortWith.map(println)

  }

}

 

package spark2021

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

    //基于类的排序
    //先按年龄排序，如果一样，就按照名称降序排

    val p1 = Person("cat",23)
    val p2 = Person("dog",21)
    val p3 = Person("duck",13)

    val array = Array(p1,p2,p3)

    //sortBy
    val array_sortBy = array.sortBy(person=>(person.age,person.name))(Ordering.Tuple2(Ordering.Int,Ordering.String.reverse))
    array_sortBy.map(println)

    //sortWith
    val array_sortWith = array.sortWith({
      case(person1,person2)=>{
        if(person1.age==person2.age){
          person1.name>person2.name

        }else{
          person1.age<person2.age
        }
      }
    })

    array_sortWith.map(println)

  }

}

case class Person(val name:String,val age:Int)

 

 

package spark2021

object ImplicitValue {
  implicit val KeyOrdering = new Ordering[String] {
    override def compare(x: String, y: String) : Int = {
      y.compareTo(x)
    }
  }
}

package spark2021

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


    val list = List( "a", "g", "f", "b", "c")

    //隐式比较器,按字符串逆序
    import ImplicitValue.KeyOrdering
    val sortedList = list.sorted
    println(sortedList) // List(g, c, a, F, B)


    //sortWith:sortWith需要传入一个比较函数用来比较！
    val sortwithList2 = list.sortWith((left, right) => left < right) //List(B, F, a, c, g)
    val sortWithList1 = list.sortWith(_ < _) // List(B, F, a, c, g)
    val sortwithList3 = list.sortWith(compareIngoreUpperCase) // List(a, B, c, F, g)

    println(sortWithList1)
    println(sortwithList2)
    println(sortwithList3)


    //sortBy:sortBy需要提供一个属性

  }
  def compareIngoreUpperCase(e1: String, e2: String) : Boolean = {
    e1.toLowerCase < e2.toLowerCase
  }


}