Kotlin是新一代的基于JVM的静态多范式编程语言，功能强大，语法简洁，前面已经做过Kotlin的基本的介绍，今天就来深入的学习一下它的数据类型和运算操作符。

数据类型

与大部分语言不同的是，在Kotlin中一切皆为对象(Everything is an object)，它没有像Java/C++那样，是没有基础数据类型(primitive types)的，都是对象，因此也不会有像Java那样的box和auto box的麻烦。box和autobox对于单独使用基础数据类型时没啥问题，比如一个方法add(Integer)，会进行自动装箱和拆箱。但如果在集合中使用就不一样了，比如array of int与array of Integer是完全不同的数据类型，以及list of int与list of Integer也是完全不同的数据类型，在这些场景里就会相当麻烦，要进行转换，详细可以参考这篇文章。

变量类型的声明

类型是放在变量之后，这样可以先强调变量的名字，后关注其类型，如：

1
2
3
4
5

var count: Int
var message: String
fun double(x: Int): Int {
      return x + x
}

类型推断

虽然Kotlin是静态强类型语言，也就是说在编译的时候，编译器必须知道你的数据是什么类型的，这与Java和C++等是一样的，但并不意味着你必须为每个变量声明它的类型。变量的声明，是告诉编译器有一个什么类型的变量，以及叫什么，就比如在函数中的参数列表，就是变量的声明；而变量的定义，则是在声明的同时，要给变量赋值。

那么，当定义变量的时候，编译器是能够直接推断出来它的类型的，这个时候就可以省去类型的声明，Kotlin语言力求简洁，凡是能推断出变量的类型时都可以省去类型的声明，如定义变量的时候，如在lambda中，或者在函数的返回值中。

1
2

val PI = 3.14 // Double
val PI: Double = 3.14 // 与上面的效果一样

数字类型(Numbers)

数字类型与大部分语言一样，特别的，它与Java语言是一样的，都是有符号的，即数字最高数位代表符号。

整数

与Java语言一样，有四大整数具体类型，8位的Byte，16位的Short，32位的Int以及64位的Long。它们的范围如下：

当然了，每个类型都有其最大值和最小值的常量可以直接引用，不用自己手动写。另外需要注意的是非10进制的字面常量都是二的补码形式，并不是直观的二进制，详细的可以参考另外一篇文章。

浮点数

有Float和Double，它们的定义如下：

字面常量(Literals)

字面常量是指直接写在代码中的数字，默认的是Int和Double，如果需要指定类型，可以用标记或者给变量指定类型，如：

1
2
3
4
5
6

val one = 1 // Int
val threeBillion = 3000000000 // Long, exceeding Int, so it is Long
val aLong = 1L // mark it as Long
val oneByte: Byte = 1 // Byte
val e = 2.7182818284 // Double
val eFloat = 2.7182818284f // Float, actual value is 2.7182817

常见的语法糖：

• 浮点数可以用乘方形式如123.5e10
• 可以下划线(underscore)来加强可读性，如1_000_000
• 16进制用0x打头，如0xFF_AB
• 二进制用0b打头，如0b1101_1111

布尔类型(Booleans)

字符类型(Characters)

用两个单引号来表示，如val ch = ‘ ’

需要注意因为字符是对象，所以不能直接与整数进行比较，需要转化为整数，这点不像Java，在Java中字符是可以直接与整数比较的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

    val map = CharArray(26)
    var index = 0
    for (ch in key) {
        if (!ch.isLetter()) {
            continue
        }
        if (map[ch - 'a'].toInt() == 0) {
            map[ch - 'a'] = 'a' + index
            index++
        }
    }

    return message.map { if (it.isLetter()) map[it - 'a'] else it }
                .joinToString("")

字符串类型(Strings)

可以视为字符的数组，是一个不可变对象(immutable object)，用两个双引号来表示，如

1

val message = "Hello, world"

字符串拼接用加号+：

1
2

val name = "John"
val message = "Hello" + name

当然了，直接用加号拼接效率不好，一般情况下可以直接用字符串模板更好一些。

字符串模板

这是一个强大且方便的内置功能，相当于简化版本的String.format，可以在字符串用美元符$来引用一个变量的值，如果是有方法调用或者运算或者成员引用等情况可以加花括号：

1
2
3

val name = "John"
val message = "Hello, $name"
println("Length is ${name.length}")

字符遍历

与Java不同的是，字符串在Kotlin里面更像是字符数组，或者说一个列表，因此可以直接遍历：

