Kotlin编程:基础数据类型

作者: 麻辣阁 分类: kotlin 发布时间: 2018-11-30 11:52

字符

字符类型 Char 用单引号, 不用双引号 — 双引号是字符串.

转义字符:

  • \t,制表符
  • \b,退格符
  • \n,换行符
  • \r,换行符
  • \',单引号
  • \',双引号
  • \\,反斜线
  • \$,美元符号 — $ 可以在字符串中表示后面跟的为变量或表达式, 用来构造字符串模板, 所以需要转义.其他很多语言中不需要转义.
  • \u, Unicode转义序列
fun main(args: Array<String>) {
    /* * 打印如下小诗歌
        Rain雨
    Rain is falling all around, 雨儿在到处降落,
    It falls on field and tree, 它落在田野和树梢,
    It rains on the umbrella here, 它落在这边的雨伞上,
    And on the ships at sea. 又落在航行海上的船只。
     */
    println("\t\t\t\tRain雨")
    println("\tRain is falling all around, 雨儿在到处降落,")
    println("\tIt falls on field and tree, 它落在田野和树梢,")
    println("\tIt rains on the umbrella here, 它落在这边的雨伞上,")
    println("\tAnd on the ships at sea. 又落在航行海上的船只。")

    //打印阴阳符号 ☯
    var yinyang = '\u262F'
    println(yinyang)
}
/* 打印效果
                Rain雨
    Rain is falling all around, 雨儿在到处降落,
    It falls on field and tree, 它落在田野和树梢,
    It rains on the umbrella here, 它落在这边的雨伞上,
    And on the ships at sea. 又落在航行海上的船只。
☯
 */

数值

Kotlin内置数值类型:

大类 小类 位宽
整数 Long 64
整数 Int 32
整数 Short 16
整数 Byte 8
浮点数 Double 64
浮点数 Float 32

数值类型之间不存在隐式的类型转换, 数值表达式可以看作一个数值, 有对应的数值类型.

fun main(args: Array<String>) {
    var numLong:Long = 1

    //var numInt:Int = numLong //Error:(3, 22) Kotlin: Type mismatch: inferred type is Long but Int was expected

    //var numInt:Int = numLong + 1  //Error:(4, 22) Kotlin: Type mismatch: inferred type is Long but Int was expected

    var numTemp = numLong + 1 //ok, numTemp 表达式的类型都是 Long

    var numInt: Int = 15 //ok, Int类型

    //var numLong2 : Long = numInt + 1 //Error, 表达式的值类型为 Int

    var numLong2 : Long = numInt + 1L  //OK, 表达式的值类型为 Long
}

类型转换

Kotlin中的数值都是对象.当类型不同时, 可以调用数值对象的类型转换方法.

字符类型 Char不是数值, 但可以和数值之间相互转换, 需要注意 char 类型的范围, 有可能不会得到你的计算结果但也不会报错.

  • toLong()
  • toInt()
  • toShort()
  • toByte()
  • toDouble()
  • toFloat()
  • toChar()
fun main(args: Array<String>) {
    var letterChar:Char = 's'
    var ageInt:Int = letterChar.toInt() // ok
    var counterLong:Long = 324324324324
    letterChar = counterLong.toChar()
    counterLong = letterChar.toLong()
    println(letterChar) //珤
    println(counterLong) //29668
    letterChar = 'Z'
    counterLong = letterChar.toLong()
    println(counterLong) //90
}

数值的字面值表示

1.整数

  • 16进制: 0x开头,0x0F
  • 2进制: 0b开头,0b00001011
  • 8进制:不支持
  • 10进制:默认Int,可以在数值结尾加大写字母L表示Long类型数值, 1L

2.浮点数

  • 默认为Double类型, 支持科学计数法: 123.5, 123.5e10
  • Float类型值: 结尾加 f或者 F, 123.5F, 貌似不支持科学计数法
  • 没太多理由指定和使用 Float 类型
