一:基础要点

//常量定义 val
val arg_a1: Int = 1  
//变量定义var
var arg_a2 = 5  // 系统自动推断变量类型为Int

备注:kotlin 定义变量必须给定初始值,如延迟初始值,需要特殊声明!

空对象处理
//可null对象声明

//类型后面加?表示可为空
var agrs_t: String? = null
//抛出空指针异常
val v1 = agrs_t!!.toInt()
//不做处理返回 null //the safe call operator, written ?.
val v2 = agrs_t?.toLong()
//age为空时返回-1, 非空正常执行
val v3 = agrs_t?.toInt() ?: -1
//显示判断处理
val l: Int = if (b != null) b.length else -1 val b: String? = "Kotlin"
if (b != null && b.length > 0) {
print("String of length ${b.length}")
} else {
print("Empty string")
} //安全处理符处理
//the safe call operator, written ?. val lt = b?.length ?: -1//为空为-1 val files = File("Test").listFiles()
println(files?.size ?:"empty")

类型判断及转化

//类型判断,如果为String类型,则自动转为String
if (obj is String) {
    print(obj.length)
}
// 非此类型判断,same as !(obj is String)
if (obj !is String) {
    print("Not a String")
}

//可null类型转化
val x: String? = y as String?
//非null转化
//null cannot be cast to String as this type is not nullable,
val x2: String = y as String

equels与引用比较:

两个对象内容比较(Java中的equels)==两个等号代表

两个引用比较使用===三个等号代表

Equality checks: a == b    ,!==
Referential equality: a === b

this关键字引用含义

class A { // implicit label @A
inner class B { // implicit label @B
fun Int.foo() { // implicit label @foo
val a = this@A // A's this
val b = this@B // B's this
val c = this // foo()'s receiver, an Int
val c1 = this@foo // foo()'s receiver, an Int
val funLit = lambda@ fun String.() {
val d = this // funLit's receiver
}
val funLit2 = { s: String ->
// foo()'s receiver, since enclosing lambda expression
// doesn't have any receiver
val d1 = this
}
}
}
}

说明:

1,this默认不加标签,如在类的成员内,标识当前类对象,在成员函数或扩展函数内部则this代表的是接受者类型对象(如变量c,c1代表作用对象Int)

2,this加上@对应类名称代表指定类对象引用,如a,b

函数定义

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

//无返回值
fun getHello(){
        //......
 }

//不定参数定义函数
fun varsFor(vararg v:Int){//变长参数 vararg
    for(vt in v){
        print(vt)
    }
}

//函数返回可null类型
fun getStringLength(obj: Any): Int? {
    // `obj` 的类型会被自动转换为 `String`
    if (obj is String && obj.length > 0)
        return obj.length
    return null // 这里的obj仍然是Any类型
}

条件控制:

fun blockIfWhen(a:Int ,b:Int){
val max1 = if (a > b) a else b var max2: Int
if (a > b) {
max2 = a
} else {
max2 = b
} val result = if(a == 1) {
"one"
}else {
"other"
} var x = 0
//将参数和所有的分支条件顺序比较,直到某个分支满足条件。
//类似其他语言的 switch 内部else(default)
when (x) {
0, 1 -> println("x == 0 or x == 1")
8, 9 -> println("x == 8 or x == 9")
else -> println("otherwise")
} when (x) {
1 -> println("x == 1")
2 -> println("x == 2")
else -> { // 注意这个块
println("x 不是 1 ,也不是 2")
}
} when (x) {
in 0..10 -> println("x 在该区间范围内")
else -> println("x 不在该区间范围内")
} var tx :Any ?= null
when (tx) {
is Int -> print(tx + 1)
is String -> print(tx.length + 1)
is IntArray -> print(tx.sum())
} //when 也可以用来取代 if-else if链。 如果不提供参数,所有的分支条件都是简单的布尔表达式
when {
x < 5 -> print("x is odd")
x < 9 -> print("x is even")
else -> print("x is funny")
} }

  

集合:kotlin集合分为mutable(可变类型,元素可修改),read-only(只读类型,没有add,remove,set方法)
1,集合类型包含三种类型:List、Set、Map
2,三种集合类型分别对应MutableList<E>、MutableSet<E>、MutableMap<K,V>接口

