Kotlin语法简单入门

Author：优雅的猫先生
发布时间：April 29, 2023
649views
No comments
13217字数
Categories：其他

在线运行Kotlin

变量

fun main() {
    println("Hello, world!!!")
    //val声明常量
    val a = 10
    //var声明变量
    var b = 20
    println(a+b)
    //显示定义变量类型
    var c:Int = 50
    println(c)
}

Hello, world!!!
30
50

函数

fun main() {
    myfunc("zhangsan")
    println(getMax(10,20))
    println(getMax2(20,30))
    println(getMax3(10,40))
}

fun myfunc(name:String){
    println("hello "+name)
}

fun getMax(a:Int,b:Int):Int{
    // if 可以带返回值
   val result = if (a>b){
       a
   }else{
       b
   }

   return result
}

fun getMax2(a:Int,b:Int):Int{
    // if 简化写法
   return if (a>b) a else b
}

// 更加简化
fun getMax3(a:Int,b:Int)=if (a>b) a else b

hello zhangsan
20
30
40

流程控制

if语句

参考上文

when条件语句

fun main() {
    println(getScore("Tom"))
    println(getScore("jack"))
    println("==============")
    println(getScore2("Tom11"))
    println(getScore2("Tom22"))
    println(getScore2("jack"))
    println("==============")
    checkNum(90)
    checkNum(90L)
}


fun getScore(name:String):Int{
   return when(name){
       "Tom"->86
       "Jim"->65
       "kaven"->99
       else->60
   }
}
fun checkNum(num:Number){
    when(num){
        is Int -> println("number is Int")
        is Double -> println("number is Int")
        else -> println("number is unknow")
    }
}

fun getScore2(name:String):Int{
   return when{
       name.startsWith("Tom")->88
       name=="Jim"->80
       name=="kaven"->99
       else-> 60
   }
}

86
60
==============
88
88
60
==============
number is Int
number is unknow

循环语句

fun main() {
    // ..代表的是闭区间 index为[0,10]
    var index = 0..10
    for(i in index){
        println(i)
    }
    println("============")
    // until代表左闭右开 index为[0,10)
    index = 0 until 10
    for(i in index){
        println(i)
    }
    println("============")
    // 循环，步长为2
    println("循环，步长为2")
    for(i in 0 until 10 step 2){
        println(i)
    }
    println("============")
    // 降序循环
    println("降序循环")
    for(i in 10 downTo 1){
        println(i)
    }
    println("============")
    println("降序循环,步长为2")
    for(i in 10 downTo 1 step 2){
         println(i)
    }
    println("============")
}

0
1
2
3
4
5
6
7
8
9
10
============
0
1
2
3
4
5
6
7
8
9
============
循环，步长为2
0
2
4
6
8
============
降序循环
10
9
8
7
6
5
4
3
2
1
============
降序循环,步长为2
10
8
6
4
2
============

面向对象

类

fun main() {
    val p= Person()
    p.name="jack"
    p.age=18
    p.sayHello()
}

class Person{
    var name=""
    var age=0
    fun sayHello(){
        println("hello,I am "+ name+",I am "+ age+" years old.")
    }
}

hello,I am jack,I am 18 years old.

继承与构造函数

fun main() {
    val p= Person()
    p.name="jack"
    p.age=18
    p.sayHello()
    println("=================")
    var s1= Student()
    s1.sno="123"
    s1.grade=3
    s1.study()
    println("=================")
    var s2= Student1("456",2)
}

open class Person{
    var name=""
    var age=0
    fun sayHello(){
        println("hello,I am "+ name+",I am "+ age+" years old.")
    }
}

// Student继承Person
class Student:Person(){
    var sno=""
    var grade = 0
    fun study(){
        println("hello,my sno is"+ sno+",grade is "+ grade+".")
    }
}

//Student继承Person 主构造函数 带参数
class Student1(val sno:String,val grade:Int):Person(){
    //初始化的时候会执行init代码块 相当于构造方法
    init{
        println("Student1 sno:"+sno+" grade:"+grade)
    }
}

hello,I am jack,I am 18 years old.
=================
hello,my sno is123,grade is 3.
=================
Student1 sno:456 grade:2

继承时为什么要加上()?

子类继承父类的时候，需要调用父类的构造方法，在java中是子类的构造方法调用super()，kotlin也是需要子类初始化时调用父类的构造方法，可以在init代码块中调用，不过最好的处理办法是直接在继承的时候给父类加上(),表示调用父类无参的构造方法.

