Kotlin有点意思之常用操作符及扩展函数

目录

导读

kotlin.png

kotlin确实很简洁,但是在使用kotlin一段时间后,你会发现自己还是不能写出足够漂亮的代码 icon_arrow.png ,所以还是要继续深入。

当然,你将会发现越来越有意思,相较于java,代码量也显著下降。

来吧继续学习!

推荐阅读:Kotlin入门 - 为什么使用Kotlin

? 操作符

表示这个对象可能为空

//在变量类型后面加上问号,代表该变量是可空变量  
var name: String? = "zhangsan"
/**
 * 如果str不能转为Int类型,则返回null
 */
fun parseInt(str: String): Int? { 
  // (代码略)
}
b?.length //如果 b非空,就返回 b.length ,否则返回 null,这个表达式的类型是 Int? 。

?: 操作符

如果值非空,我使用它;否则使用某个非空的值 x

val l: Int = if (b != null) b.length else -1

除了完整的 if-表达式,还可以通过 Elvis 操作符表达:

val l = b?.length ?: -1

如果 ?: 左侧表达式非空,elvis操作符就返回其左侧表达式,否则返回右侧表达式。请注意,当且仅当左侧为空时,才会对右侧表达式求值。

== 与 ===

==判断值是否相等,===判断值及引用是否完全相等。

val num: Int = 128
val a:Int? = num
val b:Int? = num
println(a == b)
print(a === b)

.. 符号以及 in 和 !in 操作符

..代表从x到y,包括x和y,这是一个闭区间运算符,而until则是半闭区间运算符,代表从a到b范围内所有的值,包括a和不包括b。
in代表在一个区间中,!in代表不在一个区间中。

使用in运算符来检查某个数字是否在指定区间内。

if (i in 1..10) { // 等价于 1 <= i && i <= 10
    println(i)
}
if (i in 10..1) {
    println(i)//什么都不会打印
}
//使用until函数,创建一个不包括其结束元素的区间
for (i in 1 until 10) {   // i in [1, 10) 排除了 10
     println(i)
}

downTo() 函数

倒叙遍历,区间内循环:

for (i in 4 downTo 1){
    print(i) //倒叙遍历
}   
// print "4321"

step() 函数

可以进行任意数量的迭代,而不是每次变化都是1:

for(i in 1..4 step 2) {
  print(i) //print "13"
}
for(i in 4 downTo 1 step 2) {
  print(i) //print "42"
}

:: 符号

得到类的Class对象

startActivity(Intent(this@KotlinActivity, MainActivity::class.java))

@ 符号

限定 this 的类型

class User {
    inner class State{
        fun getUser(): User{
            //返回User
            return this@User
        }
        fun getState(): State{
            //返回State
            return this@State
        }
    }
}

作为标签

跳出双层for

val a = arrayOf(0,1,2)
val b = arrayOf(1,2,5)
loop@ for (itemA in a) {
  var i = 0
  for (itemB in b) {
    i++
    if (itemB > 2) {
      break@loop
    }
    println("itemB:$itemB")
  }
}

print:

itemB:1
itemB:2

命名函数自动定义标签

fun fun_run(){
    run {
        println("lambda")
    }
    var i: Int = run {
        return@run 1
    }
    println("$i")
    //匿名函数可以通过自定义标签进行跳转和返回
    i = run (outer@{
        return@outer 2
    })
    println(i)
}

print:

lambda
1
2

从forEach函数跳出

fun forEach_label(){
  run breaking@{
    (0..20).forEach forEach@{
      println(it)
      if (it >= 5) {
        println("it >= 5")
        return@forEach
      } //相当于在forEach函数中continue,实际上是从匿名函数返回
      println("it < 5")
      if (it >= 10) {
        println("it >= 10")
        return@breaking
      } //相当于在forEach函数中使用break,实际上是跳转到outer之外
    }
  }
}

print:

0
it < 2
1
it < 2
2
it >= 2
3
it >= 2
4
it >= 2
5
it >= 2
6
it >= 2
7
it >= 2
8
it >= 2
9
it >= 2
10
it >= 2
fun forEach_label(){
  run breaking@{
    (0..10).forEach forEach@{
      println(it)
      //if (it >= 2) {
      //  println("it >= 2")
      //  return@forEach
      //} //相当于在forEach函数中continue,实际上是从匿名函数返回
      //println("it < 2")
      if (it >= 5) {
        println("it >= 5")
        return@breaking
      } //相当于在forEach函数中使用break,实际上是跳转到outer之外
    }
  }
}

print:

0
1
2
3
4
5
it >= 5

as? 操作符

当使用 as 转型的时候,可能会经常出现 ClassCastException。 所以,现在可以使as?安全转型,当转型不成功的时候,它会返回null。

