01kotlin基础语法

最新推荐文章于 2024-07-19 16:39:02 发布

LJLThomson

最新推荐文章于 2024-07-19 16:39:02 发布

阅读量93

点赞数

分类专栏： kotlin 文章标签： kotlin

本文链接：https://blog.csdn.net/LJLThomson/article/details/118585023

版权

kotlin 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

koltin基础语法

1.函数基础知识

fun main() {
    println("Hello world")
    var value = sum1(3, 5)
    print(value)
}

//函数
fun sum(a: Int, b: Int): Int {
    return a + b
}

//函数lamada表达式
fun sum1(a: Int, b: Int) = a + b //lamada=会自动识别类型，如果块状

//unit返回无类型，与java中void等价，可以省略
fun printSum(a: Int, b: Int): Unit = println(a + b)

2.变量

package day1

//类中，f，g都是静态的
//val等价于 static final
//var等价于static
val F = 5
var g = 4

fun main(args: Array<String>) {
    //val对象不能修改，但对象内部的属性值可以修改
    val a: Int = 1
    val b: Int = 4
    val b2 = "wo de shijie"
    println(b2.replace("wo","nihao"))
    val c = 3;
    //var可修改
    var d = 5;
    print("$a" + "$b" + "$c" + "$d")
}
/* 注释从这里开始
/* 包含嵌套的注释 */
并且在这里结束。 */

3.条件表达式

//条件表达式
fun maxOf(a: Int, b: Int): Int {
    if (a > b) {
        return a
    } else {
        return b
    }
}

//改写
fun maxOf2(a: Int, b: Int): Int {
    return if (a > b) {
        a
    } else {
        b
    }
}

//改写
fun maxOf3(a: Int, b: Int) = if (a > b) a else b

4.类型检测与自动转换

package day1

fun main(args: Array<String>) {
    //判断是否可空
    var data: String? = null
    println(data)
}

//函数可空
fun sub(a: Int, b: Int): Int? = null;

fun sub2(a: Any): Int? {
    //判断成功之后，无须再判断
    return if (a is String) {
        a.length
    } else {
        null
    }
}

5.for循环

for循环基本操作

package day1

fun main(args: Array<String>) {
    val items = listOf("apple", "banana", "kiwifruit")
    //for循环
var index = 0
while (index < items.size) {
    println("item at $index is ${items[index]}")
    index++
}
    //第一种形式for循环
    for (item in items) {
        println(item)
    }
    println()
    //第二种形式for循环
    items.forEach { println(it) }
    println()
    //不执行后续,此时相当于continue
    items.forEach lit@{
        if (it.length == 6) return@lit
        println(it)
    }
    println()
    //不执行后续,此时相当于continue,等价于上面操作
    items.forEach {
        //不执行后续
        if (it.length == 6) return@forEach
        println(it)
    }
    println("开始")
    //如果不加标签，则直接退出
//    items.forEach {
//        //不执行后续
//        if (it.length == 6) return
//        println(it)
//    }
    println("xxxx")
    items.forEach(fun(m) {
        if (m.length == 6) return
        println(m)
    })

    //break操作
    run Looper@{
        items.forEach {
            //不执行后续
            if (it.length == 6) return@Looper
            println(it)
        }
    }
}

判断数据在不在集合中

    //判断a是不是再集合中
    //等价于
//    if (mList.contains(a)) {
//        System.out.println(a);
//    }
    var a = 2;
    if (a in list1) {
        println(a)
    }

key和value

package day1

fun main(args: Array<String>) {
    val items = listOf("apple", "banana", "kiwifruit")
    for (item in items) {
        println(item)
    }
    //下标
    for (position in items.indices) {
        println("$position" + items[position])
    }
    //下标和value
    for ((index, value) in items.withIndex()) {
        println("$index" + " $value")
    }
}

6when表达式

package day1

fun main(args: Array<String>) {
    println(describe("xx"))
    var a=10
    var b = when(a){
        1-> "奔波儿霸"
        2-> "霸波儿奔"
        4,5-> "奔波儿霸和霸波儿奔"
        in 6 .. 10 -> "对的"
        else ->"错误"
    }
    //找到便break返回
    val items = listOf("apple", "banana", "kiwifruit")
    when {
        "banana" in items -> println("banana")
        "apple" in items -> println("apple is fine too")
    }
    println(b)
}

fun describe(obj: Any): String =
        when (obj) {
            1 -> "One"
            "Hello" -> "Greeting"
            is Long -> "Long"
            is String -> obj
            !is String -> "Not a string"
            else -> "Unknown"
        }

7 range区间

package day1

fun main(args: Array<String>) {
    val x = 10
    val y = 9
    if (x in 1..y + 1) { // 1到10
        println("fits in range")
    }
    if (x in 1 until y + 1) { // 1到9
        println("fits in range")
    }
    var num = 3
    if (num in 10 downTo 1 step 2) {
       println(num)
    }

    //检测某个数字是否在指定区间外:
    val list = listOf("a", "b", "c")
    if (-1 !in 0..list.lastIndex) {
        println("-1 is out of range")
    }
    if (list.size !in list.indices) {
        println("list size is out of valid list indices range, too")
    }
}

8.集合排序

package day1

fun main(args: Array<String>) {
    val fruits = listOf("banana", "avocado", "apple", "kiwifruit")
    var list2 = fruits
            .filter { it.startsWith("a") }
            .sortedBy { it }
            .map { it.toUpperCase() }
//            .forEach { println(it) }
    println(list2)

    fruits.sortedBy { it.first() }
            .forEach {
                println(it)
            }
    val list = listOf(1, 4, 2, 2)
//    println(list.sortedBy { -it })
    println(list.sorted()) // 只能升序， 等价于java中Collections.sort(mList);如果需要降序，需使用sortBy
    println(list.sortedDescending())// 倒叙
    var mlist = list.reversed(); // 反转
    println(mlist)

    test5()
}