父类的构造函数带参数

fun main() {
       var s3=Student2("789",6,"zhangsan",18)
}

open class Person(val name:String,val age:Int){
    fun sayHello(){
        println("hello,I am "+ name+",I am "+ age+" years old.")
    }
}

class Student2(val sno:String,val grade:Int,name:String,age:Int):Person(name,age){
    //初始化的时候会执行init代码块 相当于构造方法
    init{
        println("Student1 name:"+name+" age:"+age+" sno:"+sno+" grade:"+grade)
    }
}

Student1 name:zhangsan age:18 sno:789 grade:6

需要注意的是name和age不能使用val声明,有val声明的变量会自动成为该类的成员

次构造函数

次构造函数也有点像是java中某个类具有多个构造方法的味道,只不过kotlin多个构造函数区分了主次,要求次构造函数必须调用主构造函数

fun main() {
    //带有主构造函数的类
    val s1 = Student()
    println("===============")
    val s2 = Student("zhangsan")
    println("===============")
    val s3 = Student("zhangsan",18)
    println("===============")
    val s4 = Student("113",5,"wangwu",23)
    //类缺少主构造函数
    val s5 = Student2()
    println("===============")
    val s6 = Student2("jack li")
    println("===============")
    val s7 = Student2("jack ma",32) 
}

open class Person(val name:String,val age:Int){
    fun sayHello(){
        println("hello,I am "+ name+",I am "+ age+" years old.")
    }
}

class Student(val sno:String,val grade:Int,name:String,age:Int):Person(name,age){
    //次构造函数
    constructor(name:String,age:Int):this("",0,name,age){
        println("Student name:String,age:Int次构造函数被执行了")
    }
    constructor(name:String):this("",0,name,-1){
        println("Student name:String次构造函数被执行了")
    }
    constructor():this("",0,"defaultName",-1){
        println("Student 无参数,次构造函数被执行了")
    }
    init{
        println("Student name:"+name+" age:"+age+" sno:"+sno+" grade:"+grade)
    }
}

//Student2没有主构造函数
class Student2:Person{
    //次构造函数
    constructor(name:String,age:Int):super(name,age){
        println("Student2 name:String,age:Int次构造函数被执行了")
    }
    constructor(name:String):super(name,-1){
        println("Student2 name:String次构造函数被执行了")
    }
    constructor():super("defaultName",-1){
        println("Student2 无参数,次构造函数被执行了")
    }
    init{
        println("Student2 name:"+name+" age:"+age)
    }
}

Student name:defaultName age:-1 sno: grade:0
Student 无参数,次构造函数被执行了
===============
Student name:zhangsan age:-1 sno: grade:0
Student name:String次构造函数被执行了
===============
Student name:zhangsan age:18 sno: grade:0
Student name:String,age:Int次构造函数被执行了
===============
Student name:wangwu age:23 sno:113 grade:5
Student2 name:defaultName age:-1
Student2 无参数,次构造函数被执行了
===============
Student2 name:jack li age:-1
Student2 name:String次构造函数被执行了
===============
Student2 name:jack ma age:32
Student2 name:String,age:Int次构造函数被执行了

如果类没有主构造函数,但是继承类的构造函数又必须带参,那么可以用次构造函数去调用父类带参的构造函数

接口

fun main() {
    val s1 = Student("zhangsan",18)
    s1.study()
    println("==多态调用===")
    // 多态调用
    toLearn(s1)
}

open class Person(val name:String,val age:Int){
    fun sayHello(){
        println("hello,I am "+ name+",I am "+ age+" years old.")
    }
}

class Student(val sno:String,val grade:Int,name:String,age:Int):Person(name,age),Study{
    override fun study(){
        println(name+" is studing")
    }
//     override fun readBooks(){
//         println(name+" is reading")
//     }
    //次构造函数
    constructor(name:String,age:Int):this("",0,name,age){
        println("Student name:String,age:Int次构造函数被执行了")
    }
    constructor(name:String):this("",0,name,-1){
        println("Student name:String次构造函数被执行了")
    }
    constructor():this("",0,"defaultName",-1){
        println("Student 无参数,次构造函数被执行了")
    }
    init{
        println("Student name:"+name+" age:"+age+" sno:"+sno+" grade:"+grade)
    }
}