这里以数组为例:

 //数组,2种创建 arrayof() ,Array(函数表达式)
//方式一 arrayOf(...)元素初始化
//指定类型
val a = intArrayOf(1, 2, 3)// or arrayOf<Int>(1,2,3)
//不限制类型
val a1 = arrayOf(1,"2",true,1.0f,100L)
//方式二 Array(函数or表达式)
val b = Array(10, { i -> (i*2) })//[0,2,4,6,8,]
val b1 = Array(3, { initArray(it) })//[10,11,12...]
//获取元素
// b[1] or b.get(2)
//注:数组内元素为immutable类型,即只读属性 //List 类型,只读类型
val list1 = listOf(1,2,"3",true) // 不定类型创建
val list2 = listOf<String>("1","2","3") // 确定元素的值类型
val list3 = listOf(a) // 使用数组创建
//备注:List一旦创建不可修改,add set remove不能使用 //MutableList 元素可修改
val mutaList1 = mutableListOf<String>("1","2","3")//通过函数mutableListOf创建
val mutaList2 = MutableList(5,{ i -> i*10 })//直接创建并初始化
val mutaList3 = mutableListOf<String>()//创建空的MutableList,后面可以添加元素
mutaList1.add("11")
mutaList1.removeAt(2)
mutaList1.set(0,"mm") //Array List,MutableList 内的元素不能为null
//可以包含null元素的容器需要特殊声明
//空元素的数组
var arr = arrayOfNulls<String>(5)
arr[0]="11"
arr[1]=null
//包含空元素的List
val nullableList: List<Int?> = listOf(1, 2, null, 4)
//可含有null元素容器
val nullableMList:MutableList<String?> = mutableListOf()
nullableMList.add("11")
nullableMList.add(null)

集合常用函数

fun listOperate(){
val items = listOf(1, 2, 3, 4)
items.first() //== 1
items.last() //== 4
val subItems = items.filter { it % 2 == 0 } // returns [2, 4]
var sub2 = items.slice(1..3)
var sub3 =items.filterNot { it>100 } //高阶函数
//遍历list
items.forEach{
// it= it*2+1
print(it)
}
items.forEachIndexed { index, value -> if (value > 8) println("value of index $index is $value") }
//T->R 集合中的元素通过某个方法转换后的结果存到一个集合
val list11 = items.map { (it - 2+1).toLong() }
val list111 = items.mapIndexed { index, it -> if(index>5) 10 * it }
//合并两个集合
// items.flatMap { listOf(it, it + 1) } // map:遍历每一个元素
// flatMap:遍历每一个元素,并铺平(展开内部嵌套结构)元素
var list_map = listOf(listOf(10,20),listOf(30,40),listOf(50,60))
var mapList = list_map.map{ element -> element.toString() }
var flatMapList = list_map.flatMap{ element -> element.asIterable() }
// map [[10, 20], [30, 40], [50, 60]]
// flatmap [10, 20, 30, 40, 50, 60] // filter all 符合条件element
val list12 = items.filter { mypre(it) }
//filter 到第一个不符合条件元素返回,后面不再过滤
val list13 = items.takeWhile { (it%2!=0) }
//提取前3个元素
val list14 = items.take(3)
//提取后3个
val list15 = items.takeLast(3)
//去除重复元素
var list16 = items.distinct()
//指定key过滤条件
var list17 = items.distinctBy { it*101+100 }
// list1.fold(5,operation = )
//匹配交集元素
var list18 = items.intersect(listOf<Int>(2,3,4))
//匹配两个集合内所以不同元素,差集合
var list19 = items.union(listOf<Int>(2,3,4))
//返回匹配条件元素
var list21 = items.any { (it in 10..20) }
//返回符合条件元素个数
var list22 = items.count { it >20 }
//给定初始值,指定计算函数对元素累计处理
var list23 = items.fold(10) { total, next -> total + next }
//指定计算函数对元素累计处理
var list24 =items.reduce { total, next -> total - next } var sumFilterResult : Int = 0
items.filter { it < 7 }.forEach { sumFilterResult += it } val rwList = mutableListOf(1, 2, 3)
// 去除null元素
rwList.requireNoNulls() //returns [1, 2, 3]
//检测list内有符合条件元素
if (rwList.none { it > 6 }) println("No items above 6") // prints "No items above 6"
//第一个元素,或为空对象
val item = rwList.firstOrNull() //集合分组
val groupItem:Map<String,List<Int>> = items.groupBy { handleGroup(it) } val numbers11 = setOf(1, 2, 3)
println(numbers11.mapNotNull { if ( it == 2) null else it * 3 })
println(numbers11.mapIndexedNotNull { idx, value -> if (idx == 0) null else value * idx }) val colors = listOf("red", "brown", "grey")
val animals = listOf("fox", "bear", "wolf")
//集合元素组合压缩
val zipResult = colors.zip(animals) { color, animal -> "The ${animal.capitalize()} is $color"}
println(zipResult) val numbers = listOf("one", "two", "three", "four", "five")
println(numbers.elementAtOrNull(5))
println(numbers.elementAtOrElse(5) { index -> "The value for index $index is undefined"})
println(numbers.last { it.startsWith("f") })
println(numbers.firstOrNull { it.length > 6 })
//数据采样
println(numbers.slice(0..4 step 2))//[one, three, five]
println(numbers.slice(setOf(3, 5, 0)))//[four, six, one]
//安匹配条件分组,转换value
println(numbers.groupBy { it.first().toUpperCase() })//{O=[one], T=[two, three], F=[four, five]}
println(numbers.groupBy(keySelector = { it.first() }, valueTransform = { it.toUpperCase() }))//{o=[ONE], t=[TWO, THREE], f=[FOUR, FIVE]}
//分块处理
val numbers2 = (0..13).toList()
println(numbers2.chunked(3))//[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11], [12, 13]]
println(numbers2.chunked(3) { it.sum() })//per chunk sum
} fun handleGroup(v:Int):String{
if(v%2==0) return "even"
else return "odd"
} fun arrayOfMinusOnes(size:Int): IntArray {
return IntArray(size).apply { fill(-1) }
} fun mypre(t:Int): Boolean{
return t%2==0
}