fun main(args: Array<String>) {
    var tempL:Long = 123L

    // 整数不支持科学计数法
    //var temp2L:Int = 123e5 //Error:(3, 22) Kotlin: The floating-point literal does not conform to the expected type Int

    var tempDouble: Double = 12.5e5 //OK
    //var tempFloat: Float = 12.5e5 //Error:(8, 28) Kotlin: The floating-point literal does not conform to the expected type Float
    var tempFloat: Float = 12.5e5.toFloat() //OK
}

3.支持在字面值中加入下划线,以提高可读性

注意下划线不要加在小数点后!

fun main(args: Array<String>) {
    val oneBigInt = 100_0_33343423_99L
    var oneHex = 0xFF_FF_FF_e_99
    var oneByte =0b11111_00_1_10_0101010101_11
    var oneDouble = 1.34_999_32423_11e5
    println(oneDouble) //134999.3242311
    //var oneFloat = 3._4323432_11f //Error:(7, 22) Kotlin: Unresolved reference: _4323432_11f
    var oneFloat = 3.1_4323432_11f 
    println(oneFloat)//3.1432343
}

布尔类型

Boolean 类型用来表示布尔值, 有两个可能的值: true 和 false.

布尔值的内建运算符有
|| – 或运算
&& – 与运算
! – 非运算

比较运算

  • 相等判断: a == b 以及 a != b
  • 比较操作符: a < b , a > b , a <= b , a >= b
  • 数值范围(Range) 的创建, 以及范围检查: a..b , x in a..b , x !in a..b
fun main(args: Array<String>) {
    // ==, !=
    var a:Int = 1
    var b:Long = 1
    var c:Double =1.0
    var d:Float = 1.0f
    //Error: Operator '==' cannot be applied to 'Int' and 'Long'
//    println(a == b)
//    println(b == c)
//    println(c == d)
    println(a == b.toInt())  //true
    println(b.toDouble() == c)  //true
    println(c == d.toDouble())  //true
    //println(c != d) //Error:(14, 13) Kotlin: Operator '!=' cannot be applied to 'Double' and 'Float'
}

注意相同类型才能比较.

fun main(args: Array<String>) {
    println(1 in 1..10) //true
    println(10 in 1..10) //true
    println(1.0 in 1.0 ..10.0) //true
    println(10.9 in 1.0 ..10.9) //true

    println(1 in 1.0 ..10.0) //true , Warning:(6, 13) Kotlin: 'contains(Int): Boolean' is deprecated. This `contains` operation mixing integer and floating point arguments has ambiguous semantics and is going to be removed.

    println(1.0 in 1..10) // true, Warning:(7, 17) Kotlin: 'contains(Double): Boolean' is deprecated. This `contains` operation mixing integer and floating point arguments has ambiguous semantics and is going to be removed.
}

a..b 包含了上下界,并且 c in a..b 这种表达中, a,b,c 三者要求都是同一类型.

数组类型

数组类型为 Array, 默认为 Int数组, 如果需要指定其他类型数组, 可以用如下方式, 将数组类型放在尖括号中:

  • Array<Long>: Long 数组
  • Array<Double>:Double 数组
  • Array<Char>: 字符数组

数组创建需要调用工厂函数 arrayOf(), 这是 Kotlin 标准库函数.

fun main(args: Array<String>) {
    var a = arrayOf(1,2,3) //ok, Int类型的数组
    var a2 : Array<Long> = arrayOf(1,2,3) // Long类型数组
    println(a2) // [Ljava.lang.Long;@610455d6, 并不会打印整个数组
    println(a2[0]) //1
    var b = arrayOf(1.0, 2) //ok ,数组类型为  Any
    var c = arrayOf('d','e',10.5) // ok, Any 类型的数组
    var d = arrayOf('g','h') //ok, char类型的数组
}

创建数组对象会增加内存开销降低程序性能, Kotlin提供了特定类型的数组直接装基础数值类型来提高程序性能降低程序的内存开销.这些数组类型包括
DoubleArray,LongArray,CharArray等, 这些类型和 Array 没有继承关系, 因此不能用 arrayOf 创建实例, 而是用对应的工厂函数 doubleArrayOf 等创建实例.

fun main(args: Array<String>) {
    var x:IntArray = intArrayOf(1,2,3)
    x[0] += 5
    println(x[0]) //6
}

发表评论

电子邮件地址不会被公开。 必填项已用*标注