interface Study{
    fun study()
    // 接口方法的默认实现
    fun readBooks(){
        println("default is reading books.")
    }
}

fun toLearn(stu:Study){
    stu.study()
    stu.readBooks()
}

Student name:zhangsan age:18 sno: grade:0
Student name:String,age:Int次构造函数被执行了
zhangsan is studing
==多态调用===
zhangsan is studing
default is reading books.

数据类和单例

数据类

fun main() {
    val c1 = CellPhone("Apple",118)
    val c2 = CellPhone("Apple",118)
    println(c1)
    println("c1==c2?"+(c1==c2))
}

//data表明CellPhone类是数据类.没有代码可以省略{}不写
data class CellPhone(val brank:String,val price:Int)

CellPhone(brank=Apple, price=118)
c1==c2?true

单例

fun main() {
    Singleton.singletonTest()
}

//声明单例类,使用object关键字
object Singleton{
    fun singletonTest(){
        println("singletonTest is called.")
    }
}

singletonTest is called.

单例类声明使用关键字object

全局只会有一个Singleton类

集合

List

fun main() {
    //声明list
    println("声明list")
    val list1= ArrayList<String>()
    list1.add("a")
    list1.add("b")
    list1.add("c")
    for(i in list1){
        println(i)
    }
    println("=========")
    //另一种方式
    println("另一种方式声明list,该list为不可变list")
    //listOf声明的是不可变的list,即不可以调用add或delete方法增加删除元素.
    val list2=listOf("a","b","c")
    for(i in list2){
        println(i)
    }
    println("=========")
    println("另一种方式声明list,该list为可变list")
    val list3=mutableListOf("a","b","c")
    list3.add("d")
    for(i in list3){
        println(i)
    }
}

声明list
a
b
c
=========
另一种方式声明list,该list为不可变list
a
b
c
=========
另一种方式声明list,该list为可变list
a
b
c
d

Set

fun main() {
    //setOf声明的是不可变的set,即不可以调用add或delete方法增加删除元素.
    println("声明set,该set为不可变set")
    val set1=setOf("a","b","c")
    for(i in set1){
        println(i)
    }
    println("=========")
    println("另一种方式声明set,该set为可变set")
    val set2=mutableSetOf("a","b","c")
    set2.add("d")
    for(i in set2){
        println(i)
    }
}

声明set,该set为不可变set
a
b
c
=========
另一种方式声明set,该set为可变set
a
b
c
d

Map

fun main() {
    println("map的声明和使用")
    val map = HashMap<String,Int>()
    map.put("zhangsan",1)
    map.put("lisi",2)
    map.put("wangwu",3)
    //更推荐使用这种方式修改以及赋值
    map["jack"]=4
    map["tony"]=5
    for((name,age) in map){
        println(name+" "+age)
    }
    //取值
    println("jack's age is "+map["jack"])
    println("===================")
    //另一种map的声明方式
    println("另一种map的声明方式")
    val map2 = mapOf("a" to 1,"b" to 2,"c" to 3)
    for((name,age) in map2){
        println(name+" "+age)
    }
}

map的声明和使用
tony 5
lisi 2
zhangsan 1
wangwu 3
jack 4
jack's age is 4
===================
另一种map的声明方式
a 1
b 2
c 3

集合的函数式API

Lambda表达式

fun main() {
    val fruits = listOf("Apple","Orange","Banana","Pear","Watermelon","Lemon")
    //获取最长的水果名
    var maxFruit = fruits.maxBy{it.length}
    println(maxFruit)
    println("=======")
    //lambda表达式 {参数1:参数类型,参数2:参数类型->函数体}
    //完全不简化的代码
    println("完全不简化的代码")
    val lambda = {name:String->name.length}
    maxFruit=fruits.maxBy(lambda)
    println(maxFruit)
    //简化步骤1.去掉lambda变量
    println("========")
    println("简化步骤1.去掉lambda变量")
    maxFruit=fruits.maxBy({name:String->name.length})
    println(maxFruit)
    println("========")
    println("简化步骤2. 当lambda表达式为函数的最后一个参数时候,可以写到括号外面")
    maxFruit=fruits.maxBy(){name:String->name.length}
    println(maxFruit)
    println("========")
    println("简化步骤3. 如果lambda表达式是函数的唯一一个参数,可以省略小括号")
    maxFruit=fruits.maxBy{name:String->name.length}
    println(maxFruit)
    println("========")
    println("简化步骤4. kotlin可以自动推导变量类型,可以省略变量类型定义")
    maxFruit=fruits.maxBy{name->name.length}
    println(maxFruit)
    println("========")
    println("简化步骤5. lambda表达式只有一个参数时,不必声明变量名,可以使用it关键字")
    maxFruit=fruits.maxBy{it.length}
    println(maxFruit)
}