lateinit是否初始化判断

lateinit var mLoginViewModel: LoginViewModel
if(::mLoginViewModel.isInitialized){
return
}

lazy初始化状态判断

val delegateHomePage = lazy{ HomeFragment() }
private val mPageHome by delegateHomePage
if(delegateHomePage.isInitialized()) ts.show(mPageHome)
else{
ts.add(R.id.mainContent,mPageHome)
listPage.add(mPageHome)
}

Kotlin学习-基础知识点的更多相关文章

  1. java 学习基础知识点拾遗 导航页

    每种编程语言的知识点都是很多很杂的,java也是如此 相信很多人学习的过程中都是深一脚浅一脚,最基础的东西可能有些也不是非常确定 整理了最基本的一些知识点,可以说是java入门的-1层级别的,作为自己 ...

  2. C语言的学习-基础知识点

    ---BOOL BOOL BOOL a = YES; printf("%d\n", a); a = NO; printf("%d", a); , b = ; B ...

  3. c语言学习之基础知识点介绍(三):scanf函数

    本节继续介绍c语言的基础知识点. scanf函数:用来接收用户输入的数据. 语法:scanf("格式化控制符",地址列表); 取地址要用到取地址符:&(shift+7) 例 ...

  4. c语言学习之基础知识点介绍(二):格式化控制符和变量的补充

    上节简单介绍了c语言中的一些基础知识点,本节将对之前介绍的不够详细的知识点进行补充. 格式化控制符的消息介绍: %d的其他控制符: 1.%md:m代表这个整数位占用多少位,m是一个整数.实际数字不足的 ...

  5. 20165318 预备作业二 学习基础和C语言基础调查

    20165318 学习基础和C语言基础调查 技能学习经验 我们这一代人,或多或少的都上过各种兴趣班,舞蹈钢琴画画书法,我也是如此.可这些技能中,唯一能拿的出手的就是舞蹈了.按照<优秀的教学方法- ...

  6. TypeScript 基础知识点整理

    一.TypeScript的特点 1.支持ES6规范 2.强大的IDE支持(集成开发环境) 允许为变量指定类型,减少你在开发阶段犯错误的几率. 语法提示,在IDE编写代码时,它会根据你所处的上下文把你能 ...

  7. 20165223 学习基础和C语言基础调查

    一.学习基础 1. 我所擅长的技能 从小我就对新鲜事物抱有浓厚的兴趣,因此多年来培养了许多爱好,对感兴趣的诸如绘画方面的国画.油画.素描.漫画等:音乐方面的钢琴.吉他.架子鼓等:运动方面的滑板.溜冰. ...

  8. 20165234 预备作业2 学习基础和C语言基础调查

    学习基础和C语言基础调查 一.技能学习经验及体会 你有什么技能比大多人(超过90%以上)更好? 看到这个问题,我仔细想了想,好像的确没有什么特别出众的技能,但是我想到了许多我个人的爱好. 我从小喜欢五 ...

  9. Java基础知识点总结

    前言 本文主要是我之前复习Java基础原理过程中写的Java基础知识点总结.Java的知识点其实非常多,并且有些知识点比较难以理解,有时候我们自以为理解了某些内容,其实可能只是停留在表面上,没有理解其 ...

  10. JAVA基础知识点总结(全集)

    1.JAVA简介 1.1java体系结构:j2se,javaweb,j2ee 1.2java特点:平台无关(虚拟机),垃圾回收(使得java更加稳定) 1.3 JDK与JRE,JDK:java开发环境 ...

