本文章已授权鸿洋微信公众号转载
目开源阅读录
-
空安全
-
方法支持添加默认参数
-
方法上面的参数不可变
-
类方法扩展
-
函数变量
-
内联函数
-
委托机制
-
类委托
-
属性委托
-
懒委托
-
-
扩展函数
-
let 函数
-
with 函数
-
run 函数
-
apply 函数
-
also 函数
-
-
运算符重载
空安全Kotlin
-
在 Java 不用强制我们处理空对象，所以常常会导致 NullPoint变量的指针其含义是指该变量的erException 空指针出现，现在 Kotlin 对空对象进行了限定，必须在编译时处理对象是否为空的情况，不然会导致编译不通过开源众包
-
在对象不可空的情况下，可以直接使用这个对象
fun getText() : String {
return "text"
}
val text = getText()
print(text.length)
- 在对象可空的情况下，必须要判断对象是否为空
fun getText() : String? {
return null
}
val text = getText()
if (text != null) {
print(text.length)
}
// 如果不想判断是否为空，可以直接这样，如果 text 对象为空，则会报空指针异常，一般情况下不推荐这样使用
val text = getText()
print(text!!.length)
// 还有一种更好的处理方式，如果 text 对象为空则不会报错，但是 text.length 的结果会等于 null
val text = getText()
print(text?.length)
方法支持添加默认参数
- 在 Java 方法上，我们可能会为了扩展某个方法而进行多次重载
public void toast(String text) {
toast(this, text, Toast.LENGTH_SHORT);
}
public void toast(Context context, String text) {
toast(context, text, Toast.LENGTH_SHORT);
}
public void toast(Context context, String text, int time) {
Toast.makeText(context, text, time).show();
}
toast("弹个吐司");
toast(this, "弹个吐司");
toast(this, "弹个吐司", Toast.LENGTH_LONG);
- 但是在 Kotlin 上面，我们无需进行重载，可以直接在方法上面直接定义参数的默apple认值
fun toast(context : Context = this, text : String, time : Int = Toast.LENGTH_SHORT) {
Toast.makeText(context, text, time).show()
}
toast(text = "弹个吐司")
toast(this, "弹个吐司")
toast(this, "弹个吐司", Toast.LENGTH_LONG)
方法上面的参数不可变
-
在 Java 方法上面，我们可以随意修改方法上面参数的赋值，appstore但是到了 Kotlin 这里是不行的，Kotlin 方法参数上面的变量是 val （对应 Java 的 final）类型的，那么这个时候我们有两种解决方案：
-
第一种，在方法appearance里面定义一个一模一样的变量，具体写法如下：
class XxxView : View {
override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
var widthMeasureSpec: Int = widthMeasureSpec
var heightMeasureSpec: Int = heightMeasureSpec
if (MeasureSpec.getMode(widthMeasureSpec) == MeasureSpec.AT_MOST) {
widthMeasureSpec = MeasureSpec.makeMeasureSpec(30, MeasureSpec.EXACTLY)
}
if (MeasureSpec.getMode(heightMeasureSpec) == MeasureSpec.AT_MOST) {
heightMeasureSpec = MeasureSpec.makeMeasureSpec(30, MeasureSpec.EXACTLY)
}
setMeasuredDimension(widthMeasureSpec, heightMeasureSpec)
}
}
-
但是编译器会报警告，提示我们出java语言现了重复变量，但是仍可正常编译和运行，所以不推荐这种写法
-
第二种，在方法里面定义一个不同开源中国名称的变量，具体写法如下：
class XxxView : View {
override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
var finalWidthMeasureSpec: Int = widthMeasureSpec
var finalHeightMeasureSpec: Int = heightMeasureSpec
if (MeasureSpec.getMode(finalWidthMeasureSpec) == MeasureSpec.AT_MOST) {
finalWidthMeasureSpec = MeasureSpec.makeMeasureSpec(30, MeasureSpec.EXACTLY)
}
if (MeasureSpec.getMode(finalHeightMeasureSpec) == MeasureSpec.AT_MOST) {
finalHeightMeasureSpec = MeasureSpec.makeMeasureSpec(30, MeasureSpec.EXACTLY)
}
setMeasuredDimension(widthMeasureSpec, heightMeasureSpec)
}
}
-
其实就在原来的基础上加一个 final 前缀，这样不仅解决了编译器警告的问题，还解决了我们还要重新想一个名称来给变量命名的烦恼。
-
那么肯定有人变量名会问了，有没有办法像 Java 一样改呢？关于这个问题我也纠APP结了一阵子，但是查阅了很多文档和资料，最终发现并没有办法，所以只能妥协了，毕竟这个世界上没有什么事物是完美的。
类方application法扩展
- 可以在不用继承的情况下对扩展原有类的方法，例如对 StrAPPing 类进行扩展方法
fun String.handle() : String {
return this + "Android轮子哥"
}
// 需要注意，handle 方法在哪个类中被定义，这种扩展只能在那个类里面才能使用
print("HJQ = ".handle())
HJQ = Android轮子哥
函数变量
- 在 Kotlin 语法中函数Java是可以作为变量进行传递的
var result = fun(number1 : Int, number2 : Int) : Int {
return number1 + number2
}
- 使用这个函数变量
println(result(1, 2))
内联函数
- 有人可能会问了，内联函数是虾米开源节流什么意思？我举个栗子，用 Kotlin 编写以下代码
class Demo {
fun test() {
showToast("666666")
}
/**
* 这个就是我们今天的主角：内联函数了，用 inline 关键字来修饰
*/
private inline fun showToast(message: String) {
ToastUtils.show(message)
}
}
- 经过反编译之后，会变成以下代码：
/* compiled from: Demo.kt */
public final class Demo {
public final void test() {
ToastUtils.show("666666");
}
}
-
看到这里相信大家应该知道内联函数的用法和作用了，内联函数就是在编译的时候将所有调用 inline 函数的代码直接替换成方法里面的代码，那么大家可能有疑问了，这样做有什么实际好处呢？它其实提升了代码的性能，这跟基本数据类型的常量会在编译的过程中被优化一样，但是如果 inline 函数被许多处地方调用，并且 inline 函数的实现代码比较多的情况变量下，也会相应导致代码量增加。
-
另外上面的代码示例中，编java语言译器在 inline 关键字上面有一个代码警告，原话是开源阅读app下载安装这样的java编译器：
Expected performance impact from inlining is insignificant. Inlining works best for functkotlin为什么流行不起来ions with papplea开源代码网站githubrameters of functional types
内联对性能的预期影响是微不足道的。内联最适用于参数为函数类型的函数
- 大致的意思是，上面的代码示例中，内联函数能起到开源阅读app下载安装的性变量类型有哪些能优化是微不足道的，它比较适合带有 lambda 参数的函数，根据这个提示，将上面的代码示例修改成下面这样就不会报代码警告了：
class Demo {
fun test() {
showToast({
println("测试输出了")
}, "7777777")
}
private inline fun showToast(function: () -> Unit, message: String) {
function.invoke()
ToastUtils.show(message)
}
}
- 有人可能会好奇了，这样就能有很大的性能提升？有什么判断依据呢？接下来让我们做变量的定义一组实验，加 inline 和不加 inline 反编变量的指针其含义是指该变量的译出来的代码有什么区别，先来看加 inline 之后反编译出来的代码长啥样
/* compiled from: Demo.kt */
public final class Demo {
public final void test() {
System.out.println("\u6d4b\u8bd5\u8f93\u51fa\u4e86");
ToastUtils.show("7777777");
}
}
- 一切都在java模拟器预料之中，那么不加 inline 反编译出来又是什么效果呢？
/* compiled from: Demo.kt */
public final class Demo {
public final void test() {
showToast(1.INSTANCE, "7777777");
}
private final void showToast(Function0<Unit> function, String message) {
function.invoke();
ToastUtils.show(message);
}
}
/* compiled from: Demo.kt */
final class Demo$test$1 extends Lambda implements Function0<Unit> {
public static final Demo$test$1 INSTANCE = new Demo$test$1();
Demo$test$1() {
super(0);
}
public final void invoke() {
System.out.println("\u6d4b\u8bd5\u8f93\u51fa\u4e86");
}
}
-
很明显，不加 inline 会导致多生成一个内部类，这个是 lambda 函数多出来的类，并且里面的示例还是静态，这无开源节流什么意思疑会增加内存消耗，另外这样还有另外一个好处，就是能少一层方法栈的调用。
-
除了 inline （内联）这个关键字，还开源中国有另外一个关键字：noinline（禁止内联），大家可能到这app小胖子里就摸不着头脑了，这个有啥用？我不在方法上面写 inline 不就是不会内联了么？那java培训么这个关键字是有什么作用呢？其实这个关键字不是修饰在方法上面的，开源矿工而是修饰 在 lappointmentambda 参数上面的，假设一个 inline 函数上面有多个 lambda 参数，那么我只想对某个java模拟器 lambda 参数内联，其他 lambda 参数不内联的情况下，就可以使用这个关键字来对不需要进行内联的 lambda 参数进行修饰，大体用法如下：
private inline fun showToast(function1: () -> Unit, noinline function2: () -> Unit, message: String) {
function1.invoke()
function2.invoke()
ToastUtils.show(message)
}
委托机制
类委托
- 先让我们来看一段代码
// 定义日志策略接口
interface ILogStrategy {
fun log(message: String)
}
// 实现一个默认的日志策略类
class LogStrategyImpl : ILogStrategy {
override fun log(message: String) {
Log.i("测试输出", message)
}
}
// 创建一个日志代理类
class LogStrategyProxy(strategy: ILogStrategy) : ILogStrategy by strategy
-
看到这里大家可能有一些疑惑
-
ILogjava面试题Strategyappointment by strategyjava培训是虾米操作？ -
LogStrategyProxy这个类不去实现接口方法难道不会导致编译不通过么？
-
-
关于这两个问题，我觉得都可以APP用同一个解释，LogStrategyProxy 之所以不用实现 ILogStrategy 的 lappointmentog 方法，是因为在
ILogStrategy接口后面加了by strategy，而strategy对象就是 LogStrategyProxy 构造函数中的变量，意思是让这个接口的具体实现由变量的指针其含义是指该变量的strategy对象帮我实现就可以了APP，我（LogStrategyProxy类）不需要再实现一遍了，这样是不是跟 Jajava怎么读va 中的静态代理很像？只不过在 Kotlin 类委托特性上面编译器帮我们自动生成接口方法的代码，你可以把它想象下面这样的代码java模拟器：
class LogStrategyProxy(val strategy: ILogStrategy) : ILogStrategy {
override fun log(message: String) {
strategy.log(message)
}
}
-
有人肯定会问了：口说无凭，我凭什么相信你就是这样的代码？
-
这是个好问题，我提供一下反编译之后的代码，大家看一下就能明白了：
public final class LogStrategyProxy implements ILogStrategy {
private final /* synthetic */ ILogStrategy $$delegate_0;
public LogStrategyProxy(@NotNull ILogStrategy strategy) {
Intrinsics.checkNotNullParameter(strategy, "strategy");
this.$$delegate_0 = strategy;
}
public void log(@NotNull String message) {
Intrinsics.checkNotNullParameter(message, "message");
this.$$delegate_0.log(message);
}
}
- 是不是就立马顿悟了？调用变量的定义的话也很简单，代码如下：
val logStrategyImpl = LogStrategyImpl()
LogStrategyProxy(logStrategyImpl).log("666666")
- 最后让我们看看输出的日志：
测试输出: 666666
- 这java环境变量配置个我突然有一个kotlin语言大胆的想法，在使用类委托appointment的情况下，再去重写它的接口方法呢？例如下面的：
class LogStrategyProxy(strategy: ILogStrategy) : ILogStrategy by strategy {
override fun log(message: String) {
println("测试输出 " + message)
}
}
- 关于这个问题我已经做过实践了，是开源矿工木有问题的，大家放心大胆搞。
属性委托
- 看过了上面的类委托，想必大家对委托有一定的了解了，那么属性委托是什么呢？简单来讲，类委托是为了帮我们减少一些实现代码，而属性委托是为了帮我们控制变量的 Get、Set 的操作了，废话不多说，下面演示一下用法，下面先创建一个委托类
class XxxDelegate {
// 先给它一个默认值
private var currentValue: String = "666666"
operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
println("测试字段名为 ${property.name} 的变量被访问了，当前值为 $currentValue")
return currentValue
}
operator fun setValue(thisRef: Any?, property: KProperty<*>, newValue: String) {
currentValue = newValue
println("测试字段名为 ${property.name} 的变量被赋值了，当前值为 $currentValue" + "，新的值 $newValue")
}
}
- 使用代码示例如下：
var temp: String by XxxDelegate()
println("测试输出 " + temp)
temp = "55555"
println("测试输出 " + temp)
- 具体日志输出如下：
System.out: 测试字段名为 temp 的变量被访问了，当前值为 666666
System.out: 测试输出 666666
System.out: 测试字段名为 temp 的变量被赋值了，当前值为 55555，新的值 55555
System.out: 测试字段名为 temp 的变量被访问了，当前值为 55555
System.out: 测试输出 55555
- 看到这里你是否明白了，这个
XxxDelegate类里面只有两个方法，一个是getValue，另外一个是setValue，从方法命名上我们已经能大致得出它的作用了，这里就不再多讲解了，var temp: String by XxxDelegate(开源节流)表示这个temp对象的创建会全权委托app小胖子给XxxDelegate这个类来做。
懒委托
- 什么是懒委托呢？大家开源阅读app下载安装知道单例模式中的懒汉式吧？这个跟它差不多，只不过我们不需要写静态方法和锁机制了，只需要像下面这样写：
val temp: String by lazy {
println("测试变量初始化了")
return@lazy "666666"
}
- 调用代码如下：
println("测试开始")
println("测试第一次输出 " + temp)
println("测试第二次输出 " + temp)
println("测试结束")
- 输出日志如下：
System.out: 测试开始
System.out: 测试变量初始化了
System.out: 测试第一次输出 666666
System.out: 测试第二次输出 666666
System.out: 测试结束
- 是不变量4是真的跟懒汉式差不多？只不过这种写法简化了很多，另外在日常开发中我们可以用它来做
findViewById是最适合不过的。
private val viewPager: ViewPager? by lazy { findViewById(R.id.vp_home_pager) }
-
另外懒委托还提供了几种懒加载模式供我们选择，
-
LazyTh开源软件readSafetyMode.SYNCHRONIZED：同步模式，确保只有单个线程可以初始化实例，这种模式下初始化时线程安全的，当
by lazy没有指定模式的时候，就是默认用的这种模式。 -
LazyThreadSafetyMode.PUBLICATkotlin和javaION：并发模式，在多线程下允许并发初始化，但是只有第一个返回的值作为实例，这种模式下是线程安全的，和
LazyThreadSafetyMode.SYNCHRONIZED最大区Java别是，这种模式在多线程并发访问下初始化效率是最高的，本质上面是用空间换时间，哪个的线程执行快就让哪个先返回结果，其他线程执行的结果抛弃掉。 -
LazyThreadSafetyMode.NONE：普通模式，这种模式不会使用锁来限制多线程访问java模拟器，所以是线程不安全的，所以请勿在多线程并发的情况下使用。
-
-
具体使用的方式也很简单，如下：
val temp: String by lazy(LazyThreadSafetyMode.NONE) {
println("测试变量初始化了")
return@lazy "666666"
}
- 另外有一点需要注意，使用懒委托的变量必须声明为kotlin下载 val（不可变的），因为它只能被赋值一次。
扩展函数
- 扩展函数是 KoKotlintlin 用于简化一些代码的书写产生的，其中有 let、with、rkotlin语言un、apply、also 五个函数
let 函数
-
在函数块内可以变量名的命名规则通过 it 指代该对象。返回值为函数块的最后一行或指定 return 表达式
-
一般写法
fun main() {
val text = "Android轮子哥"
println(text.length)
val result = 1000
println(result)
}
- let 写法
fun main() {
val result = "Android轮子哥".let {
println(it.length)
1000
}
println(result)
}
- 最常用的场景就是使用let函数处理需要针对一个可 null 的对象统一做判空处理
videoPlayer?.setVideoView(activity.course_video_view)
videoPlayer?.setControllerView(activity.course_video_controller_view)
videoPlayer?.setCurtainView(activity.course_video_curtain_view)
videoPlayer?.let {
it.setVideoView(activity.course_video_view)
it.setControllerView(activity.course_video_controller_view)
it.setCurtainView(activity.course_video_curtain_view)
}
- 又或者是需要去明确一个变量所处特定的作用域范围内可以使用
with 函数
-
前面的几个函数使用方式略有不同，因变量4为它开源节流什么意思不是以扩展java环境变量配置的形式存在的。它是将某对象作为函数的参数，在函数块变量与函数内可以通过 this 指代该对象，返回值为函数块的最后一行或指定 return 表达式
-
定义 Person 类
class Person(var name : String, var age : Int)
- 一般写法
fun main() {
var person = Person("Android轮子哥", 100)
println(person.name + person.age)
var result = 1000
println(result)
}
- with 写法
fun main() {
var result = with(Person("Android轮子哥", 100)) {
println(name + age)
1000
}
println(result)
}
- 适用于调用同一个类的多kotlin为什么流行不起来个方appointment法时，可以省去类名重复，直接调用类的方法即可，经常用于 Android 中
RecyclAPPerVijava面试题ew.onBinderViewHolder中，数据 model 的属性映射到 UI 上
override fun onBindViewHolder(holder: ViewHolder, position: Int){
val item = getItem(position)?: return
holder.nameView.text = "姓名：${item.name}"
holder.ageView.text = "年龄：${item.age}"
}
override fun onBindViewHolder(holder: ViewHolder, position: Int){
val item = getItem(position)?: return
with(item){
holder.nameView.text = "姓名：$name"
holder.ageView.text = "年龄：$age"
}
}
run 函数
-
实际上可以说是 let 和 with 两个变量英文函数的结合体，run 函数只接收一个 lambda 函数为参数，以闭包开源形式返回，返回值为最后一行的值或者指定的 return 的表达式
-
一般写法
var person = Person("Android轮子哥", 100)
println(person.name + "+" + person.age)
var result = 1000
println(result)
- run 写法
var person = Person("Android轮子哥", 100)
var result = person.run {
println("$name + $age")
1000
}
println(result)
- 适用于 let，with 函数任何场景。因为 run 函数是let，with两个函数结合体kotlin现在不火了，准确来说它弥补了 let 函数在函数体javascript百炼成仙内必须使用 it 参数替代对象，在 run 函数中可以像 with 函数一样可以省略，直接访问实例的公有属性和方法，另一方面它弥补了 with开源阅读app下载安装 函数传入对象判空问题，在 run 函数中可以像l et 函数一样做判空处理，这里变量4还是借助 onBindViewHolder 案例进行简化
override fun onBindViewHolder(holder: ViewHolder, position: Int){
val item = getItem(position)?: return
holder.nameView.text = "姓名：${item.name}"
holder.ageView.text = "年龄：${item.age}"
}
override fun onBindViewHolder(holder: ViewHolder, position: Int){
val item = getItem(position)?: return
item?.run {
holder.nameView.text = "姓名：$name"
holder.ageView.text = "年龄：$age"
}
}
apply 函数
-
从结构上来看 apply 函数和 run 函数很像，唯一不同点就是它们各自返回的值不一样，run 函数变量的定义是以闭包形式返回最后一行代码的值，而 apply 函数的返回的是传入对象的本身
-
一app小胖子般写法
val person = Person("Android轮子哥", 100)
person.name = "HJQ"
person.age = 50
- apply 写法Java
val person = Person("Android轮子哥", 100).apply {
name = "HJQ"
age = 50
}
- 整体作用功能和 run 函数很像，唯开源节流什么意思一不同点就是它返回的值是对象本身，而 ru开源软件n 函数是一个闭包形式返回，返回的是最后一行的值。正是基于这一点差异它的适用场景稍微与 run 函数有点不一样。apply 一般用于一个变量的定义对象实例初始化的时候，需要对对象中的属性进行赋值。或者动javaee态 inflat变量的定义e 出一个 XMappearL 的 View 的时候需要给 View 绑定数据也会用到，这种javascript情景非常常见。特别是在我变量的定义们开发中会有一application些数据 model 向 V变量4iew model 转化实例化的过程中需要用到
mRootView = View.inflate(activity, R.layout.example_view, null)
mRootView.tv_cancel.paint.isFakeBoldText = true
mRootView.tv_confirm.paint.isFakeBoldText = true
mRootView.seek_bar.max = 10
mRootView.seek_bar.progress = 0
- 使用 apply 函数后java面试题的代码是这样的
mRootView = View.inflate(activity, R.layout.example_view, null).apply {
tv_cancel.paint.isFakeBoldText = true
tv_confirm.paint.isFakeBoldText = true
seek_bar.max = 10
seek_bar.progress = 0
}
- 多层级判空问题
if (sectionMetaData == null || sectionMetaData.questionnaire == null || sectionMetaData.section == null) {
return;
}
if (sectionMetaData.questionnaire.userProject != null) {
renderAnalysis();
return;
}
if (sectionMetaData.section != null && !sectionMetaData.section.sectionArticles.isEmpty()) {
fetchQuestionData();
return;
}
- kotjavascriptlin 的 apply 函数优化
sectionMetaData?.apply {
// sectionMetaData 对象不为空的时候操作sectionMetaData
}?.questionnaire?.apply {
// questionnaire 对象不为空的时候操作questionnaire
}?.section?.apply {
// section 对象不为空的时候操作section
}?.sectionArticle?.apply {
// sectionArticle 对象不为空的时候操作sectionArticle
}
also 函数
- also 函数的结构实际上和 lappearet 很像唯一的区别就是返回值的不一样，let 是以闭包的形式返回，返回函数体内最后一行的值，如果最后一行为空就返回一个 Unit 类型的默认值。而 als开源众包o 函数返回的则是传入对象的本身
fun main() {
val result = "Android轮子哥".let {
println(it.length)
1000
}
println(result) // 打印：1000
}
fun main() {
val result = "Android轮子哥".also {
println(it.length)
}
println(result) // 打印：Android轮子哥
}
- 适用于 let 函数的任何场景，also 函数和 let 很像，只是唯一的不同点就是 let 函数最开源是什么意思后的返回值是最后一行的返回值而 also 函数的返回值是返回java环境变量配置当前的这个对象。一般可用于多个扩展函数链式调用
运算符重载
- 在 Kotlin 中使用运算符最终也会调用对appear象对应的方法，我们可以通过重写这些方法使得这个对象支持运算符，这开源阅读app下载安装里不再演示代码
| 运算符 | 调用方法 |
|---|---|
| +a | a.unaryPlus() |
| -aAPP | a.unaryMinus() |
| !a | a.not() |
| 运算符 | 调用方法 |
|---|---|
| a++ | a.inc() |
| a– | a.dec() |
| 运算符 | 调用方法 |
|---|---|
| a + b | a.plus(b) |
| a – b | a.minapple苹果官网us(b) |
| a * b | a.变量值times(b) |
| a / b | a.div(b) |
| a % b | a.rem(b), a开源中国.mod(b) (depr开源众包ecated) |
| a..b | a.rangeTo(b) |
| 运算符 | 调用方APP法 |
|---|---|
| a in b | b.contains(a) |
| a !in b | !b.contains(a) |
| 运算符 | 调用方法 |
|---|---|
| a[i] | a.getJava(i) |
| a[i, j] | a.get(i, j) |
| a[i_1, …, i_n] | a.get(i_1, …, i_njava模拟器) |
| 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) |
| 运算符 | 调用方法 |
|---|---|
| a() | a.invoke开源中国() |
| a(i) | a.inv开源阅读oke(i) |
| a(i, j) | a.invoke(i, j) |
| a(i_1, …, i_n) | a.invoke(i_1java编译器, .javascript百炼成仙.., i_n) |
| 运算符 | 调用方法 |
|---|---|
| a +=javascript b | a.pluskotlin现在不火了Assign(b) |
| a -= b | a.minusAssign(b) |
| a *= b | a.timesAssign(b) |
| a /= b | a.divAssign(b) |
| a %= b | a.remAssign(b), a.modAssign(b) (deprecated) |
| 运算符 | 调用方法 |
|---|---|
| a == b | a?.equalsjava模拟器(b) ?: (b === null) |
| a != b | !(a?.equals(b) ?: (b === null)) |
| 运算符 | 调用方法 |
|---|---|
| a > b | a.compareTo(b) > 0 |
| a < b | a.compareTo(b) < 0 |
| a >= b | a.compareTo(b) >= 0 |
| a <= b | a.compareTo(b) &lkotlin下载t;= 0 |