Watermelon
=======
完全不简化的代码
Watermelon
========
简化步骤1.去掉lambda变量
Watermelon
========
简化步骤2. 当lambda表达式为函数的最后一个参数时候,可以写到括号外面
Watermelon
========
简化步骤3. 如果lambda表达式是函数的唯一一个参数,可以省略小括号
Watermelon
========
简化步骤4. kotlin可以自动推导变量类型,可以省略变量类型定义
Watermelon
========
简化步骤5. lambda表达式只有一个参数时,不必声明变量名,可以使用it关键字
Watermelon

map()、filter()、all()、any()

fun main() {
    val fruits = listOf("Apple","Orange","Banana","Pear","Watermelon","Lemon")
    println("map函数,映射")
    val upperFruits = fruits.map{it.toUpperCase()}
    for (i in upperFruits) println(i)
    println("=====")
    println("filter函数,过滤")
    val lowerFruit= fruits.filter{it.length>5}.map{it.toLowerCase()}
    for (i in lowerFruit) println(i)
    println("=====")
    println("all函数,集合内所有元素均符合条件则返回true,否则为false")
    val res1 = fruits.all{it.length>5}
    println(res1)
    println("=====")
    println("any函数,集合内任意元素符合条件则返回true,否则为false")
    val res2 = fruits.any{it.length>8}
    println(res2)
}

map函数,映射
APPLE
ORANGE
BANANA
PEAR
WATERMELON
LEMON
=====
filter函数,过滤
orange
banana
watermelon
=====
all函数,集合内所有元素均符合条件则返回true,否则为false
false
=====
any函数,集合内任意元素符合条件则返回true,否则为false
true

版权属于：本文为原创文章，版权归猫先生所有
本文链接：https://loli.rip/index.php/archives/620/
转载时须注明出处及本声明

Last modification：May 15th, 2023 at 12:59 am

如果觉得我的文章对你有用，请随意赞赏

Kotlin语法简单入门

优雅的猫先生 • 2023 年 04 月 29 日

在线运行Kotlin

Jetbrain在线运行Kotlin

变量

fun main() {
    println("Hello, world!!!")
    //val声明常量
    val a = 10
    //var声明变量
    var b = 20
    println(a+b)
    //显示定义变量类型
    var c:Int = 50
    println(c)
}

Hello, world!!!
30
50

函数

fun main() {
    myfunc("zhangsan")
    println(getMax(10,20))
    println(getMax2(20,30))
    println(getMax3(10,40))
}

fun myfunc(name:String){
    println("hello "+name)
}

fun getMax(a:Int,b:Int):Int{
    // if 可以带返回值
   val result = if (a>b){
       a
   }else{
       b
   }

   return result
}

fun getMax2(a:Int,b:Int):Int{
    // if 简化写法
   return if (a>b) a else b
}

// 更加简化
fun getMax3(a:Int,b:Int)=if (a>b) a else b

hello zhangsan
20
30
40

流程控制

if语句

参考上文

when条件语句

fun main() {
    println(getScore("Tom"))
    println(getScore("jack"))
    println("==============")
    println(getScore2("Tom11"))
    println(getScore2("Tom22"))
    println(getScore2("jack"))
    println("==============")
    checkNum(90)
    checkNum(90L)
}


fun getScore(name:String):Int{
   return when(name){
       "Tom"->86
       "Jim"->65
       "kaven"->99
       else->60
   }
}
fun checkNum(num:Number){
    when(num){
        is Int -> println("number is Int")
        is Double -> println("number is Int")
        else -> println("number is unknow")
    }
}

fun getScore2(name:String):Int{
   return when{
       name.startsWith("Tom")->88
       name=="Jim"->80
       name=="kaven"->99
       else-> 60
   }
}

86
60
==============
88
88
60
==============
number is Int
number is unknow

循环语句

