kotlin必备常用重载运算符手册

算术运算符

+ 运算符

+ 运算符用于将两个值相加。在 Kotlin 中，您能够经过为您的类型界说名为 plus 的函数来支撑 + 运算符。例如：

class Point(val x: Int, val y: Int) {
    operator fun plus(other: Point): Point {
        return Point(x + other.x, y + other.y)
    }
}
val p1 = Point(1, 2)
val p2 = Point(3, 4)
val p3 = p1 + p2 // 运用 + 运算符核算两个点的和

在这个示例中，Point 类型完成了 plus 函数，以支撑 + 运算符。当您运用 + 运算符将两个 Point 目标相加时，Kotlin 将调用 plus 函数来履行实践的添加操作。

- 运算符

- 运算符用于从一个值中减去另一个值。在 Kotlin 中，您能够经过为您的类型界说名为 minus 的函数来支撑 - 运算符。例如：

class Point(val x: Int, val y: Int) {
    operator fun minus(other: Point): Point {
        return Point(x - other.x, y - other.y)
    }
}
val p1 = Point(3, 4)
val p2 = Point(1, 2)
val p3 = p1 - p2 // 运用 - 运算符核算两个点之间的差

在这个示例中，Point 类型完成了 minus 函数，以支撑 - 运算符。当您运用 - 运算符从一个 Point 目标中减去另一个 Point 目标时，Kotlin 将调用 minus 函数来履行实践的减法操作。

* 运算符

* 运算符用于将两个值相乘。在 Kotlin 中，您能够经过为您的类型界说名为 times 的函数来支撑 * 运算符。例如：

class Point(val x: Int, val y: Int) {
    operator fun times(scale: Double): Point {
        return Point((x * scale).toInt(), (y * scale).toInt())
    }
}
val p1 = Point(1, 2)
val p2 = p1 * 2.5 // 运用 * 运算符将点的坐标乘以一个因子

在这个示例中，Point 类型完成了 times 函数，以支撑 * 运算符。当您运用 * 运算符将一个 Point 目标乘以一个因子时，Kotlin 将调用 times 函数来履行实践的乘法操作。

/ 运算符

/ 运算符用于将一个值除以另一个值。在 Kotlin 中，您能够经过为您的类型界说名为 div 的函数来支撑 / 运算符。例如：

class Point(val x: Int, val y: Int) {
    operator fun div(scale: Double): Point {
        return Point((x / scale).toInt(), (y / scale).toInt())
    }
}
val p1 = Point(10, 20)
val p2 = p1 / 2.5 // 运用 / 运算符将点的坐标除以一个因子

在这个示例中，Point 类型完成了 div 函数，以支撑 / 运算符。当您运用 / 运算符将一个 Point 目标除以一个因子时，Kotlin 将调用 div 函数来履行实践的除法操作。

比较运算符

== 和 != 运算符

== 和 != 运算符用于比较两个值是否相等。在 Kotlin 中，您能够经过为您的类型界说名为 equals 的函数来支撑 == 和 != 运算符。Kotlin 还会为您主动生成 equals 函数和 hashCode 函数。例如：

class Point(val x: Int, val y: Int) {
    operator fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (other !is Point) return false
        return x == other.x && y == other.y
    }
}
val p1 = Point(1, 2)
val p2 = Point(1, 2)
val p3 = Point(3, 4)
p1 == p2 // true，由于 p1 和 p2 的坐标相同
p1 != p3 // true，由于 p1 和 p3 的坐标不同

在这个示例中，Point 类型完成了 equals 函数，以支撑 == 和 != 运算符。当您运用 == 或 != 运算符比较两个 Point 目标时，Kotlin 将调用 equals 函数来履行实践的比较操作。

需求留意的是，在完成 equals 函数时，您应该按照约好遵循以下几个规矩：

• 自反性：关于任何非空引证值 x ，x.equals(x) 应该回来 true。
• 对称性：关于任何非空引证值 x 和 y，假如 x.equals(y) 回来 true，那么 y.equals(x) 也应该回来 true。
• 传递性：关于任何非空引证值 x、y 和 z，假如 x.equals(y) 回来 true，且 y.equals(z) 也回来 true，那么 x.equals(z) 也应该回来 true。
• 一致性：关于任何非空引证值 x 和 y，只需目标上所用的信息没有被修正，屡次调用 x.equals(y) 应该始终回来相同的成果。
• 非空性：关于任何非空引证值 x，x.equals(null) 应该回来 false。