随机推荐

  1. Mybatis源码解析之执行SQL语句

    作者:郑志杰 mybatis 操作数据库的过程 // 第一步:读取mybatis-config.xml配置文件 InputStream inputStream = Resources.getResou ...

  2. 精华推荐 | 【深入浅出RocketMQ原理及实战】「性能原理挖掘系列」透彻剖析贯穿RocketMQ的事务性消息的底层原理并在分析其实际开发场景

    什么是事务消息 事务消息(Transactional Message)是指应用本地事务和发送消息操作可以被定义到全局事务中,要么同时成功,要么同时失败.RocketMQ的事务消息提供类似 X/Open ...

  3. pytest常用参数汇总

    1.  -s    表示输出调试信息,包括print打印信息 D:\demo>pytest -s ./pytest_1 ===================================== ...

  4. Octave/Matlab初步学习

    Octave/Matlab初步学习 1.基本运算 和其他语言一样,可以通过数学运算符号来实现数学公式的运算.逻辑运算也基本相同 要注意的是,≠这个符号,表达式为 1 ~= 2 而不是用!=来表达 ​ ...

  5. Flask初步认识

    1.Flask基本认识 Flask 本身相当于一个内核,其他几乎所有的功能都要用到扩展包(数据库Flask-SQLAlchemy),都需要用第三方的扩展来实现.比如可以用 Flask 扩展加入ORM. ...

  6. P7914 [CSP-S 2021] 括号序列

    简要题意 给定 \(k\),定义 "超级括号序列"(简称括号序列,下同) 字符串为: 仅由 ( ) * 三种字符组成. 下面令 \(S\) 为不超过 \(k\) 个 \(\ast\ ...

  7. 浅谈LCA问题(最近公共祖先)(四种做法)

    [模板]最近公共祖先(LCA) \(update \ 2023.1.3\) 新增了树链剖分 题目描述 如题,给定一棵有根多叉树,请求出指定两个点直接最近的公共祖先. 输入格式 第一行包含三个正整数 \ ...

  8. cordova完整版本创建、修改自定义插件重新调试步骤带截图

    创建第三方插件 npx plugman create --name myplugin --plugin_id xiao.jin.plugin --plugin_version 1.0.0 添加平台支持 ...

  9. mysql 简单查询

    查询特定列SELECT ename,birthday FROM emp; 查询所有的select*from emp; 给列起别名select ename AS 姓名, salary AS 工资 FRO ...

  10. 创建型模式 - 抽象工厂模式AbstractFactory

    学习而来,代码是自己敲的.也有些自己的理解在里边,有问题希望大家指出. 模式的定义与特点 抽象工厂模式.是一种为访问类提供一个创建一组相关或相关一类对象的接口,且访问类无需指定所要的产品的具体类,就能 ...