fun main() {
    // ..代表的是闭区间 index为[0,10]
    var index = 0..10
    for(i in index){
        println(i)
    }
    println("============")
    // until代表左闭右开 index为[0,10)
    index = 0 until 10
    for(i in index){
        println(i)
    }
    println("============")
    // 循环，步长为2
    println("循环，步长为2")
    for(i in 0 until 10 step 2){
        println(i)
    }
    println("============")
    // 降序循环
    println("降序循环")
    for(i in 10 downTo 1){
        println(i)
    }
    println("============")
    println("降序循环,步长为2")
    for(i in 10 downTo 1 step 2){
         println(i)
    }
    println("============")
}

0
1
2
3
4
5
6
7
8
9
10
============
0
1
2
3
4
5
6
7
8
9
============
循环，步长为2
0
2
4
6
8
============
降序循环
10
9
8
7
6
5
4
3
2
1
============
降序循环,步长为2
10
8
6
4
2
============

面向对象

类

fun main() {
    val p= Person()
    p.name="jack"
    p.age=18
    p.sayHello()
}

class Person{
    var name=""
    var age=0
    fun sayHello(){
        println("hello,I am "+ name+",I am "+ age+" years old.")
    }
}

hello,I am jack,I am 18 years old.

继承与构造函数

fun main() {
    val p= Person()
    p.name="jack"
    p.age=18
    p.sayHello()
    println("=================")
    var s1= Student()
    s1.sno="123"
    s1.grade=3
    s1.study()
    println("=================")
    var s2= Student1("456",2)
}

open class Person{
    var name=""
    var age=0
    fun sayHello(){
        println("hello,I am "+ name+",I am "+ age+" years old.")
    }
}

// Student继承Person
class Student:Person(){
    var sno=""
    var grade = 0
    fun study(){
        println("hello,my sno is"+ sno+",grade is "+ grade+".")
    }
}

//Student继承Person 主构造函数 带参数
class Student1(val sno:String,val grade:Int):Person(){
    //初始化的时候会执行init代码块 相当于构造方法
    init{
        println("Student1 sno:"+sno+" grade:"+grade)
    }
}

hello,I am jack,I am 18 years old.
=================
hello,my sno is123,grade is 3.
=================
Student1 sno:456 grade:2

继承时为什么要加上()?

父类的构造函数带参数

fun main() {
       var s3=Student2("789",6,"zhangsan",18)
}

open class Person(val name:String,val age:Int){
    fun sayHello(){
        println("hello,I am "+ name+",I am "+ age+" years old.")
    }
}

class Student2(val sno:String,val grade:Int,name:String,age:Int):Person(name,age){
    //初始化的时候会执行init代码块 相当于构造方法
    init{
        println("Student1 name:"+name+" age:"+age+" sno:"+sno+" grade:"+grade)
    }
}

Student1 name:zhangsan age:18 sno:789 grade:6

需要注意的是name和age不能使用val声明,有val声明的变量会自动成为该类的成员

次构造函数

次构造函数也有点像是java中某个类具有多个构造方法的味道,只不过kotlin多个构造函数区分了主次,要求次构造函数必须调用主构造函数

fun main() {
    //带有主构造函数的类
    val s1 = Student()
    println("===============")
    val s2 = Student("zhangsan")
    println("===============")
    val s3 = Student("zhangsan",18)
    println("===============")
    val s4 = Student("113",5,"wangwu",23)
    //类缺少主构造函数
    val s5 = Student2()
    println("===============")
    val s6 = Student2("jack li")
    println("===============")
    val s7 = Student2("jack ma",32) 
}

open class Person(val name:String,val age:Int){
    fun sayHello(){
        println("hello,I am "+ name+",I am "+ age+" years old.")
    }
}

class Student(val sno:String,val grade:Int,name:String,age:Int):Person(name,age){
    //次构造函数
    constructor(name:String,age:Int):this("",0,name,age){
        println("Student name:String,age:Int次构造函数被执行了")
    }
    constructor(name:String):this("",0,name,-1){
        println("Student name:String次构造函数被执行了")
    }
    constructor():this("",0,"defaultName",-1){
        println("Student 无参数,次构造函数被执行了")
    }
    init{
        println("Student name:"+name+" age:"+age+" sno:"+sno+" grade:"+grade)
    }
}

//Student2没有主构造函数
class Student2:Person{
    //次构造函数
    constructor(name:String,age:Int):super(name,age){
        println("Student2 name:String,age:Int次构造函数被执行了")
    }
    constructor(name:String):super(name,-1){
        println("Student2 name:String次构造函数被执行了")
    }
    constructor():super("defaultName",-1){
        println("Student2 无参数,次构造函数被执行了")
    }
    init{
        println("Student2 name:"+name+" age:"+age)
    }
}