fun test5() {
    val sortedValues = mutableListOf(
            1 to "a",
            2 to "b",
            6 to "c",
            5 to "e",
            3 to "c",
            4 to "d",
            7 to "a"
    )
    sortedValues.sortWith(compareBy({ it.first }, { it.second })) //以第一个为主
    println(sortedValues) // [(1, a), (2, b), (5, c), (7, c), (6, d), (6, e)]
}

9.集合非基本类型排序

package day1

import java.util.*
import kotlin.Comparator

data class Person(var name: String, var age: Int)

private val personList: MutableList<Person> = mutableListOf(
        Person("B", 2),
        Person("A", 2),
        Person("D", 1),
        Person("C", 3)
)

data class School(var name: String, var age: Int) : Comparable<School> {
    override fun compareTo(other: School): Int {
        return if (this.age == other.age) {
            this.name.compareTo(other.name)
        } else {
            other.age - this.age
        }
    }
}

//Comparable 与 Comparator ：
// 两者的区别是实现Comparator接口代码更加灵活，可以定义某个类的多个比较器，
// 从而在排序时根据实际场景自由调用，而Comparable接口实现后便不能改动
class MyComparator : Comparator<School> {
    override fun compare(p1: School, p2: School): Int {
        return if (p1.age == p2.age) {
            p1.name.compareTo(p2.name)
        } else {
            p2.age - p1.age
        }
    }
}

private val schoolList: MutableList<School> = mutableListOf(
        School("B", 2),
        School("A", 2),
        School("D", 1),
        School("C", 3)
)

/**
 * 非基本类型，引用
 */
fun main(args: Array<String>) {
    personList.sortBy { it.name }    //升序
    println(personList)
    personList.sortByDescending { it.age }
    println(personList)

//先根据age 【升序】排列，若age相同，根据name【升序】排列
    personList.sortWith(compareBy({ it.age }, { it.name }))
    println(personList)
    personList.sortWith(
            //构造一个Comparator对象，完成排序逻辑：
            // 先按age【降序】排列，若age相同，则按name【升序】排列
            Comparator { o1, o2 ->  //只有一个方法时，可以省略，直接传递参数
                //o1,o2顺序，左边大自然排序升序，否则降序
                if (o2.age == o1.age) {
                    o1.name.compareTo(o2.name)
                } else {
                    o2.age - o1.age
                }
            }
    )
    println(personList)

    schoolList.sortWith(MyComparator())
    println(schoolList)
    //匿名方法
    schoolList.sortWith(Comparator(fun(o1: School, o2: School): Int {
        //o1,o2顺序，左边大自然排序升序，否则降序
        return if (o2.age == o1.age) {
            o1.name.compareTo(o2.name)
        } else {
            o2.age - o1.age
        }
    }))
    var comparato2 = Comparator(fun(o1: School, o2: School): Int {
        //o1,o2顺序，左边大自然排序升序，否则降序
        return if (o2.age == o1.age) {
            o1.name.compareTo(o2.name)
        } else {
            o2.age - o1.age
        }
    })
    var comparato3 = Comparator { o1: School, o2: School ->
        if (o2.age == o1.age) {
            o1.name.compareTo(o2.name)
        } else {
            o2.age - o1.age
        }
    }
    Collections.sort(schoolList, MyComparator())
    println(schoolList)
}

10.字符串比较

注意：在kotlin中，，=== 表示比较对象地址，== 表示比较两个值大小

package day1
data class Person2(var name: String, var age: Int)
fun main(args: Array<String>) {
    var a = "world"
    var b = "world"
    if (a == b) {

    }
    var p1 = Person2("zhangsan",21)
    var p2 = Person2("zhangsan",21)
    if (p1 == p2) {
        println("相等");
    }
    if (p1 === p2) {
        println("不相等");
    }
}

11.回调方法简化

package day1

//在lambda表达式，只支持单抽象方法模型，也就是说设计的接口里面只有一个抽象的方法，才符合lambda表达式的规则，多个回调方法不支持。
interface Listener{
}

12.字符串

package day1

const val str = """
    你好
    世界
    我来了
    不要说话
"""
fun main(args: Array<String>) {
    meth(null)
}
data class Person01(var name: String?, var age: Int)

fun meth(str: String?) {
    str.let {

    }
    var s: String? = null
    println(s ?: "xx")
    println(s)

    var p01 = Person01(null, 20)
    p01.name?.isEmpty();

    if (p01.name?.isEmpty()!!) {
        println(2)
    } else {
        println(3)
    }
}

13.公共属性

package day1

const val b = 3 //等价于java中 public static final int b = 3;
const val c = 4

fun method() {

}

data class Person01(var name: String?, var age: Int)

fun meth(str: String?) {
str.let {

}
var s: String? = null
println(s ?: "xx")
println(s)

var p01 = Person01(null, 20)
p01.name?.isEmpty();

if (p01.name?.isEmpty()!!) {
    println(2)
} else {
    println(3)
}

}


## 13.公共属性

```kotlin
package day1

const val b = 3 //等价于java中 public static final int b = 3;
const val c = 4

fun method() {

}

LJLThomson

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
01kotlin基础语法

koltin基础语法1.函数基础知识fun main() { println("Hello world") var value = sum1(3, 5) print(value)}//函数fun sum(a: Int, b: Int): Int { return a + b}//函数lamada表达式fun sum1(a: Int, b: Int) = a + b //lamada=会自动识别类型，如果块状//unit返回无类型，与java中void等
复制链接

扫一扫