1
2
3
4

val mesage = "The quick fox jumps over the lazy dog"
for (ch in message) {
     println(ch)
}

in是一个强大的操作符，可以用于集合的遍历。另外，字符串可以像列表一样进行函数式的操作，如判断是否包含某个字符：

1
2
3

if (message.any {it == ch}) {
   println("$ch is in $message")
}

数组类型(Arrays)

数组Array是一个具体类型为T的数组，这是通用的数组，另外还有一种就是基本数组类型数组，我们分别来看一下

通用对象数组 Array<T>

这是适用于所有对象的数组，有两种构造方式，一是通过arrayOf()，直接传入数组的具体值，另外就是用构造方法Array(size)

1
2
3
4
5

val heights = arrayOf(240, 360, 480, 640)
val classes = arrayOf("John", "Harden", "Kevin", "Stephen")
val guards: Array<String> = Array(5)
guards[0] = "Stephen"
guards[1] = "Kevin"

还有一种用lambda方式来构造数组，可以非常方便的实现数组的定义：

1
2

val asc = Array(5) { i -> (i * i).toString() }
// asc = ["0", "1", "4", "9", "16"]

需要注意的是这里的类型T都是对象。但其实，对于基础类型的数组，如果都box成为对象效率并不高，虽然Kotlin中并没有真的基础数据类型，但涉及到数组这种批量的数据时，使用基础类型能提升很大的效率，因此还有专门用于基础类型的数组类型。

基础类型数组 IntArray和FloatArray

其实有很多，基础的类型都有IntArray, ByteArray, ShortArray, FloatArray, DoubleArray。而且需要注意的是Array<Int>与IntArray是两个数组类型，它们并不一样，这个区别与Java中的Integer[]和int[]是类似的。而且IntArray与Array<T>也没什么关系，也不是什么继承关系。但是它们表现出来的使用方法是一样的。

1
2
3
4

val heights = intArrayOf(240, 360, 480, 640)
val squares = IntArray(5) { i -> i * i } // [0, 1, 4, 9, 16]
val arr = IntArray(5) { 42 } // [42, 42, 42, 42, 42]
val bundle = arrayOf(intArrayOf(1080, 720), intArrayOf(1920, 1080)) // bundle type is Array<IntArray>

运算操作符

运算操作符与大部分语言是一样的。

算术运算符

也即是常规的算术操作符，+(加) -(减）*(乘) /(除) %(取模)，这些都是二元操作符，也就是需要两个操作数才能使用。

还有单元操作符，如自增++自减–，当然也分前置和后置，区别与Java/C++中一样。

操作符与赋值符=可以配合一起使用，如a += b等同于a = a + b，a /= c等同于 a = a / c

逻辑运算符

双元操作符: && 逻辑与，|| 逻辑或，它们的操作数必须 是布尔型，且返回值也是布尔。

与其他语言一样，这两个操作符是short-circiut的或者说是lazy的，也即a && b，如果a是false，那就不去管b了，因为不影响结果；a || b也一样，如果a是true就不去管b了。

还有单元操作符! 逻辑非。一个有意思的地方在于，逻辑非可以与一些操作符合起来使用，而不是直接写在表达式之外，比如，下面两种写法等效：

1
2
3
4

if (!(a in asc)) {...}
if (a !in asc) {...}
if (b !is Array) {...}
if (!(b is Array)) {...}

位运算符

位运算符比较特殊，与大部分语言不一样。

移位

按位逻辑运算

这些操作符看起来可能比较怪，然后更怪异的是位运算操作符不能与赋值符=一起使用，只能这样写：

1
2

a = a or b
c = c xor (1 shl 3)

事实上位运算不是操作符，它们是一种函数，叫做infix函数，简写了把括号省略了，看起来就像操作符一样，但它们并不是操作符。

运算符重载

与C++中的运算符重载类似，Kotlin中支持运算符重载，本质上它们都是对象定义的方法，但支持重载为运算符。

比如说加法，a + b，可以写成方法调用的形式a.plus(b)；b or c等同于b.or©，!a等同于a.not()。

运算符的优先级

尽管是有默认的优先级的，但强烈建议使用括号以减少歧义和增强可读性，更可以避免一些难以察觉的Bug。

参考资料

• Basic types
• Using Bitwise Operators in Kotlin
• Kotlin Bitwise and Bitshift Operations
• Kotlin Operators
• Kotlin - Operators
• Kotlin Operators