Kotlin数据类型

ysxAshore

已于 2022-07-07 11:33:34 修改

阅读量1.3k

点赞数 2

分类专栏： Android_Kotlin 文章标签： kotlin android java

于 2022-07-07 00:05:38 首次发布

本文链接：https://blog.csdn.net/weixin_53966032/article/details/125646347

版权

Android_Kotlin 专栏收录该内容

15 篇文章 2 订阅

订阅专栏

基本数据类型

数值类型

Byte型

Kotlin中的Byte型与Java中的Byte型类似，均为1B长，数值范围为-128~127

也和Java的内存机制一致（均用JVM机制），Kotlin中-128~127也是直接在内存中有对应的缓存，这对于后面的==和===比较十分关键

Short型

Short数据类型大小为2B，数值范围为 $-2^{15}$ ~ $2^{15}-1$

Int型

Int型是最为常用的数据类型，占4B，Kotlin中默认整数即为Int型

Long型

Long型存储的数据范围更大，一般如果不指定类型存储时，需要用Long存储，需在数值后加L结尾
var a: Long = 123
var b= 456L

Float型

Float型存储4字节的浮点数，Float型的存储理念与C++类似，（1符号位+8指数位+23尾数位），Kotlin中浮点数默认是Double型，一般若需指定为Float型，需在数末尾加f或F

Double型

Double型存储了8字节的数据，（1+11+52）

println(Byte.MAX_VALUE.toString()+"   "+ Byte.MIN_VALUE)
println(Short.MAX_VALUE.toString()+"   "+ Short.MIN_VALUE)
println(Int.MAX_VALUE.toString()+"   "+ Int.MIN_VALUE)
println(Long.MAX_VALUE.toString()+"   "+ Long.MIN_VALUE)
println(Float.MAX_VALUE.toString()+"   "+ Float.MIN_VALUE)
println(Double.MAX_VALUE.toString()+"   "+ Double.MIN_VALUE)

数值类型的装箱和比较

装箱和拆箱这个思想是在Java中的，这是因为在Java中既有基本类型，如int，也有封装类型如Integer。但是Kotlin中“一切都是对象”，并不存在基本类型这一说（前面讲基本类型只是为了方便），所以只存在将数字封装为对象——装箱，而不存在将对象拆为数值类型——拆箱。

在Kotlin中实现装箱工作是通过可空数据类型来实现的 var/val 变量名类型？=值
var s:Int ?=123
Kotlin中的比较有==和===，==是比较值是否相等，===是比较地址是否相等，有以下几种情况
var a=129;
var b:Int =a;
var c:Int =a;
println(b==a)//true
println(c==b)//true
println(a===b)//true
println(b===c)//true
//直接赋值，并不涉及到装箱，虽然在Kotlin中a是对象，但是在其执行的字节码内，a,b,c均为一普通的
//数值
var a:Int ?=129;
var b: Int? =a;
var c: Int? =a;
println(b==a)//true
println(c==b)//true
println(a===b)//true
println(b===c)//true
//这里a,b,c均装箱，在其字节码中也视为对象，对象的直接赋值，故a,b,c均指向同一个对象
var a:Int =129;
var b: Int? =a;
var c: Int? =a;
println(b==a)//true
println(c==b)//true
println(a===b)//true
println(b===c)//false
//这里b,c均装箱，故在字节码中b,c均被视为对象处理，按赋值次序，a先赋给b，故b直接利用现存的数据
//129即可，不需要再创建内存，而再赋给c，则需要再重新申请内存存储129，故b和c内存地址不同
var a:Int =123;
var b: Int? =a;
var c: Int? =a;
println(b==a)//true
println(c==b)//true
println(a===b)//true
println(b===c)//true
//123在内部有缓存，始终不需要再次创建
var a:Int =129;
var b: Int =a;
var c: Int? =a;
println(b==a)//true
println(c==b)//true
println(a===b)//true
println(b===c)//true
//123只有一次被用作装箱，a与b均在字节码中是数值，而c装箱未曾被装箱过的数，不需要申请内存。
综上，-128~127始终可以重复使用，不需要再申请内存，而装箱只有第一次装箱的变量与被装箱变量==和===均true

进制表示

Kotlin中数有3种进制：二进制 0b 十进制十六进制 0x

且当要表示一些长整数时，可以使用数的字面量表示方法，用下划线来进行任意的分割
var num=1_000_000_12334
println(num)

布尔型Boolean

Boolean型只有两个值 true false，大小为1B

和Java的要求一致，Kotlin中的布尔型也不能实现与其他类型的自动转换，这就要求我们必须在判断条件处必须要写一个逻辑表达式(即可判断真假的式子)

字符型Char

Kotlin采用UTF-8进行编码，占2B，也因此变量名支持中文（不推荐）

Char支持大小写转换 toLowerCase toUpperCase

数组Array

Kotlin中的数组采用Java的Array类构建模板类实现

这里主要介绍Array的声明方式

arrayOf(数组成员) 数组成员类型相同或者可以自动隐式提升为同一类型
arrayOfNulls(size) 创建指定大小的Null数组
Array(size,{index->索引函数}) 或 Array(size) lamda函数{index->}
var list= arrayOf(1,2,3)
println(list)
var myList: Array<Int?> = arrayOfNulls(3);//类型是<int>?>
println(myList)
list=Array(3) { index -> (index * 3) }
for (x in list)
   print("$x ")//字符串模板$变量

字符串String

Kotlin中的String类型与Java中的String类型较为不同

我们从转义字符字面量和成员方法两方面来介绍

1.字面量表示

