用 Kotlin 做对比，就是插 Comparable 啦！嫁接这姐，你就可以货比三家。

💪0. 比较神器——Comparable

👸VS👸🏻，🙅Fight！叽里咕噜…
比较这个嗜好，女人们最喜欢，比上比下，比房子比车子，甚至比子女。
👀：在 Kotlin 世界里，你插这个就能比，就是 Comparable 插件 。

---

🏎️1. 方程 compareTo()

compareTo() 是主打方程，发出比一比的号角。
这个 class 是地主🐢，compareTo( 对手🐰 )。

👧🏻：这不是龟兔赛跑吗？好玩！
🤔：这个比喻不好，不明白，咱还是画圈吧。

介绍个两个免费网上Kotlin 编译器 ——

• Kotlin Playground 游乐园 —— 这个快👍。
• JDoodle —— 怪名。现打现用，今天就是用这个面试废了。我不是应聘写手机的吗？考官就考基础。我就琢磨着这是干什么来着，手机只有两个问题，其它全是 order，sort，linked list, binary search，可能银行就喜欢这个。记性不好，明年再来。哈奇😷！

✔️它们好处是现打现用，❌坏处是编译功能缺失。你们谁能写个 AI 补补？
…

class Circle(val radius: Int): Comparable<Circle> {
    
    private val area: Double = 3.14 * radius * radius
    
    override fun compareTo(other: Circle): Int {
    
        val area2 = other.area
  
        // 对比面积
        if(area == area2){
    
            return 0; 
        } else if(area < area2){
    
            return -1; 
        } 
        return 1; 
    } 
    
    override fun toString(): String {
   
        return "Type(circle) -> radius = $radius, area = $area"
    }
}

fun main(){
    
    val cirs: List<Circle> = listOf(
        Circle(5), Circle(4), Circle(4), Circle(7), Circle(8), Circle(10)) 
  
    println("Is cir1 > cir2? ${
     cirs[0] > cirs[1]}") 
    println("Is cir3 > cir1? ${
     cirs[2] > cirs[1]}")
    println("Is cir3 == cir1? ${
     cirs[2] == cirs[1]}")
}

这个 compareTo 需要覆盖，因为 Comparable 只是个 Interface，骨头也。它要做出三种答复 ——

• 等于 ⇨ 0
• 小于 ⇨ -1
• 大于 ⇨ 1

简单，明快。
结果：

Is cir1 > cir2? true
Is cir3 > cir1? false
Is cir3 == cir1? false

---

🚝2. 方程 coerceAtLeast() 较大

这是比最小大一点的意思，例子：
coerceAtLeast( 较大 )：

• 是问我比最小大吗？—— 是就我上，反之最小上。

咱们试试：

    var min = Circle(2) 
    var max = Circle(9) 
    
    println("\nmin: ${
     min}\ncir2: ${
     cirs[1]}")    
    println("Find bigger: cir1 > min? Bigger is ${
     cirs[1].coerceAtLeast(min)}") 

🏃结果：

min: Type(circle) -> radius = 2, area = 12.56
cir2: Type(circle) -> radius = 4, area = 50.24
Find bigger: cir1 > min? Bigger is Type(circle) -> radius = 4, area = 50.24

➕找个大小差不多看看：

    println("\ncir1: ${
     cirs[0]}\ncir2: ${
     cirs[1]}")    
    println("Find bigger: cir1 > cir2? Bigger is ${
     cirs[0].coerceAtLeast(cirs[1])}") 
    println("Find bigger: cir2 > cir1? Bigger is ${
     cirs[1].coerceAtLeast(cirs[0])}") 

🏃结果：

cir1: Type(circle) -> radius = 5, area = 78.5
cir2: Type(circle) -> radius = 4, area = 50.24
Find bigger: cir1 > cir2? Bigger is Type(circle) -> radius = 5, area = 78.5
Find bigger: cir2 > cir1? Bigger is Type(circle) -> radius = 5, area = 78.5

都是较大的胜出，这就是 coerceAtLeast 。

---

🚈3. 方程 coerceAtMost() 较小

顾名思义，coerceAtMost() 就比最大小点，较小也。

    println("\ncir5: ${
     cirs[4]}\nmax: ${
     max}")    
    println("Find bigger: cir5 > max? Bigger is ${
     cirs[4].coerceAtMost(max)}") 
    println("Find bigger: cir5 > max? Bigger is ${
     max.coerceAtMost(cirs[4])}") 

比对 8 号选手 和 max 选手。

cir5: Type(circle) -> radius = 8, area = 200.96
max: Type(circle) -> radius = 9, area = 254.34
Find bigger: cir5 > max? Bigger is Type(circle) -> radius = 8, area = 200.96
Find bigger: cir5 > max? Bigger is Type(circle) -> radius = 8, area = 200.96

8 号较小胜出。现在看来好像多余，其实不是，思维有点不一样而已。反正又不用我写，用就是了。

---

🚅4. 方程 coerceIn() 域内

明白不？这个方程当然有一大一小，要不怎么知道是否在队伍内。
例子：

coerceIn( 最小，最大 )

拿来玩玩：

    println("\ncir4: ${
     cirs[3]}\nmin: ${
     min}\nmax: ${
     max}")    
    println("Is cir4 in min and max? ${
     cirs[3].coerceIn(min, max) == cirs[3]}") 

在室吗？🏃🏼

cir4: Type(