Student name:defaultName age:-1 sno: grade:0
Student 无参数,次构造函数被执行了
===============
Student name:zhangsan age:-1 sno: grade:0
Student name:String次构造函数被执行了
===============
Student name:zhangsan age:18 sno: grade:0
Student name:String,age:Int次构造函数被执行了
===============
Student name:wangwu age:23 sno:113 grade:5
Student2 name:defaultName age:-1
Student2 无参数,次构造函数被执行了
===============
Student2 name:jack li age:-1
Student2 name:String次构造函数被执行了
===============
Student2 name:jack ma age:32
Student2 name:String,age:Int次构造函数被执行了

如果类没有主构造函数,但是继承类的构造函数又必须带参,那么可以用次构造函数去调用父类带参的构造函数

接口

fun main() {
    val s1 = Student("zhangsan",18)
    s1.study()
    println("==多态调用===")
    // 多态调用
    toLearn(s1)
}

open class Person(val name:String,val age:Int){
    fun sayHello(){
        println("hello,I am "+ name+",I am "+ age+" years old.")
    }
}

class Student(val sno:String,val grade:Int,name:String,age:Int):Person(name,age),Study{
    override fun study(){
        println(name+" is studing")
    }
//     override fun readBooks(){
//         println(name+" is reading")
//     }
    //次构造函数
    constructor(name:String,age:Int):this("",0,name,age){
        println("Student name:String,age:Int次构造函数被执行了")
    }
    constructor(name:String):this("",0,name,-1){
        println("Student name:String次构造函数被执行了")
    }
    constructor():this("",0,"defaultName",-1){
        println("Student 无参数,次构造函数被执行了")
    }
    init{
        println("Student name:"+name+" age:"+age+" sno:"+sno+" grade:"+grade)
    }
}

interface Study{
    fun study()
    // 接口方法的默认实现
    fun readBooks(){
        println("default is reading books.")
    }
}

fun toLearn(stu:Study){
    stu.study()
    stu.readBooks()
}

Student name:zhangsan age:18 sno: grade:0
Student name:String,age:Int次构造函数被执行了
zhangsan is studing
==多态调用===
zhangsan is studing
default is reading books.

数据类和单例

数据类

fun main() {
    val c1 = CellPhone("Apple",118)
    val c2 = CellPhone("Apple",118)
    println(c1)
    println("c1==c2?"+(c1==c2))
}

//data表明CellPhone类是数据类.没有代码可以省略{}不写
data class CellPhone(val brank:String,val price:Int)

CellPhone(brank=Apple, price=118)
c1==c2?true

单例

fun main() {
    Singleton.singletonTest()
}

//声明单例类,使用object关键字
object Singleton{
    fun singletonTest(){
        println("singletonTest is called.")
    }
}

singletonTest is called.

单例类声明使用关键字object

全局只会有一个Singleton类

集合

List

fun main() {
    //声明list
    println("声明list")
    val list1= ArrayList<String>()
    list1.add("a")
    list1.add("b")
    list1.add("c")
    for(i in list1){
        println(i)
    }
    println("=========")
    //另一种方式
    println("另一种方式声明list,该list为不可变list")
    //listOf声明的是不可变的list,即不可以调用add或delete方法增加删除元素.
    val list2=listOf("a","b","c")
    for(i in list2){
        println(i)
    }
    println("=========")
    println("另一种方式声明list,该list为可变list")
    val list3=mutableListOf("a","b","c")
    list3.add("d")
    for(i in list3){
        println(i)
    }
}

声明list
a
b
c
=========
另一种方式声明list,该list为不可变list
a
b
c
=========
另一种方式声明list,该list为可变list
a
b
c
d

Set

fun main() {
    //setOf声明的是不可变的set,即不可以调用add或delete方法增加删除元素.
    println("声明set,该set为不可变set")
    val set1=setOf("a","b","c")
    for(i in set1){
        println(i)
    }
    println("=========")
    println("另一种方式声明set,该set为可变set")
    val set2=mutableSetOf("a","b","c")
    set2.add("d")
    for(i in set2){
        println(i)
    }
}

声明set,该set为不可变set
a
b
c
=========
另一种方式声明set,该set为可变set
a
b
c
d

Map