可以用""，""" "'"表示字符串，前者用的较多，后者主要用来表示长字符串且其内格式不变

2.转义字符

转义字符
\n 换行
\t 制表对齐
\r 回车
\b 退格
\\ 打印\
\' 打印'
\" 打印"
\$
打印$（$不转义后需接变量名，模板化）

转义字符
\n	换行
\t	制表对齐
\r	回车
\b	退格
\\	打印\
\'	打印'
\"	打印"
\$	打印$（$不转义后需接变量名，模板化）

3.String方法

获取元素

first() firstOrNull() first{} firstOrNull{}

last() lastOrNull() last{} lastOrNull{}

first函数在字符串为空或者null时会报错，而firstOrNull不会,会返回null

last函数在字符串为空或者null时会报错，而lastOrNull不会，会返回null

根据其对null处理的特殊，我们一般选择firstOrNull lastOrNull使用且()返回第一个或最后一个元素，而{}则是查找等于给的it的第一个或最后一个元素，有则为其值，无则OrNull返回null，另一个报错
var s="123"
var s1=""
println(s1.first())//报错
println(s.first { it=='3' })//3
println(s.firstOrNull { it=='4' })//null
println(s1.firstOrNull())//null
println(s.last())//3
println(s1.last { it=='3' })//报错
println(s.lastOrNull { it=='4' })//null
println(s.lastOrNull())//3
查找

find{} findLast{}

find{it==} findLast{it==}用于查找元素是否在字符串中出现，若出现返回其值，不出现返回null。其内层是调用了firstOrNull{}和LastOrNull{}的
    var s1="123456"
    var s=""
    println(s1.find { it=='1' })//1
    println(s.find { it=='3' })//null
    println(s1.findLast { it=='7' })//null
    println(s.findLast { it=='我' })//null
indexOf() indexOfFirst{} lastIndexOf() indexOfLast{}

index的()和{}使用并无很大区别，选择哪一种使用均可，均可以返回给定元素的第一次或最后一次出现的索引，均对于不出现的字符返回-1
    var s1="123456"
    var s=""
    println(s1.indexOf('2'))//1
    println(s.indexOfFirst { it=='2' })//-1
    println(s.lastIndexOf('4'))//-1
    println(s1.indexOfLast { it=='4' })//3
替换

replace replaceFirst

replaceBefore replaceAfter

replaceBeforeLast replaceAfterLast

replace(old,new) 用new字符或者字符串替换old字符或字符串

           replace(regex,replace) 用replace字符串替换匹配到regex的部分 regex=Regex(正则表达式字符串)

           replaceFirst(old,new) 替换第一出现的old或者第一次匹配到regex的部分

           replaceBefore(old,new) 找到第一次匹配到old的部分，保留old及之后的原字符串，将new拼接至old前

replaceBeforeLast(old,new) 倒序查找截取之后的拼接,仍保留匹配部分

           replaceAfter(old,new) 与replaceFirst不同的是replaceAfter保留的是old及之前的原字符串，将new拼接至其后

           replaceAfterLast(old,new) 倒序查找截取之前的拼接,仍保留匹配部分
    var s="Sometimes ever, sometimes never"
    println(s.replace('S','s'))//sometimes ever, sometimes never
    println(s.replace("Sometimes","Occasionally"))//Occasionally ever, sometimes never
    println(s.replace(Regex("[re]"),"11"))//Som11tim11s 11v1111, som11tim11s n11v1111
    println(s.replaceBefore("ever","Replace"))//Replace ever, sometimes never
    println(s.replaceBeforeLast("ever","Replace"))//Replaceever
    println(s.replaceAfter("ever","Replace"))//Sometimes everReplace
    println(s.replaceAfterLast("ever","Replace"))//Sometimes ever, sometimes neverReplace
分割

split

split()可以按给定的字符串或字符分割，可以给定多个用逗号间隔，但多个必须类型一致，也可以给定正则表达式进行分割
    var s="123 345-778989909-@@-abc-e#-e"
    println(s.split(' ','-', '#'))//[123, 345, 778989909, @@, abc, e, , e]
    println(s.split(" ","-","@@"))//[123, 345, 778989909, , , abc, e#, e]
    println(s.split(Regex("[- @@]")))//[123, 345, 778989909, , , , abc, e#, e]
截取

subString() subSequence()

subString(beg) subString(beg,end) [beg,end) subString(IntRange(a,b))[a,b]

subSequence(beg,end) subSequence(IntRange())
    var s="Don't let dream just be your dream"
    println(s.substring(4))//t let dream just be your dream
    println(s.substring(3,6))//'t
    println(s.substring(IntRange(3,6)))//'t l
    println(s.subSequence(3,6))//'t
    println(s.subSequence(IntRange(3,6)))//'t l
长度

.length count()

获取重复元素数

count{it==}

反转

reversed()
    var s="You are a part-time lover and a full-time friend."
    println(s.length)//49
    println(s.count())//49
    println(s.count{it=='a'})//5
    println(s.reversed())//.dneirf emit-lluf a dna revol emit-trap a era uoY
其他判断函数

startsWith() endsWith() isEmpty isBlank isNullOrEmpty isNullOrBlank

startsWith(string,beg)判断从beg开始的字符串部分是否是string，默认beg为0

           endsWith(string)判断字符串是否以string结尾

           isEmpty() 当字符串为空串""为true null会报错

           isNullOrEmpty() 当字符串为null或者""为true 等价于 s?.isEmpty()

           isBlank() 当字符串不为""且包含字符串长度个" "时为true null会报错

           isNullOrBlank() 为null或者为isBlank 等价于 s?.isBlank()

类型转换

隐式转换

byte->short->int->long

float->double

显式转换

方法	描述
toByte()	转换成Byte型
toShort()	转换成Short型
toInt()	转换成Int型
toLong()	转换成Long型
toFloat()	转换成Float型
toDouble()	转换成Double型
toChar()	转换成Char型
toString()	转换为String型