本文共 2747 字，大约阅读时间需要 9 分钟。

##Scala 集成排序方法——从浅入 深入理解 sorted、sortBy 和 sortWith

在 Scala 中，集合的排序操作通常通过 sorted、sortBy 和 sortWith 这三个方法实现，分别对应不同的排序需求。本文将从基础到进阶，帮助开发者理解这三个方法的区别及其使用场景。

###1. 排序的基础——sorted方法

sorted 是 Scala 集合中最基本的排序方法。它默认使用udp og新.java.util.Arrays排序逻辑对集合中的元素进行排序。该方法的核心作用是对集合中的元素按照默认排序规则进行排序。

####使用示例：

val lb = new ListBuffer[Int]
lb.append(1, 2, 9, 4, 5, 2)
var lb2 = lb.sorted
lb2.foreach(x => println("lb2 : "+x))

运行上述代码，输出结果为：

lb2 : 1
lb2 : 2
lb2 : 2
lb2 : 4
lb2 : 5
lb2 : 9

排序结果表明，sorted 方法能正确地按照升序对集合元素进行排序。

###2. 定制排序规则——sortBy方法

相比于 sorted，sortBy 方法的独特之处在于它允许开发者自定义排序规则。通过传递一个函数，该函数定义了排序的依据，sortBy方法会根据函数返回的值对集合元素进行排序。

####定义排序规则：

def sortTest(i:Int) = {
  i match {
    case 1 => 2
    case 2 => 1
    case 4 => 0
    case _ => 3
  }
}

####使用示例：

var lb3 = lb.sortBy(sortTest)
lb3.foreach(x => println("lb3: "+x))

运行上述代码，输出结果为：

lb3: 1
lb3: 2
lb3: 2
lb3: 4
lb3: 5
lb3: 9

从输出结果可以看出，sortBy 方法能够根据定义的排序规则对集合元素进行定制排序。每个元素会被传递给 sortTest 函数，函数返回的值决定了排序的顺序。

####扩展案例——复杂排序规则

为了更深入地理解 sortBy 的应用场景，我们可以定义更复杂的排序规则。以 Person 类为例：

// 定义 Person 类
class Person(age:Int, salary:Double, name:String) {
  var Age = age
  var Salary = salary
  var Name = name
}
val lisa = new Person(38, 2.3, "lisa")
val nana = new Person(1, 3.4, "nana")
val zhaoSi = new Person(1, 5.9, "赵四")
val grandpa = new Person(80, 20, "grandpa")
// 创建一个 ListBuffer[Person]
val listPerson = new ListBuffer[Person]
listPerson.append(lisa, nana, zhaoSi, grandpa)
// 定义排序规则
var sortRule = (p: Person) => {
  (p.Age, p.Salary, p.Name)
}
// 使用自定义排序规则进行排序
var listPersonSorted = listPerson.sortBy(sortRule)(Ordering.Tuple3(Ordering.Int.reverse, Ordering.Double.reverse, Ordering.String.reverse))
listPersonSorted.foreach(x => println(x.Name, x.Age, x.Salary))

运行上述代码，可以看到输出结果按照年龄薪水和姓名进行降序排列。如果需要仅按照年龄和薪水排序，可以修改排序规则：

var sortRule = (p: Person) => {
  (p.Age, p.Salary)
}

修改后的排序结果将仅根据年龄和薪水对元素进行排序。

###3. 定制比较逻辑——sortWith 方法

sortWith 方法的核心与 sorted 方法的区别在于，它不直接使用排序规则，而是接受一个比较函数。该函数定义了一个两个元素之间的比较逻辑，基于比较函数的返回值来排序集合元素。

####定义一个忽略大小写的比较函数：

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

####使用示例：

def test2() = {
  val list = List("a", "g", "F", "B", "c")
  val sortWithList1 = list.sortWith(_ < _) // List(B, F, a, c, g)
  val sortwithList2 = list.sortWith((left, right) => left < right) // List(B, F, a, c, g)
  val sortwithList3 = list.sortWith(compareIngoreUpperCase) // List(a, B, c, F, g)
  println(sortWithList1)
  println(sortwithList2)
  println(sortwithList3)
}

运行上述代码，输出结果分别为：

List(B, F, a, c, g)
List(B, F, a, c, g)
List(a, B, c, F, g)

从输出结果可以看出，sortWith 方法能够根据定义的比较函数对元素进行定制排序。在 compareIngoreUpperCase 函数中，我们忽略了字符串的大小写，实现了忽略大小写的排序。

###总结

通过对 sorted、sortBy 和 sortWith 这三个方法的学习，我们可以更好地理解 Scala 集成排序的灵活性。无论是简单的默认排序，还是复杂的定制排序，Scala 都提供了丰富的工具来满足开发者的需求。