Kotlin那些与Java不一样的写法

一、构造器

//一个User类
class User {
}

//添加参数的主构造器
class User(name: String) {
}

//加val、var 声明为类的属性
class User(val name: String) {
}

//init代码块可以添加初始化逻辑
class User(val name: String) {
    init {
       ...
    }
}
//次构造器
class User(val name: String) {
    init {
        ...
    }
    constructor(person: Person) : this(person.name) {
    }
}

class User {
    var name: String
    constructor(name: String) {
        this.name = name
    }
}
//或者
class User constructor(name: String) {
    var name: String = name
}
//constructor关键字可以省略
class User(name: String) {
    var name: String = name
}
//等价于
class User(var name: String) {
     
}

//使用「可见性修饰符」或者「注解」时constructor关键字不能省略
class User private constructor(name: String) {
    //主构造器被修饰为私有的，外部就无法调用该构造器
}

二、函数

使用 = 连接返回值

//有返回值
fun area(width: Int, height: Int): Int {
    return width * height
}

fun area(width: Int, height: Int): Int = width * height

//无返回值
fun test(name: String) {
    println("Hi " + name)
}

fun test(name) = println("test " + name)

参数默认值

fun test(name: String = "world") = println("hello " + name)
//测试
test("kotlin")

test()
//可以通过指定参数名，来区分多个默认参数
test(name = "Test")

嵌套函数

        在函数中声明一个函数，将该函数作为一个单独的函数，并且不对外暴露；

        在嵌套函数里面可以访问它外部函数的所有变量或常量，例如类中的属性、当前函数中的参数与变量等。

三、字符串

字符串拼接模板：用$变量  ${表达式}

原生字符串：使用""" 包裹原生字符串 """

四、数组和集合

1.声明

//数组
val intArray = intArrayOf(1, 2, 3)
//列表
val strList = listOf("a", "b", "c")

2.forEach 遍历

intArray.forEach { i ->
    print(i + " ")
}

3.filter 过滤，满足条件的元素生成新的集合

val newList: List = intArray.filter { i ->
    i != 1 //过滤掉数组中等于1的元素
}

4.map 转换，遍历每个元素并执行给定表达式，形成新的集合

val newList: List = intArray.map { i ->
    i + 1 //每个元素加1
}

5.flatMap 遍历每个元素，并为每个元素创建新的集合，最后合并

intArray.flatMap { i ->
    listOf("${i + 1}", "a") // 生成新集合
}

6.Range 区间范围

val range: IntRange = 0..1000       //[0,1000]
val range: IntRange = 0 until 10000 // [0,1000)

for (i in range) {
    print("$i, ")
}
//for (i in range step 2) 可以设置步长

for (i in 1000 downTo 1) { //[1000, 1]
    print("$i, ")
}

7.Sequence 惰性集合操作 代码不会立即执行，只是定义了一个执行流程，当被使用到的时候才会执行，惰性指当出现满足条件的第一个元素的时候，Sequence 就不会执行后面的元素遍历了

好处：在数据量比较大或者数据量未知的时候，作为流式处理的解决方案

五、条件控制

if/else 

弃用java的三元运算符，分支中可以是一个变量，也可以是一个代码块，代码块的最后一行会作为结果返回

when

来替代java中的switch

when (x) {
    1 -> { println("1") }
    2 -> { println("2") }
    3,4 -> { println("3 or 4") }//多种情况执行同一份代码时，可以将多个分支条件放在一起，用 , 隔开，表示这些情况都会执行后面的代码：
    in 5..8 { println("x 在 5..8 中") }
    in listOf(9,10) -> println("x 在集合中")
    !in 11..20  -> println(x 不在区间11..20中)
    is String -> println("是特定类型String“)
    else -> { println("不在任何上") }
}

for

for (i in 0..10) {
    println(i)
}

try-catch

Kotlin 中的异常在编译时期是不会被检查的，只有在运行时抛出异常，才会出错

?. 和 ?:

空安全

val str: String? = "Hello"
val length: Int = str?.length ?: -1

?.  在对象非空时会执行后面的调用，对象为空时就会返回 null,

?:  如果左侧表达式 str?.length 结果为空，则返回右侧的值 -1。

== 和 ===

== ：可以对基本数据类型以及 String 类型进行内容比较，相当于 Java 中的 equals

=== ：对引用的内存地址进行比较，相当于 Java 中的 ==