Kotlin——初级篇（三）：数据类型详解

时间 2019-11-09

标签 kotlin 初级数据类型详解繁體版

原文原文链接

任意一种开发语言都有其数据类型，而且数据类型对于一门开发语言来讲是最基本的构成，同时也是最基础的语法。固然，Kotlin也不例外。Kotlin的数据类型和Java是大体相同的，可是他们的写法不一样，而且类型之间的转换也存在着差别。下面为你们详细说明并举例。git

1、数值类型

一、Kotlin中的数字的内置类型（接近与Java），其关键字为：github

Byte=> 字节 => 8位

Short => 短整型 => 16位

Int => 整型 => 32位

Long => 长整型 => 64位

Float => 浮点型 => 32位

Double => 双精度浮点型 => 64位

例：编程

var a: Byte = 2
var b: Short = 2
var c: Int = 2
var d: Long = 2L         //长整型由大写字母L标记
var e: Float = 2f        //单精度浮点型由小写字母f或大写字符F标记
var f: Double = 2.0
println(" a => $a \n b => $b \n c => $c \n d => $d \n e => $e \n f => $f);

输出结果为：数组

a => 2 
b => 2 
c => 2 
d => 2 
e => 2.0 
f => 2.0

二、进制数缓存

二进制数

八进制数（Kotlin不支持）

十进制数

十六进制数

例：编程语言

var g = 0x0F            //十六进制数
var h = 0b00001011      //二进制数
var k = 123             //十进制数
// ps：Kotlin不支持八进制数
println(" g => $g \n h => $h \n k => $k);

输出结果为：函数

g => 15 
h => 11 
k => 123

三、数字类型字面常量的下划线学习

做用：分割数字进行分组，使数字常量更易读this

例：code

val oneMillion = 1_000_000
val creditCardNumber = 1234_5678_9012_3456L
val socialSecurityNumber = 999_99_9999L
val hexBytes = 0xFF_EC_DE_5E
val bytes = 0b11010010_01101001_10010100_10010010

println("oneMillion => $oneMillion")
println("creditCardNumber => $creditCardNumber")
println("socialSecurityNumber => $socialSecurityNumber")
println("hexBytes => $hexBytes")
println("bytes => $bytes")

输出结果为：

oneMillion => 1000000
creditCardNumber => 1234567890123456
socialSecurityNumber => 999999999
hexBytes => 4293713502
bytes => 3530134674

四、装箱与拆箱

装箱与拆箱

在Kotlin中，存在数字的装箱，可是不存在拆箱。由于Kotlin是没有基本数据类型的，Kotlin是万般皆对象的原则。故不存在和Java中的相似int是数据类型，Integer是整型的引用类型。

在Kotlin中要实现装箱操做。首先要了解可空引用。即相似Int?(只限数值类型)这样的。

例：

val numValue: Int = 123
//装箱的过程，其实装箱以后其值是没有变化的
val numValueBox: Int? = numValue
println("装箱后： numValueBox => $numValueBox")

输出结果为：

装箱后： numValueBox => 123

两个数值的比较

判断两个数值是否相等（==）,判断两个数值在内存中的地址是否相等（===）,其实上面的装箱操做以后其内存中的地址根据其数据类型的数值范围而定。

例：

val numValue: Int = 128    
val numValueBox: Int? = numValue

/*
    比较两个数字
 */
var result: Boolean
result = numValue == numValueBox
println("numValue == numValueBox => $result")  // => true,其值是相等的

result = numValue === numValueBox
/*
  上面定义的变量是Int类型，大于127其内存地址不一样，反之则相同。
  这是`kotlin`的缓存策略致使的，而缓存的范围是` -128 ~ 127 `。
  故，下面的打印为false
*/
println("numValue === numValueBox => $result")

输出结果为：

numValue == numValueBox => true
numValue === numValueBox => false

Ps:各位能够试试将变量numValue的值改成在-128 ~ 127这个区间的数字试试

五、转换

显式转换

较小的类型不会被隐式转换为更大的类型，故而系统提供了显式转换。提供的显式转换方法以下：

toByte() => 转换为字节型

toShort() => 转换为短整型

toInt() => 转换为整型

toLong() => 转换为长整型

toFloat() => 转换为浮点型

toDouble() => 转换为双精度浮点型

toChar() => 转换为字符型

toString() => 转换为字符串型

例：

var numA: Int = 97
println(numA.toByte())
println(numA.toShort())
println(numA.toInt())
println(numA.toLong())
println(numA.toFloat())
println(numA.toDouble())
println(numA.toChar())
println(numA.toString())

输出结果为：

隐式转换

类型是从上下文推断出来的，即算术运算则被重载为适当的转换

例：

// 30L + 12 -> Long + Int => Long
val num = 30L + 12
print(num)

输出结果为：

六、位运算符

Kotlin中对于按位操做，和Java是有很大的差异的。Kotlin中没有特殊的字符，可是只能命名为能够以中缀形式调用的函数，下列是按位操做的完整列表(仅适用于整形（Int）和长整形（Long）)：

shl(bits) => 有符号向左移 (相似Java的<<)

shr(bits) => 有符号向右移 (相似Java的>>)

ushr(bits) => 无符号向右移 (相似Java的>>>)

and(bits) => 位运算符 and (同Java中的按位与)

or(bits) => 位运算符 or (同Java中的按位或)

xor(bits) => 位运算符 xor (同Java中的按位异或)

inv() => 位运算符按位取反 (同Java中的按位取反)

下面附上Kotlin中关于位操做符的源码：

/** Shifts this value left by [bits]. */
public infix fun shl(bitCount: Int): Int
/** Shifts this value right by [bits], filling the leftmost bits with copies of the sign bit. */
public infix fun shr(bitCount: Int): Int
/** Shifts this value right by [bits], filling the leftmost bits with zeros. */
public infix fun ushr(bitCount: Int): Int
/** Performs a bitwise AND operation between the two values. */
public infix fun and(other: Int): Int
/** Performs a bitwise OR operation between the two values. */
public infix fun or(other: Int): Int
/** Performs a bitwise XOR operation between the two values. */
public infix fun xor(other: Int): Int
/** Inverts the bits in this value. */
public fun inv(): Int

例：

/*
    位运算符
    支持序列以下：shl、shr、ushr、and、or、xor
 */
var operaNum: Int = 4

var shlOperaNum = operaNum shl(2)
var shrOperaNum = operaNum shr(2)
var ushrOperaNum = operaNum ushr(2)
var andOperaNum = operaNum and(2)
var orOperaNum = operaNum or(2)
var xorOperaNum = operaNum xor(2)
var invOperaNum = operaNum.inv()

println("shlOperaNum => $shlOperaNum \n " +
        "shrOperaNum => $shrOperaNum \n " +
        "ushrOperaNum => $ushrOperaNum \n " +
        "andOperaNum => $andOperaNum \n " +
        "orOperaNum => $orOperaNum \n " +
        "xorOperaNum => $xorOperaNum \n " +
        "invOperaNum => $invOperaNum")

输出结果为：

shlOperaNum => 16 
shrOperaNum => 1 
ushrOperaNum => 1 
andOperaNum => 0 
orOperaNum => 6 
xorOperaNum => 6 
invOperaNum => -5

2、布尔类型（Boolean）

一、关键字

Boolean关键字表示布尔类型，而且其值有true和false

例：

var isNum: Boolean
isNum = false
println("isNum => $isNum")

输出结果为：

isNum => false

二、逻辑操做符（与Java相同）

' || ' => 逻辑或（或者）

' && ' => 逻辑与（而且）

' ! ' => 逻辑非（取反）

例：

/*
    操做运算符
    ' || ' => 逻辑或（或者）
    ' && ' => 逻辑与（而且）
    ' ! ' => 逻辑非（取反）
 */
var a: Boolean = false
var b: Boolean = true
var result: Boolean

/* 逻辑或操做 */
if (a || b){
    result = a || b
    println("a || b => $result")
}

/* 逻辑与操做 */
if (a && b){
    result = a && b
    println("a && b => $result")
}

/* 逻辑非操做 */
result = !a
println("!a => $result")

result = !b
println("!b => $result")

输出结果为：

isNum => false
a || b => true
!a => true
!b => false

3、字符型（Char）

一、关键字

Char为表示字符型，字符变量用单引号（‘ ’）表示。而且不能直接视为数字，不过能够显式转换为数字。

例：

var char1: Char
char = 'a'
//char1 = 1        => 这句代码会直接出错
println("char1 => $char1")

输出结果为：

char1 => a

二、显示转换为其余类型

字符型的变量不只能够转换为数字，同时也可转换为其余类型

例：

var var1 = char1.toByte()
var var2 = char1.toInt()
var var3 = char1.toString()
var var4 = char1.toFloat()
var var5 = char1.toShort()
println("var1 => $var1 \n var2 => $var2 \n var3 => $var3 \n var4 => $var4 \n var5 => $var5")

输出结果为：

var1 => 97 
var2 => 97 
var3 => a 
var4 => 97.0 
var5 => 97

PS:除了能够转换类型外，当变量为英文字母时还支持大小写转换。

例：

/*
   当字符变量为英文字母时，大小写的转换
*/
var charA: Char = 'a'
var charB: Char = 'B'
var charNum: Char = '1'
var result: Char

// 转换为大写
result = charA.toUpperCase() 
println("result => $result")

// 转换为小写
result = charB.toLowerCase()
println("result => $result")

//当字符变量不为英文字母时，转换无效
result = charNum.toLowerCase()
println("result => $result")

输出结果为：

result => A
result => b
result => 1

三、字符转义
同Java同样，使用某些特殊的字符时，要使用转义。下列是支持的转义序列：

\t => 表示制表符

\n => 表示换行符

\b => 表示退格键（键盘上的Back建）

\r => 表示键盘上的Enter键

\\ => 表示反斜杠

\' => 表示单引号

\" => 表示双引号

\$ => 表示美圆符号，若是不转义在kotlin中就表示变量的引用了

其余的任何字符请使用Unicode转义序列语法。例：'\uFF00'

例：

println("\n  换行符")
println("\t  制表符")
println(" \b  退格键")
println("\r  Enter键一样换行")
println('\\')
println('\'')
println('\"')
println('\$')
println('\uFF01')

输出结果为：

换行符
     制表符

 退格键
 Enter键一样换行
\
'
"
$
！

4、字符串类型（String）

一、关键字

String表示字符串类型。其是不可变的。因此字符串的元素能够经过索引操做的字符：str[index]来访问。可使用for循环迭代字符串：
其中str[index]中的str为要目标字符串，index为索引

例：

val str: String = "kotlin"
println("str => $str")

//迭代
for (s in str){
    print(s)
    print("\t")
}

输出结果为：

str => kotlin
k   o   t   l   i   n

二、字符串字面量

在Kotlin中，字符串字面量有两种类型：

包含转义字符的字符串转义包括（\t、\n等）,不包含转义字符串的也同属此类型

包含任意字符的字符串由三重引号（""" .... """）表示

例：

// 类型1：
var str1: String = "hello\t\tkotlin"
println(str1)
str1 = "hello kotlin"
println(str1)

// 类型2：
val str2 = """ fun main(args: Array<String>){
    println("我是三重引号引用的字符串，我能够包含任意字符")
    } """
println(str2)

输出结果为：

hello       kotlin
hello kotlin
fun main(args: Array<String>){
    println("我是三重引号引用的字符串，我能够包含任意字符")
    }

PS：可使用trimMargin()函数删除前导空格，默认使用符号(|)做为距前缀，固然也可使用其余字符。例：右尖括号（>）、左尖括号（<）等。

例：

val str3: String = """
    > I`m like Kotlin .
    > I`m like Java .
    > I`m like Android .
    > I`m like React-Native.
""".trimMargin(">")
println(str3)

输出结果为：

I`m like Kotlin .
 I`m like Java .
 I`m like Android .
 I`m like React-Native.

三、字符串模板

使用字符串模板的符号为（$）。在$符号后面加上变量名或大括号中的表达式

例：

val text1: String = "我来了！"
var text2: String = "$text1 kotlin"
var text3: String = "$text2 ${text1.length} 哈哈！！！！"
println(text1)
println(text2)
println(text3)

输出结果为：

我来了！
我来了！ kotlin
我来了！ kotlin 4 哈哈！！！！

5、数组型（Array）

Kotlin中数组由Array<T>表示，能够去看看源码实现，里面就几个方法

建立数组的3个函数

arrayOf()

arrayOfNulls()

工厂函数（Array()）

一、arrayOf()

建立一个数组，参数是一个可变参数的泛型对象

例：

var arr1 = arrayOf(1,2,3,4,5) //等价于[1,2,3,4,5]
for (v in arr1){
    print(v)
    print("\t")
}

var arr2 = arrayOf("0","2","3",'a',32.3f)
for (v in arr2){
    print(v)
    print("\t")
}

输出结果为：

1   2   3   4   5   
0   2   3   a   32.3

二、arrayOfNulls()

用于建立一个指定数据类型且能够为空元素的给定元素个数的数组

例：

var arr3 = arrayOfNulls<Int>(3)

//如若不予数组赋值则arr3[0]、arr3[1]、arr3[2]皆为null
for(v in arr3){
    print(v)
    print("\t")
}

println()

//为数组arr3赋值
arr3[0] = 10
arr3[1] = 20
arr3[2] = 30

for(v in arr3){
    print(v)
    print("\t")
}

输出结果为：

null    null    null    
10  20  30

三、工厂函数

使用一个工厂函数Array()，它使用数组大小和返回给定其索引的每一个数组元素的初始值的函数。

Array() => 第一个参数表示数组元素的个数，第二个参数则为使用其元素下标组成的表达式

例：

var arr4 = Array(5,{index -> (index * 2).toString() })
for (v in arr4){
    print(v)
    print("\t")
}

输出结果为：

0   2   4   6   8

四、原始类型数组

Kotlin还有专门的类来表示原始类型的数组，没有装箱开销，它们分别是：

ByteArray => 表示字节型数组

ShortArray => 表示短整型数组

IntArray => 表示整型数组

LongArray => 表示长整型数组

BooleanArray => 表示布尔型数组

CharArray => 表示字符型数组

FloatArray => 表示浮点型数组

DoubleArray => 表示双精度浮点型数组

PS: Kotlin中不支持字符串类型这种原始类型数组，能够看源码Arrays.kt这个类中并无字符串数组的声明。而源码中StringArray.kt这个类并非声明字符串型数组的。

下面的例子只演示了几种，其余的相似。
例：

var intArr: IntArray = intArrayOf(1,2,3,4,5)
for (number in intArr){
    print(number)
    print("\t")
}

println()

var charArr: CharArray = charArrayOf('a','1','b','c','3','d')
for (char in charArr){
    print(char)
    print("\t")
}

println()

var longArr: LongArray = longArrayOf(12L,1254L,123L,111L)
for (long in longArr){
    print(long)
    print("\t")
}

输出结果为：

1   2   3   4   5   
a   1   b   c   3   d   
12  1254   123  111

6、尾语

无论对于任何一门编程语言，都有其数据类型，而数据类型是学习一门编程语言的基础。因此请各位大佬认真而且跟着代码敲一遍。特别是数组和字符串类型这两个点。

源代码

若是各位大佬看了以后感受还阔以，就请各位大佬随便star一下，您的关注是我最大的动力。
个人我的博客：Jetictors
个人掘金：Jetictors
Github：Jteictors

Kotlin——初级篇（三）：数据类型详解

目录

1、数值类型

2、布尔类型（Boolean）

3、字符型（Char）

4、字符串类型（String）

5、数组型（Array）

6、尾语

欢迎各位大佬进群共同研究、探索

QQ群号：497071402