fun main() {
    println("map的声明和使用")
    val map = HashMap<String,Int>()
    map.put("zhangsan",1)
    map.put("lisi",2)
    map.put("wangwu",3)
    //更推荐使用这种方式修改以及赋值
    map["jack"]=4
    map["tony"]=5
    for((name,age) in map){
        println(name+" "+age)
    }
    //取值
    println("jack's age is "+map["jack"])
    println("===================")
    //另一种map的声明方式
    println("另一种map的声明方式")
    val map2 = mapOf("a" to 1,"b" to 2,"c" to 3)
    for((name,age) in map2){
        println(name+" "+age)
    }
}

map的声明和使用
tony 5
lisi 2
zhangsan 1
wangwu 3
jack 4
jack's age is 4
===================
另一种map的声明方式
a 1
b 2
c 3

集合的函数式API

Lambda表达式

fun main() {
    val fruits = listOf("Apple","Orange","Banana","Pear","Watermelon","Lemon")
    //获取最长的水果名
    var maxFruit = fruits.maxBy{it.length}
    println(maxFruit)
    println("=======")
    //lambda表达式 {参数1:参数类型,参数2:参数类型->函数体}
    //完全不简化的代码
    println("完全不简化的代码")
    val lambda = {name:String->name.length}
    maxFruit=fruits.maxBy(lambda)
    println(maxFruit)
    //简化步骤1.去掉lambda变量
    println("========")
    println("简化步骤1.去掉lambda变量")
    maxFruit=fruits.maxBy({name:String->name.length})
    println(maxFruit)
    println("========")
    println("简化步骤2. 当lambda表达式为函数的最后一个参数时候,可以写到括号外面")
    maxFruit=fruits.maxBy(){name:String->name.length}
    println(maxFruit)
    println("========")
    println("简化步骤3. 如果lambda表达式是函数的唯一一个参数,可以省略小括号")
    maxFruit=fruits.maxBy{name:String->name.length}
    println(maxFruit)
    println("========")
    println("简化步骤4. kotlin可以自动推导变量类型,可以省略变量类型定义")
    maxFruit=fruits.maxBy{name->name.length}
    println(maxFruit)
    println("========")
    println("简化步骤5. lambda表达式只有一个参数时,不必声明变量名,可以使用it关键字")
    maxFruit=fruits.maxBy{it.length}
    println(maxFruit)
}

Watermelon
=======
完全不简化的代码
Watermelon
========
简化步骤1.去掉lambda变量
Watermelon
========
简化步骤2. 当lambda表达式为函数的最后一个参数时候,可以写到括号外面
Watermelon
========
简化步骤3. 如果lambda表达式是函数的唯一一个参数,可以省略小括号
Watermelon
========
简化步骤4. kotlin可以自动推导变量类型,可以省略变量类型定义
Watermelon
========
简化步骤5. lambda表达式只有一个参数时,不必声明变量名,可以使用it关键字
Watermelon

map()、filter()、all()、any()

fun main() {
    val fruits = listOf("Apple","Orange","Banana","Pear","Watermelon","Lemon")
    println("map函数,映射")
    val upperFruits = fruits.map{it.toUpperCase()}
    for (i in upperFruits) println(i)
    println("=====")
    println("filter函数,过滤")
    val lowerFruit= fruits.filter{it.length>5}.map{it.toLowerCase()}
    for (i in lowerFruit) println(i)
    println("=====")
    println("all函数,集合内所有元素均符合条件则返回true,否则为false")
    val res1 = fruits.all{it.length>5}
    println(res1)
    println("=====")
    println("any函数,集合内任意元素符合条件则返回true,否则为false")
    val res2 = fruits.any{it.length>8}
    println(res2)
}

map函数,映射
APPLE
ORANGE
BANANA
PEAR
WATERMELON
LEMON
=====
filter函数,过滤
orange
banana
watermelon
=====
all函数,集合内所有元素均符合条件则返回true,否则为false
false
=====
any函数,集合内任意元素符合条件则返回true,否则为false
true

版权属于：本文为原创文章，版权归猫先生所有
本文链接：https://loli.rip/index.php/archives/620/
转载时须注明出处及本声明

在线运行Kotlin

变量

函数

流程控制

if语句

when条件语句

循环语句

面向对象

类

继承与构造函数

次构造函数

接口

数据类和单例

数据类

单例

集合

List

Set

Map

集合的函数式API

Lambda表达式

map()、filter()、all()、any()