<、<=、> 和 >= 运算符

<、<=、> 和 >= 运算符用于比较两个值的大小关系。在 Kotlin 中，您能够经过为您的类型界说名为 compareTo 的函数来支撑这些运算符。例如：

class Point(val x: Int, val y: Int) : Comparable<Point> {
    override operator fun compareTo(other: Point): Int {
        return compareValuesBy(this, other, { it.x }, { it.y })
    }
}
val p1 = Point(1, 2)
val p2 = Point(3, 4)
p1 < p2 // true，由于 p1 的坐标小于 p2 的坐标

在这个示例中，Point 类型完成了 compareTo 函数，并完成了 Comparable<Point> 接口，以支撑比较运算符。当您运用 <、<=、> 和 >= 运算符比较两个 Point 目标时，Kotlin 将调用 compareTo 函数来履行实践的比较操作。

需求留意的是，在完成 compareTo 函数时，您应该保证其满意一些约好：

• 回来值为负数表明当时目标小于比较目标。
• 回来值为零表明当时目标等于比较目标。
• 回来值为正数表明当时目标大于比较目标。

区间运算符

.. 运算符

.. 运算符用于表明一个区间规模。在 Kotlin 中，您能够经过为您的类型界说名为 rangeTo 的函数来支撑 .. 运算符。例如：

class Date(val year: Int, val month: Int, val day: Int) {
    operator fun rangeTo(other: Date): DateRange {
        return DateRange(this, other)
    }
}
class DateRange(val start: Date, val endInclusive: Date) : Iterable<Date> {
    override fun iterator(): Iterator<Date> {
        return object : Iterator<Date> {
            var current = start
            override fun hasNext() = current <= endInclusive
            override fun next(): Date {
                val next = current
                current = current.nextDay()
                return next
            }
        }
    }
    private fun Date.nextDay(): Date {
        // 核算日期的下一天
    }
}
val startDate = Date(2022, 1, 1)
val endDate = Date(2022, 1, 31)
val dates = startDate..endDate // 运用 .. 运算符创立一个日期规模
for (date in dates) {
    println(date) // 输出该日期规模内的所有日期
}

在这个示例中，Date 类型完成了 rangeTo 函数，以支撑 .. 运算符。当您运用 .. 运算符创立一个日期规模时，Kotlin 将调用 rangeTo 函数来创立实践的规模目标。由于规模目标完成了 Iterable 接口，因而能够经过在 for 循环中迭代规模内的值来输出它们。

需求留意的是，在完成 rangeTo 函数时，您应该保证其回来一个完成了 Iterable 接口的目标，而且该目标应支撑运用 for 循环遍历规模内的所有值。

in 运算符

in 运算符用于查看一个值是否坐落某个区间内。在 Kotlin 中，区间目标完成了 ClosedRange<T> 接口，该接口界说了一个名为 contains 的函数，用于查看一个值是否坐落该区间内。例如：

class Date(val year: Int, val month: Int, val day: Int) : Comparable<Date> {
    override operator fun compareTo(other: Date): Int {
        // 比较两个日期的大小
    }
}
val startDate = Date(2022, 1, 1)
val endDate = Date(2022, 1, 31)
val currentDate = Date(2022, 1, 15)
currentDate in startDate..endDate // true，由于当时日期处于该区间内

在这个示例中，startDate..endDate 运用 .. 运算符创立了一个 Date 类型的区间目标。当您运用 in 运算符查看某个日期是否坐落该区间内时，Kotlin 将调用 contains 函数来履行实践的查看操作。

需求留意的是，在完成 contains 函数时，您应该保证其满意以下约好：

• 函数参数应为一个与区间元素类型相同的值，并回来一个布尔值，指示该值是否坐落区间内。
• 区间目标应完成 ClosedRange<T> 接口，而且应保证在包括开始和完毕元素的情况下遵循闭合区间或半开区间的规矩。

until 运算符

until 运算符用于表明一个半开区间，即不包括完毕元素的区间规模。在 Kotlin 中，您能够经过为您的类型界说名为 rangeTo 的函数来支撑 until 运算符。例如：

