Kotlin基础知识学习一
数据类型
基本数据类型
数据类型和变量声明
kotlin的数据类型根java一样也包含整型、长整型、浮点型、双精度、布尔型、字符型、字符串常见类型。
与Java类型对比
| 数据类型名称 | Java数据类型 | Kotlin数据类型 |
|---|---|---|
| 整型 | int | Int |
| 常整型 | long | Long |
| 浮点型 | float | Float |
| 双精度 | double | Double |
| 布尔型 | boolean | Boolean |
| 字符型 | char | Char |
| 字符串 | String | String |
变量声明
格式：var 变量名：变量类型 = 值
如果换行不需要加分号，否则需要加入分号
fun main() {
//整型
var a:Int = 0
println("a=$a") //a=0
//长整型
var b:Long = 3
println("b=$b") //b=3
//浮点型
var c:Float = 2f
println("c=$c") //c=2.0
//双精度
var d:Double = 4.1
println("d=$d") //d=4.1
//字符型
var e:Char = 'e'
println("e=$e")//e=e
//布尔型
var f:Boolean = false
println("f=$f")//f=false
}
变量类型转换
kotlin类型转换不能像Java一样使用变量名前加上转换的数据类型，需要调用类型转成输出函数进行转换
| 转换函数 | 说明 |
|---|---|
| toInt | 转换成整型 |
| toLong | 转换成长整型 |
| toFloat | 转换成浮点型 |
| toDouble | 转换成双精度 |
| toChar | 转换成字符 |
| toString | 转换成字符串 |
fun main(){
var a:Int = 97
var d:Double = 3.2
//转成双精度
d = a.toDouble()
println("d=$d")//d=97.0
//转成字符串
var s = a.toString()
println("s=$s")//s=97
//转成字符
var c = a.toChar()
println("c=$c")//c=a
}
数组
数组声明
fun main(){
//java 创建数组 int[] array = new int[]{1,2};
//整型数组
var intArray:IntArray = intArrayOf(1,2,3)
//长整型数组
var longArray:LongArray = longArrayOf(1,2,3)
//浮点型数组
var floatArray:FloatArray = floatArrayOf(1.3f,2.4f)
//双精度数组
var doubleArray:DoubleArray = doubleArrayOf(2.1,3.4)
//字符数组
var charArray:CharArray = charArrayOf('a','b')
//布尔型数组
var booleanArray:BooleanArray = booleanArrayOf(false,true)
//字符串数组
var stringArray:Array<String> = arrayOf("张三","李四")
//其余类型也可以根字符串数组一样
var intArrays:Array<Int> = arrayOf(1,2)
}
数组访问
fun main(){
var intArray:IntArray = intArrayOf(1,2,3,4,5,6)
//数组的大小
var size = intArray.size
println("size=$size")//size=6
//通过方括号下标访问元素
var array1 = intArray[0]
println("array1=$array1")//array1=1
//通过get()方法访问元素
var array2 = intArray.get(1)
println("array2=$array2")//array2=2
//通过方括号下标修改元素
intArray[3] = 4
//通过set方法修改元素
intArray.set(4,6);
}
字符串
kotlin字符串类型和Java一样都是String
字符串转基本类型
| 转换目标 | kotlin转换方式 | Java转换方式 |
|---|---|---|
| 转整型 | 字符串变量. toInt() | Integer.parseInt(字符串变量) |
| 转长整型 | 字符串变量. toLong() | Long.parseLong(字符串变量) |
| 转长浮点数 | 字符串变量. toFloat() | Long.parseFloat(字符串变量) |
| 转长双精度 | 字符串变量. toDouble() | Long.parseDouble(字符串变量) |
| 转长双精度 | 字符串变量. toBoolean() | Long.parseBoolean(字符串变量) |
fun main(){
var s:String = "1"
//字符串转整形
var a = s.toInt()
println("a=$a")//a=1
//字符串转长整形
var b = s.toLong()
println("b=$b")//b=1.0
//字符串转双精度
var c = s.toDouble()
println("c=$c")//c=1.0
//字符串转浮点型
var d = s.toFloat()
println("d=$d")//d=1.0
//字符串转布尔型
var s1:String = "true"
var e = s1.toBoolean()
println("e=$e")//e=true
//字符串转字符数组
var f = s1.toCharArray()
}
字符串常用方法
- indexOf() 查找一个字符串中首次出现的指定字符或子字符串的索引位置,找到则返回对应的索引位置，否则返回-1。
- substring() 从当前字符串截取子字符串，返回截取后的字符串。
- split() 将字符串分割成一个字符串数组（List），基于指定的分隔符或正则表达式。
- 通过下标或者get方法获取对应位置的字符
fun main(){
val s = "abcd.efg"
//查找一个字符串中首次出现的指定字符或子字符串的索引位置,找到则返回对应的索引位置，否则返回-1
var index = s.indexOf('.')
println("index=$index")//index=4
index = s.indexOf('#')
println("index=$index")//index=-1
//从指定索引位置截取子字符串
val s1 = "DKFALD-dwewod"
var s2 = s1.substring(4)
println("s2=$s2")//s2=LD-dwewod
//从指定索引位置到截止位置上截取子字符串
var s3 = s1.substring(3,5)
println("s3=$s3")//s3=AL
//将字符串分割成一个字符串数组（List），基于指定的分隔符或正则表达式
val s4 = "apple,banana,orange"
var list:List<String> = s4.split(",")
for (item in list){
print("$item ")//apple banana orange
}
println()
val s5 = "apple1banana2orange"
var list1:List<String> = s5.split(Regex("\\d"))
for (item in list1){
print("$item ")//apple banana orange
}
println()
//通过下标获取对应位置的字符
val s6 = "apple1banana2orange"
var s7 = s6[3]
println("s7=$s7")//s7=l
var s8 = s6.get(6);
println("s8=$s8")//s8=b
}
字符串拼接
kotlin字符串拼接采用美元符号$变量名的方式，$是特殊符号，如果要单独打印需要进行转义，可以采用\$,也可以采用{‘$’}
fun main(){
//使用$进行拼接
val str = "abc"
println("dadf$str")//dadfabc
println("字符串str的长度是${str.length}")//字符串str的长度是3
}
容器
kotlin容器主要包含三种集合(Set)、队列(List)、映射(Map)。每种容器又分为只读和可变两种类型，只读容器只能读取数据，而不能进行增删改操作；可变容器则允许对内部元素进行增、删、改操作，可变容器在类型名称前会加上“Mutable”前缀。
Kotlin中的容器还提供了一些公共操作方法，这些操作方法适用于所有类型的容器：
- isEmpty()：判断该容器是否为空。
- isNotEmpty()：判断该容器是否非空。
- clear()：清空该容器。
- contains()：判断该容器是否包含指定元素。
- iterator()：获取该容器的迭代器，用于遍历容器中的元素。
- count()/size：获取该容器包含的元素个数。
集合的初始化方法
| 容器 | 容器名称 | 初始化方法 |
|---|---|---|
| 只读集合 | Set | setOf |
| 可变集合 | MutableSet | mutableSetOf |
| 只读队列 | ||
| 可变队列 | ||
| 只读映射 | ||
| 可变映射 |
集合Set
特点及常用方法使用
- 一种无序的容器，不能通过下标来访问元素。
- 集合中的元素具有唯一性(通过哈希值判断)，即不允许有重复的元素。
- Kotlin中的集合可以分为只读集合（Set）和可变集合（MutableSet）。
- 只读集合Set初始化之后就不能更改，只能访问。可变集合（MutableSet）可进行增删改。
fun main(){
//初始化集合，不可变,无序，不可重复
val set = setOf("星期一","星期二","星期三","星期一","星期四","星期五")
for (item in set){
print("$item ")//星期一 星期二 星期三 星期四 星期五
}
println()
//获取集合大小
println("set集合大小是${set.size}")//set集合大小是5
println("set集合大小是${set.count()}")//set集合大小是5
//判断集合是否为空
var empty = set.isEmpty()
println("set集合是否为空:$empty")//set集合是否为空:false
var contains = set.contains("星期一")
println("set集合是否包含星期一:$contains")//set集合是否包含星期一:true
//获取迭代器
var iterator = set.iterator()
println(iterator.next())//星期一
println("-----------")
var mutableSet:MutableSet<Int> = mutableSetOf(1,2)
printSet(mutableSet)//1 2
//添加元素
var add = mutableSet.add(3)
println(add)//true
printSet(mutableSet)//1 2 3
var remove = mutableSet.remove(2)
println(remove)//true
printSet(mutableSet)//1 3
}
fun printSet(mutableSet:MutableSet<Int>){
for (item in mutableSet){
print("$item ")
}
println()
}
遍历方式
fun main(){
val set = setOf("星期一","星期二","星期三","星期一","星期四","星期五")
//for in遍历方式
for (item in set){
print("$item ")//星期一 星期二 星期三 星期四 星期五
}
println()
val iterator = set.iterator()
//迭代器遍历
while (iterator.hasNext()){
print("${iterator.next()} ")//星期一 星期二 星期三 星期四 星期五
}
println()
//forEach遍历
set.forEach {
print("$it ")//星期一 星期二 星期三 星期四 星期五
}
}
队列List
特点及常用方法使用
- 队列是一种有序的容器，可以通过下标来访问元素。
- 与集合不同，队列中的元素可以重复。
- Kotlin中的队列可以分为只读队列（List）和可变队列（MutableList）。
- 队列能够通过get方法获取指定位置的元素，也可以直接通过下标获得该位置的元素。
- 队列可通过sort方法进行排序。
- MutableList的add方法每次都是把元素添加到队列末尾，也可指定添加的位置。
- MutableList的set方法允许替换或者修改指定位置的元素。
- MutableList的removeAt方法允许删除指定位置的元素。
/**
* 不可变队列list
*/
fun main(){
val list:List<String> = listOf("一月","二月","三月","四月")
for (item in list){
print("$item ")//一月 二月 三月 四月
}
println()
//获取集合大小
println("list队列大小是${list.size}")//list队列大小是4
println("list队列大小是${list.count()}")//list队列大小是4
//判断集合是否为空
var empty = list.isEmpty()
println("list队列是否为空:$empty")//list队列是否为空:false
var contains = list.contains("五月")
println("list队列是否包含五月:$contains")//list队列是否包含五月:false
//获取迭代器
var iterator = list.iterator()
println(iterator.next())//一月
//通过下标索引获取元素
var str = list[0]
println("str=$str")//str=一月
//通过get方法获取元素
var str1 = list.get(1)
println("str1=$str1")//str1=二月
}
/**
* 可变队列
*/
fun main(){
val mutableList:MutableList<String> = mutableListOf("一月","二月","三月","四月")
printList(mutableList)//一月 二月 三月 四月
//添加元素(末尾添加)
mutableList.add("五月")
mutableList.add("六月")
printList(mutableList)//一月 二月 三月 四月 五月 六月
//修改指定索引位置上的值
mutableList.set(4,"天气正好")
printList(mutableList)//一月 二月 三月 四月 天气正好 六月
//移除指定元素
mutableList.remove("三月")
printList(mutableList)//一月 二月 四月 天气正好 六月
//移除指定索引位置上的元素
mutableList.removeAt(2)
printList(mutableList)//一月 二月 天气正好 六月
//排序
mutableList.sort()
printList(mutableList)//一月 二月 六月 天气正好
//指定条件升序排序
mutableList.sortBy { it.length }
printList(mutableList)//一月 二月 六月 天气正好
//指定条件降序排序
mutableList.sortByDescending { it.length }
printList(mutableList)//天气正好 一月 二月 六月
}
fun printList(mutableSet:MutableList<String>){
for (item in mutableSet){
print("$item ")
}
println()
}
遍历方式
队列除了拥有跟集合一样的三种遍历方式（for-in循环、迭代器遍历、forEach遍历）外，还多了一种按元素下标循环遍历的方式。
/**
* 集合遍历
*/
fun main(){
val mutableList:MutableList<String> = mutableListOf("一月","二月","三月","四月")
//for in遍历方式
for (item in mutableList){
print("$item ")//一月 二月 三月 四月
}
println()
val iterator = mutableList.iterator()
//迭代器遍历
while (iterator.hasNext()){
print("${iterator.next()} ")//一月 二月 三月 四月
}
println()
//forEach遍历
mutableList.forEach {
print("$it ")//一月 二月 三月 四月
}
println()
//通过下标进行遍历
for (i in mutableList.indices){
print("${mutableList[i]} ")//一月 二月 三月 四月
}
}
映射Map
特点及常用方法使用
- 映射是一种键值对的容器，每个元素都有一个唯一的键和一个对应的值。
- Kotlin中的映射可以分为只读映射（Map）和可变映射（MutableMap）。
- 映射的containsKey方法判断是否存在指定键名的元素，containsValue方法判断是否存在指定键值的元素。
- MutableMap的put方法不单单是添加元素，而是智能的数据存储。每次调用put方法时，映射会先根据键名寻找同名元素，如果找不到就添加新元素，如果找得到就用新元素替换旧元素。
- 调用mapOf和mutableMapOf方法初始化映射时，有两种方式可以表达单个键值对元素，其一是采取“键名 to 键值”的形式，其二是采取Pair配对方式，形如“Pair(键名, 键值)”。
/**
* 不可变映射map
*/
fun main(){
//to方式初始化
val map:Map<String,Int> = mapOf("一月" to 1,"二月" to 2,"三月" to 3,"四月" to 4)
//Pair方式初始化
mapOf(Pair("一月",1),Pair("二月",1))
for (item in map){
print("$item ")//一月=1 二月=2 三月=3 四月=4
}
println()
//获取集合大小
println("map大小是${map.size}")//map大小是4
println("map大小是${map.count()}")//map大小是4
//判断集合是否为空
var empty = map.isEmpty()
println("map是否为空:$empty")//map是否为空:false
//判断是否包含该键值对
var containsKey = map.containsKey("一月")
println("map是否包含一月:$containsKey")//map是否包含一月:true
//判断是否包含该值
var containsValue = map.containsValue(5)
println("map是否包含值为5:$containsValue")//map是否包含值为5:false
//获取迭代器
var iterator = map.iterator()
println(iterator.next())//一月=1
//通过
var str = map["二月"]
println("str=$str")//str=2
}
/**
* 可变映射map
*/
fun main(){
//Pair方式初始化
val mutableMap:MutableMap<String,Int> = mutableMapOf(Pair("一月",1),Pair("二月",2),Pair("三月",3),Pair("四月",4))
printMap(mutableMap)//一月=1 二月=2 三月=3 四月=4
//添加元素(末尾添加)
mutableMap.put("五月",5)
mutableMap.put("六月",6)
printMap(mutableMap)//一月=1 二月=2 三月=3 四月=4 五月=5 六月=6
//修改指定索引位置上的值
mutableMap.set("五月",8)
mutableMap["六月"] = 9
printMap(mutableMap)//一月=1 二月=2 三月=3 四月=4 五月=8 六月=9
//移除指定元素
mutableMap.remove("三月")
printMap(mutableMap)//一月=1 二月=2 四月=4 五月=8 六月=9
//替换值
mutableMap.replace("五月",5)
printMap(mutableMap)//一月=1 二月=2 四月=4 五月=5 六月=9
}
fun printMap(mutableMap:MutableMap<String,Int>){
for (item in mutableMap){
print("$item ")
}
println()
}
遍历方式
/**
* 集合遍历
*/
fun main(){
val mutableList:MutableList<String> = mutableListOf("一月","二月","三月","四月")
//for in遍历方式
for (item in mutableList){
print("$item ")//一月 二月 三月 四月
}
println()
val iterator = mutableList.iterator()
//迭代器遍历
while (iterator.hasNext()){
print("${iterator.next()} ")//一月 二月 三月 四月
}
println()
//forEach遍历
mutableList.forEach {
print("$it ")//一月 二月 三月 四月
}
println()
//通过下标进行遍历
for (i in mutableList.indices){
print("${mutableList[i]} ")//一月 二月 三月 四月
}
}