注:在使用intent传值的时候,会出现空字符串不能用as强制转型,这是应该使用as?

val m: Int? = a as? Int

冒号 :

  1. 类型和超类型之间的冒号前要有一个空格
  2. 实例和类型之间的冒号前不要空格
//定义全局变量时
var str: String? = null
//类的继承与变量定义
class TestActivity<T : Serializable>(str: String) : Activity{}

类型判断符 is

检查某个实例是否是某个类型,如果判断出属于某个类型,那么判断后的分支中可以直接可当该类型使用,无需显示转换

fun getStringLength(obj: Any): Int? {
  //obj在&&右边自动动转换成"String"类型
  if (obj is String && obj.length > 0){
      return obj.length
  }
  return null
}

多行输入符 """

三引号的形式用来输入多行文本,也就是说在三引号之间输入的内容将被原样保留,之中的单号和双引号不用转义,其中的不可见字符比如/n和/t都会被保留。

val str = """ 
one
two
"""
//等价于          
val str = "one\ntwo"       
val str =  "one" +"\n"+"two"

$ 操作符

字符串可以包含模板表达式,及一小段代码,会求值并把结果包含到字符串中。模板字符串以美元符号$开头,由一个简单的名字构成:

val value = 5
val str = "the value is $value"
//字符串模板
var userInfo = "name:${user.name},  age:$age"

或花括号括起来的任意表达式

val g = 2
val h = 3
val str = "g+h=${g+h}"

转义字符串和原生字符串都支持模板字符串。如果想要在原生字符串中使用$(它不支持反斜杠转义),可以使用以下语法:

val str:String="""the price is ${'$'}199"""

扩展函数

run

调用函数块,块内this指代调用对象,返回值为最后一行。

val result = "hello".run{
    println(this) //this为hello
    "I'm result"
}
println(result)

print:

hello
I'm result

apply

run,函数块内this指代该对象,返回值为对象自己。

data class Account(
    var username: String? = null,
    var password: String? = null
)
val account = Account().apply {
  this.username = "ZhangSan"
  this.password = "aaa"
}
println(account)

print:

Account(username=ZhangSan, password=aaa)

let

函数块内it指代该对象。

返回值最后一行,如果最后一行为空则返回一个Unit类型的默认值。

object.let{
  it.todo()//在函数体内使用it替代object对象去访问其公有的属性和方法
  ...
}
val account2 = Account().let {
  it.username = "LiSi"
  it.password = "bbb"
  it.toString()
}

print:

Account(username=LiSi, password=bbb)

also

also函数的结构实际上和let很像唯一的区别就是返回值的不一样,let是以闭包的形式返回,返回函数体内最后一行的值,如果最后一行为空就返回一个Unit类型的默认值。而also函数返回的则是传入对象的本身。

val account3 = Account().also {
  it.username = "WangWu"
  it.password = "ccc"
}

print:

Account(username=WangWu, password=ccc)

with

将该对象作为函数参数,this 指代该对象,返回值为最后一行。

with函数和前面的几个函数使用方式略有不同,因为它不是以扩展的形式存在的。它是将某对象作为函数的参数,在函数块内可以通过this指代该对象。返回值为函数块的最后一行或指定return表达式。

val account4 = with(Account()){
  this.username = "ZhaoLiu"
  this.password = "ddd"
  println("my name is $username, my password is $password")
  100
}

print:

my name is ZhaoLiu, my password is ddd
100

修饰符

  1. private 只能被自己所在的文件可见,不能在定义这个类之外的文件中使用

  2. protected 可以被成员自己和继承它的成员可见(比如,类和它的子类)

  3. internal 对所在的整个module可见

  4. public 最没有限制的修饰符。这是默认的修饰符

标签: kotlin

声明:本博客如无特殊说明皆为原创,转载请注明来源:Kotlin有点意思之常用操作符及扩展函数谢谢!

相关文章

精彩评论
  1. 这么多文字,,不来个简单介绍吗。
    这是精简语言还是新语言? icon_biggrin.png

    1. 新语言哦,与Java互通,很多Java没有的特性,主要是写起来简洁,Java实现某些功能还是过于臃肿。
      介绍看一看:https://notemi.cn/introduction-to-kotlin---why-use-kotlin.html

发表评论:

icon_question.pngicon_razz.pngicon_sad.pngicon_evil.pngicon_exclaim.pngicon_smile.pngicon_redface.pngicon_biggrin.pngicon_surprised.pngicon_eek.pngicon_confused.pngicon_cool.pngicon_lol.pngicon_mad.pngicon_twisted.pngicon_rolleyes.pngicon_wink.pngicon_idea.pngicon_arrow.pngicon_neutral.pngicon_cry.pngicon_mrgreen.png