class Date(val year: Int, val month: Int, val day: Int) {
    operator fun rangeTo(other: Date): DateRange {
        return DateRange(this, other)
    }
}
class DateRange(val start: Date, val endExclusive: Date) : Iterable<Date> {
    override fun iterator(): Iterator<Date> {
        return object : Iterator<Date> {
            var current = start
            override fun hasNext() = current < endExclusive
            override fun next(): Date {
                val next = current
                current = current.nextDay()
                return next
            }
        }
    }
    private fun Date.nextDay(): Date {
        // 核算日期的下一天
    }
}
val startDate = Date(2022, 1, 1)
val endDate = Date(2022, 2, 1)
val dates = startDate until endDate // 运用 until 运算符创立一个日期规模
for (date in dates) {
    println(date) // 输出该日期规模内的所有日期，不包括完毕日期
}

在这个示例中，Date 类型完成了 rangeTo 函数，以支撑 until 运算符。当您运用 until 运算符创立一个日期规模时，Kotlin 将调用 rangeTo 函数来创立实践的规模目标。由于规模目标完成了 Iterable 接口，因而能够经过在 for 循环中迭代规模内的值来输出它们。

需求留意的是，在完成 rangeTo 函数时，您应该保证其回来一个完成了 Iterable 接口的目标，而且该目标应支撑运用 for 循环遍历半开区间内的所有值。

其他运算符

in 和 !in 运算符

in 运算符用于查看一个值是否归于一个调集、数组或区间等目标。在 Kotlin 中，您能够经过为您的类型界说名为 contains 的函数来支撑 in 运算符。例如：

class Point(val x: Int, val y: Int) {
    operator fun contains(other: Point): Boolean {
        return x == other.x && y == other.y
    }
}
val p1 = Point(1, 2)
val p2 = Point(3, 4)
val points = listOf(p1, p2)
p1 in points // true，由于点 p1 在列表中
p2 !in points // false，由于点 p2 不在列表中

在这个示例中，Point 类型完成了 contains 函数，以支撑 in 运算符。当您运用 in 或 !in 运算符查看某个 Point 目标是否归于一个列表时，Kotlin 将调用 contains 函数来履行实践的查看操作。

需求留意的是，在完成 contains 函数时，您应该保证其满意一些约好：

• 当您的类型是一个调集或许数组时，contains 函数应该承受一个参数，表明要查看的元素，并回来一个布尔值，指示该元素是否归于该调集或数组。
• 当您的类型是一个区间或许带有 Comparable 接口完成的目标时，contains 函数应该承受一个参数，表明要查看的值，并回来一个布尔值，指示该值是否坐落该区间或许目标的值规模内。

+=、-=、*= 和 /= 运算符

+=、-=、*= 和 /= 运算符用于对一个可变目标（如列表或许数组）进行修正操作。在 Kotlin 中，您能够经过为您的类型界说名为 plusAssign、minusAssign、timesAssign 和 divAssign 的函数来支撑这些运算符。例如：

class Point(var x: Int, var y: Int) {
    operator fun plusAssign(other: Point) {
        x += other.x
        y += other.y
    }
}
var p1 = Point(1, 2)
val p2 = Point(3, 4)
p1 += p2 // 运用 += 运算符将点 p2 加到点 p1 上

在这个示例中，Point 类型完成了 plusAssign 函数，以支撑 += 运算符。当您运用 +=、-=、*= 和 /= 运算符对一个可变目标进行修正时，Kotlin 将调用 plusAssign、minusAssign、timesAssign 和 divAssign 函数来履行实践的修正操作。

需求留意的是，在完成 plusAssign、minusAssign、timesAssign 和 divAssign 函数时，您应该保证其满意以下约好：

• 函数参数有必要为可变目标。
• 函数不该回来任何值。
• 在完成修正操作后，目标的状况应该反映出修正后的成果。

is 运算符

is 运算符用于查看一个目标是否为某个类型或许其子类型。在 Kotlin 中，您能够经过为您的类型界说名为 isInstance 的函数来支撑 is 运算符。例如：

open class Animal
class Cat : Animal()
val animal = Cat()
if (animal is Cat) {
    // 假如动物是一只猫，则履行以下操作
}

在这个示例中，Cat 类型是 Animal 类型的子类型。当您运用 is 运算符查看某个动物是否为猫时，Kotlin 将调用 isInstance 函数来履行实践的查看操作。

需求留意的是，在完成 isInstance 函数时，您应该保证其满意以下约好：

• 函数参数应为一个 Any? 类型的值，并回来一个布尔值，指示该值是否为当时类型或许其子类型的实例。
• 当您为一个类界说 isInstance 函数时，应将其界说为一个 companion object 中的扩展函数，以保证该函数能够作为 is 运算符的一部分运用而无需创立实例。