Kotlin数据类型_kotlin byte[]

目录

基本数据类型

数值类型

Byte型

Short型

Int型

Long型

Float型

Double型

数值类型的装箱和比较

进制表示

布尔型Boolean

字符型Char

数组Array

字符串String

类型转换

隐式转换

显式转换

---

基本数据类型

数值类型

Byte型

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

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

Short型

        Short数据类型大小为2B，数值范围为 ~

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的声明方式

1. arrayOf(数组成员) 数组成员类型相同或者可以自动隐式提升为同一类型
2. arrayOfNulls(size) 创建指定大小的Null数组
3. 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	退格
\\	打印\
\'	打印'
\"	打印"
\$	打印$（$不转义后需接变量名，模板化）

  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

显式转换