前言
在 Kotlin 中，我們可以用 約定的操作符，代替 調用代碼中以特定的命名定義的函數，來實現 與之對應的操作。例如在類中定義了一個名為 plus 的特殊方法，就可以使用加法運算符 + 代替 plus() 的方法調用。由于你無法修改已有的接口定義，因此一般可以通過 擴展函數 來為現有的類增添新的 約定方法，從而使得 操作符重載 這一語法糖適應任何現有的 Java 類。
算術運算符
我們就從最簡單直接的例子 + 這一類算術運算符開始。
data class Point(val x: Int, val y: Int) { operator fun plus(other: Point) = Point(x + other.x, y + other.y) operator fun plus(value: Int) = "toString: ${Point(x + value, y + value)}"}fun main(args: Array<String>) { val p1 = Point(1, 2) val p2 = Point(3, 4) println(p1 + p2) println(p1 + 3)}/*Point(x=4, y=6)toString: Point(x=4, y=5)*/// 第一個文件：package package0operator fun Point.times(value: Int) = Point(x * value, y * value)// 第二個文件：package package1operator fun Point.times(value: Int) = Unit // Do nothing.// 使用第一個擴展操作符：import package0.timesval newPoint = Point(1, 2) * 3
Kotlin 為一些基本類型預定義了一些操作符方法，我們平時常寫的基本數據計算也可以翻譯成調用這些操作符方法，比如 (2 + 3) * 4 可以翻譯成 2.plus(3).times(4)，2 + 3 * 4 可以翻譯成 2.plus(3.times(4))。根據擴展函數的語法，擴展函數無法覆蓋與類已有的方法簽名相同的方法，因此，不必擔心隨隨便便給 Int 自定義一個 plus 擴展方法就能讓 1 + 1 變得不等于 2。
同時，所有操作符都針對基本類型做了優化，比如 1 + 2 * 3、4 < 5，不會為它們引入函數調用的開銷。
所有可重載的算術運算符有：
| 表達式 | 翻譯為 |
|---|---|
| a + b | a.plus(b) |
| a - b | a.minus(b) |
| a * b | a.times(b) |
| a / b | a.div(b) |
| a % b | a.rem(b)、 a.mod(b) （在 Kotlin 1.1 中被棄用） |
| a..b | a.rangeTo(b) |
它們的優先級與普通的數字類型運算符優先級相同。其中 rangeTo 會在下面說明。
廣義賦值操作符
| 表達式 | 翻譯為 |
|---|---|
| a += b | a.plusAssign(b) |
| a -= b | a.minusAssign(b) |
| a *= b | a.timesAssign(b) |
| a /= b | a.divAssign(b) |
| a %= b | a.remAssign(b)、 |
對于以上廣義賦值操作符：
data class Size(var width: Int = 0, var height: Int = 0) { operator fun plus(other: Size): Size { return Size(width + other.width, height + other.height) } operator fun plusAssign(other: Size) { width += other.width height += other.height }}fun main(args: Array<String>) {// var s1 = Size(1, 2) // 如果這么寫，執行 += 時會報錯. val s1 = Size(1, 2) val s2 = Size(3, 4) s1 += s2}我們使用這個例子來理解：為什么使用 var 定義的 s1 會導致 += 報錯呢？因為理論上，執行 += 時，既可以調用 s1 = s1 + s2，也就是 s1 = s1.plus(s2)，又可以調用 s1.plusAssign(s2)，都符合操作符重載約定，這樣就會產生歧義，而如果使用 val 定義 s1，則只可能執行 s1.plusAssign(s2)，因為 s1 不可被重新賦值，因此 s1 = s1 + s2 這樣的語法是出錯的，永遠不能能調用，那么調用 s1 += s2 就不會產生歧義了。
既然編譯器會幫我把 a += b 解釋成 a = a + b，那是不是意味著我只需要 plus 永遠不需要 plusAssign 了呢？比較好的實踐方式是：
Kotlin 標準庫中就是這么實現的：
fun main(args: Array<String>) { val list = arrayListOf(1, 2) list += 3 // 添加元素到自身集合, 沒有新的對象被創建, 調用的是 add 方法. val newList = list + 4 // 創建一個新的 ArrayList, 添加自身元素和新元素并返回新的 ArrayList.}in
| 表達式 | 翻譯為 |
|---|---|
| a in b | b.contains(a) |
| a !in b | !b.contains(a) |
println("hello" in arrayListOf("hello", ", ", "world"))/*true*/在 for 循環中使用 in 操作符會執行迭代操作，for(x in list) { /* 遍歷 */ } 將被轉換成 list.iterator() 的調用，然后在上面重復調用hasNext 和 next 方法。
rangeTo
rangeTo 用于創建一個區間。例如 1..10 也就是 1.rangeTo(10) 代表了從 1 到 10 這 10 個數字，Int.rangeTo 方法返回一個 IntRange 對象，IntRange 類定義如下：
/** * A range of values of type `Int`. */public class IntRange(start: Int, endInclusive: Int) : IntProgression(start, endInclusive, 1), ClosedRange<Int> { override val start: Int get() = first override val endInclusive: Int get() = last override fun contains(value: Int): Boolean = first <= value && value <= last override fun isEmpty(): Boolean = first > last override fun equals(other: Any?): Boolean = other is IntRange && (isEmpty() && other.isEmpty() || first == other.first && last == other.last) override fun hashCode(): Int = if (isEmpty()) -1 else (31 * first + last) override fun toString(): String = "$first..$last" companion object { /** An empty range of values of type Int. */ public val EMPTY: IntRange = IntRange(1, 0) }}它的基類 IntProgression 實現了 Iterable 接口，因此 1..10 可以用來迭代：
for (index in 1..10) { // 遍歷 1 到 10, 包括 1 和 10.}IntRange 還實現了接口 ClosedRange ，可以用來判斷某元素是否屬于該區間。
Kotlin 為 Comparable 定義了擴展函數 rangeTo：
/** * Creates a range from this [Comparable] value to the specified [that] value. * * This value needs to be smaller than [that] value, otherwise the returned range will be empty. * @sample samples.ranges.Ranges.rangeFromComparable */public operator fun <T: Comparable<T>> T.rangeTo(that: T): ClosedRange<T> = ComparableRange(this, that)
因此所有的 Comparable 對象都可以使用 .. 區間操作符，例如：
fun main(args: Array<String>) { val c1 = Calendar.getInstance() // 代表今天. val c2 = Calendar.getInstance() c2.add(Calendar.DATE, 10) // 代表 10 天后. val c3 = Calendar.getInstance() c3.add(Calendar.DATE, 3) // 代表 3 天后. val c4 = Calendar.getInstance() c4.add(Calendar.DATE, 13) // 代表 13 天后. // 判斷某日期是否在某兩個日期范圍內. println(c3 in c1..c2) println(c4 in c1..c2)}/*truefalse*/一元前綴操作符
| 表達式 | 翻譯為 |
|---|---|
| +a | a.unaryPlus() |
| -a | a.unaryMinus() |
| !a | a.not() |
data class Point(val x: Int, val y: Int)operator fun Point.unaryMinus() = Point(-x, -y)val point = Point(10, 20)println(-point)/*Point(x=-10, y=-20)*/
遞增與遞減
| 表達式 | 翻譯為 |
|---|---|
| a++ | a.inc() |
| a– | a.dec() |
編譯器自動支持與普通數字類型的前綴、后綴自增運算符相同的語義。例如后綴運算會先返回變量的值，然后才執行 ++ 操作。
索引訪問操作符
| 表達式 | 翻譯為 |
|---|---|
| a[i] | a.get(i) |
| a[i, j] | a.get(i, j) |
| a[i_1, ……, i_n] | a.get(i_1, ……, i_n) |
| a[i] = b | a.set(i, b) |
| a[i, j] = b | a.set(i, j, b) |
| a[i_1, ……, i_n] = b | a.set(i_1, ……, i_n, b) |
@Suppress("IMPLICIT_CAST_TO_ANY", "UNCHECKED_CAST")operator fun <T> SharedPreferences.get(key: String, defValue: T) = when (defValue) { is String -> getString(key, defValue) is Int -> getInt(key, defValue) is Long -> getLong(key, defValue) is Float -> getFloat(key, defValue) is Boolean -> getBoolean(key, defValue) else -> throw RuntimeException()} as T@SuppressLint("CommitPrefEdits")operator fun <T> SharedPreferences.set(key: String, value: T) = with(edit()) { when (value) { is String -> putString(key, value) is Int -> putInt(key, value) is Long -> putLong(key, value) is Float -> putFloat(key, value) is Boolean -> putBoolean(key, value) else -> throw RuntimeException() }.apply()}fun main(args: Array<String>) { val version = sp["key_version", 47] // 讀 sp. sp["key_version"] = 48 // 寫 sp.}調用操作符
| 表達式 | 翻譯為 |
|---|---|
| a() | a.invoke() |
| a(i) | a.invoke(i) |
| a(i, j) | a.invoke(i, j) |
| a(i_1, ……, i_n) | a.invoke(i_1, ……, i_n) |
相等與不等操作符
| 表達式 | 翻譯為 |
|---|---|
| a == b | a?.equals(b) ?: (b === null) |
| a != b | !(a?.equals(b) ?: (b === null)) |
這在 Any 中被定義。Java 的 a.equals(b) 相當于 Koltin 的 a == b，Java 的 a == b 相當于 Kotlin 的 a === b（同一性檢查）。要自定義 == 操作符其實就是覆寫 equals 方法。Kotlin 中 === 不可被重載。
比較操作符
| 表達式 | 翻譯為 |
|---|---|
| a > b | a.compareTo(b) > 0 |
| a < b | a.compareTo(b) < 0 |
| a >= b | a.compareTo(b) >= 0 |
| a <= b | a.compareTo(b) <= 0 |
要求 compareTo 返回值類型必須為 Int ，這與 Comparable 接口保持一致。
data class Movie(val name: String, val score: Int, val date: Date, val other: Any = Any()) : Comparable<Movie> { override fun compareTo(other: Movie): Int { return compareValuesBy(this, other, Movie::score, Movie::date, Movie::name) // 如果將 Movie::other 也用作比較會報錯, 因為 other 不是 Comparable 類型的。 }}fun main(args: Array<String>) { val df = SimpleDateFormat("yyyy-MM-dd", Locale.getDefault()) val movie0 = Movie("馬戲之王", 8, df.parse("2018-01-31")) val movie1 = Movie("神秘巨星", 7, df.parse("2018-01-01")) val movie2 = Movie("移動迷宮", 7, df.parse("2018-01-02")) println(movie0 < movie1) println(movie1 < movie2)}/*falsetrue*/其中的 compareValuesBy 方法如下：
/** * Compares two values using the specified functions [selectors] to calculate the result of the comparison. * The functions are called sequentially, receive the given values [a] and [b] and return [Comparable] * objects. As soon as the [Comparable] instances returned by a function for [a] and [b] values do not * compare as equal, the result of that comparison is returned. * * @sample samples.comparisons.Comparisons.compareValuesByWithSelectors */public fun <T> compareValuesBy(a: T, b: T, vararg selectors: (T) -> Comparable<*>?): Int { require(selectors.size > 0) return compareValuesByImpl(a, b, selectors)}private fun <T> compareValuesByImpl(a: T, b: T, selectors: Array<out (T)->Comparable<*>?>): Int { for (fn in selectors) { val v1 = fn(a) val v2 = fn(b) val diff = compareValues(v1, v2) if (diff != 0) return diff } return 0}我們定義一個 Movie 類，它實現了 Comparable 接口，在比較時，希望按照 評分 、 上映日期 、 電影名稱 的優先級順序排序?？梢院唵蔚氖褂帽容^操作符對 Movie 對象進行“大小比較”。
操作符函數與 Java
Java 中調用 Kotlin 中的操作符方法，就跟調用普通方法一樣，你不能期望在 Java 中寫 new Point(1, 2) + new Point(3, 4) 這樣的語法，只能乖乖調用 new Point(1, 2).plus(new Point(3, 4))。
反之，Kotlin 中調用 Java 代碼卻可以同 Kotlin 中自定義操作符方法一樣方便。只要一個類提供了滿足操作符方法簽名的方法，哪怕它只是一個普通方法，不需要加 operator 修飾符（Java 中也沒有這個修飾符），就可以在 Kotlin 中以操作符的方式調用。例如：arrayList[0] 相當于 Java 中 arrayList.get(0)，盡管這個 get 方法是 Java 中定義的。又比如所有實現了 Comparable 的類實例都可以使用比較操作符 >、< 等進行比較。
Java 中的位運算符在 Kotlin 中是沒有的 ，它們只能使用普通方法加中綴表達式使用，只能用于 Int 和 Long，對應關系如下：
| Java 中 | Kotlin 中 |
|---|---|
| « 有符號左移 | shl(bits) |
| » 有符號右移 | shr(bits) |
| »> 無符號右移 | ushr(bits) |
| & 與 | and(bits) |
| | 或 | or(bits) |
| ^ 異或 | xor(bits) |
| ! 非 | inv() |
操作符重載與屬性委托、中綴調用
我們在使用委托屬性時也用過 operator 修飾符：
class Delegate { operator fun getValue(thisRef: Any?, property: KProperty<*>): String { //... } operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) { //... }}符合這樣方法簽名的 getValue 、 setValue 也是操作符函數，用于委托屬性的 getter 和 setter。
可以看出，操作符重載并不是一定要用如 * 、 + 、 < 這樣的符號來表示的，比如之前的 in 操作符，這里的 getter 、 setter。
除了以上這些標準的可被重載的操作符外，我們也可以通過中綴函數的調用來模擬自定義中綴操作符，實現形如 a in list 這樣的語法。
總結
以上就是這篇文章的全部內容了，希望本文的內容對大家的學習或者工作具有一定的參考學習價值，如果有疑問大家可以留言交流，謝謝大家對VeVb武林網的支持。
新聞熱點
疑難解答
