Kotlin学习之 3基本数据类型

红太狼 2022-05-27 04:52 191阅读 0赞

# Kotlin 基本数据类型 #

下面来对比学习一下Kotlin和java的基本数据类型吧。

## 一.Kotlin 的基本数值类型 ##

包括 Byte、Short、Int、Long、Float、Double 等。  
其实，Char，Boolean也是Kotlin的基本数据类型，只是不是数值类型而已。

### 1.对比一下java的基本数据类型 ###

byte、char、short、int、long、float、double、boolean（8个）。

这里有一点是要非常注意的，Kotlin中基本数据类型前面必须是大写的，像java中的int在Kotlin中是没有意义的，就像普通字符aa一样的作用，是可以随意使用的

### 还有一点要注意的，Kotlin中所有数据符号的定义只能用var或val ###

比如定义一个Int类型的数据

//在Kotlin中要用代码
    var number=10
    //或者
    var number:Int=10
    
    //如果你像java那样写，就会报错
    Int number=10 //Kotlin不能识别这个语句！
    
    //即使自己的类对象也要用var或val来定义，比如
    var people=People() //注意Kotlin中是没有new这个关键字的！
    
    //上面的var也可以用val来代替，而他们的区别后面再说吧。

是不是涨知识了，意不意外，惊不惊喜，是不是有点坑爹！  
习惯就好！就是不太好习惯！

### 2.Kotlin的基本数据类和位宽： ###

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>位宽度</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Double</td> 
   <td>64</td> 
  </tr> 
  <tr> 
   <td>Float</td> 
   <td>32</td> 
  </tr> 
  <tr> 
   <td>Long</td> 
   <td>64</td> 
  </tr> 
  <tr> 
   <td>Int</td> 
   <td>32</td> 
  </tr> 
  <tr> 
   <td>Short</td> 
   <td>16</td> 
  </tr> 
  <tr> 
   <td>Byte</td> 
   <td>8</td> 
  </tr> 
 </tbody> 
</table>

这个和java是一样样的。

## 二.字面常量 ##

### 1.进制数的字面常量： ###

十进制：123
    长整型以大写的 L 结尾：123L
    16 进制以 0x 开头：0x0F
    2 进制以 0b 开头：0b00001011

注意：8进制不支持，java也没有！  
注意的是Kotlin还是不太灵活，比如只能识别123L，如果L写成小写的就不能识别了。java中是都可以的。

### 2.Kotlin 同时也支持传统符号表示的浮点数值： ###

Doubles 默认写法: 123.5, 123.5e10
    Floats 使用 f 或者 F 后缀：123.5f

这里比较无语的是，Kotlin中浮点数的Float类型可以写成123f或123F，大小写都是可以的。但是长整形只能用大写的L

### 3.Kotlin中的数值支持使用下划线 ###

你可以使用下划线使数字常量更易读：

//Kotlin的下划线在数值中，读取的时候是会被自动忽略的
    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
    
    //你也可以任意搞，都是可以的
    var number=1_22_333_4444_1_0_1_1L
    
    //打印数字，你会发现没有下划线。

## 三.比较两个数字 ##

Kotlin 中没有基础数据类型，只有封装的数字类型，你每定义的一个变量，其实 Kotlin 帮你封装了一个对象，这样可以保证不会出现空指针。  
数字类型也一样，所有在比较两个数字的时候，就有比较数据大小和比较两个对象是否相同的区别了。

在 Kotlin 中，三个等号 === 表示比较对象地址，两个 == 表示比较两个值大小。这个也是和java不同的。

fun main(args: Array<String>) {
        val a: Int = 10000
        println(a === a) // true，值相等，对象地址相等
    
        //经过了装箱，创建了两个不同的对象
        val boxedA: Int? = a
        val anotherBoxedA: Int? = a
    
        //虽然经过了装箱，但是值是相等的，都是10000
        println(boxedA === anotherBoxedA) //  false，值相等，对象地址不一样
        println(boxedA == anotherBoxedA) // true，值相等
    }

这里我把 a 的值换成 100，这里应该跟 Java 中是一样的，在范围是 \[-128, 127\] 之间并不会创建新的对象，boxedA === anotherBoxedA比较输出的都是 true，从 128 开始，比较的结果才为 false。

## 四.类型转换 ##

由于不同的表示方式，较小类型并不是较大类型的子类型，较小的类型不能隐式转换为较大的类型。  
这意味着在不进行显式转换的情况下我们不能把 Byte 型值赋给一个 Int 变量。但是，java中是会自动装换的。

val b: Byte = 1 // OK, 字面值是静态检测的
    val i: Int = b // 错误，如果在java中是没有问题的

我们可以代用其toInt()方法。

val b: Byte = 1 // OK, 字面值是静态检测的
    val i: Int = b.toInt() // OK

每种数据类型都有下面的这些方法，可以转化为其它的类型：

toByte(): Byte
    toShort(): Short
    toInt(): Int
    toLong(): Long
    toFloat(): Float
    toDouble(): Double
    toChar(): Char

这里Byte可以转为Int，Int可以转为Byte，其他的也是一样

有些情况下也是可以使用自动类型转化的，前提是可以根据上下文环境推断出正确的数据类型而且数学操作符会做相应的重载。例如下面是正确的：

val l = 1L + 3 // Long + Int => Long

## 五.位操作符 ##

对于Int和Long类型，还有一系列的位操作符可以使用，分别是：

shl(bits) – 左移位 (Java’s <<)
    shr(bits) – 右移位 (Java’s >>)
    ushr(bits) – 无符号右移位 (Java’s >>>)
    and(bits) – 与
    or(bits) – 或
    xor(bits) – 异或
    inv() – 反向

比如 1左移两位，得到二进制100，换成十进制的数据就是4  
Kotlin的代码体现如下：

package hello                      
    
    fun main(args: Array<String>) {     
         var q: Int = 1  
         q=q shl 2  //左移两位
        println("q="+q) //打印得到q=4
    }

## 六.字符 ##

和 Java 不一样，Kotlin 中的 Char 不能直接和数字操作，Char 必需是单引号 ’ 包含起来的。比如普通字符 ‘0’，’a’。

fun check(c: Char) {
        if (c == 1) { // 错误：类型不兼容,正确的用法是c=='1'
            // ……
        }
    }

字符字面值用单引号括起来: ‘1’。  
特殊字符可以用反斜杠转义。 支持这几个转义序列：\\t、 \\b、\\n、\\r、\\’、\\”、\\ 和 $。  
编码其他字符要用 Unicode 转义序列语法：’\\uFF00’。

我们可以显式把字符转换为 Int 数字：比如把’8’转化为数字8，如果直接把Char类型的’8’转换成Int肯定得不到8的，得到的是数值56，这个和java是一样的，’a’的数值是97

//转换的方法代码
    fun decimalDigitValue(c: Char): Int {
        if (c !in '0'..'9')
            throw IllegalArgumentException("Out of range")
        return c.toInt() - '0'.toInt() // 显式转换为数字
    }

## 七.布尔 ##

布尔用 Boolean 类型表示，它有两个值：true 和 false。

若需要可空引用布尔会被装箱。

内置的布尔运算有：

|| – 短路逻辑或
    && – 短路逻辑与
    !  - 逻辑非

## 八.数组 ##

数组用类 Array 实现，并且还有一个 size 属性及 get 和 set 方法，由于使用 \[\] 重载了 get 和 set 方法，所以我们可以通过下标很方便的获取或者设置数组对应位置的值。

数组的创建两种方式：一种是使用函数arrayOf()；另外一种是使用工厂函数。如下所示，我们分别是两种方式创建了两个数组：

fun main(args: Array<String>) {
        //创建数组：[1,2,3]
        val a = arrayOf(1, 2, 3)
    
        //使用工厂方法，创建数组：[0,2,4]
        val b = Array(3, { i -> (i * 2) })//又是Kotlin的一个特色，i都不用定义就可以用！
    
        //读取数组内容
        println(a[0])    // 输出结果：1
        println(b[1])    // 输出结果：2
    
        a[0]=10
        println(a[0])    // 输出结果：10
    }

如上所述，\[\] 运算符代表调用成员函数 get() 和 set()。

注意: 与 Java 不同的是，Kotlin 中数组是不型变的（invariant）。

除了类Array，还有ByteArray, ShortArray, IntArray，用来表示各个类型的数组数据，省去了装箱操作，因此效率更高，其用法同Array一样：

val x: IntArray = IntArrayOf(1, 2, 3)
    x[0] = x[1] + x[2]

Array就是比其他几种数组类型灵活一些，可以根据你放入的数据类型，来自动转变为对应数组数据类型

## 九.字符串 ##

### 1.字符串的遍历 ###

和 Java 一样，String 是可不变的。方括号 \[\] 语法可以很方便的获取字符串中的某个字符，也可以通过 for 循环来遍历：

var str:String="hello"
    
    //打印所有的字符串
    for (c in str) {
        println(c)
    }
    
    //打印字符串的第一个字符
    println(str[0])

### 2.Kotlin 支持三个引号 “”” 扩起来的字符串，支持多行字符串， ###

比如：

fun main(args: Array<String>) {
        val text = """
        多行字符串
        多行字符串
        """
        println(text)   // 输出有一些前置空格
    }

输出结果：(会自行换行，并且前面会留一些空格)

多行字符串
        多行字符串

#### String 可以通过 trimMargin() 方法来删除多余的空白。 ####

fun main(args: Array<String>) {
        val text = """
        |多行字符串
        |菜鸟教程
        |多行字符串
        |Runoob
        """.trimMargin()
        println(text)    // 前置空格删除了
    }

默认 | 用作边界前缀，但你可以选择其他字符并作为参数传入，比如 trimMargin(“=”)。

val text3 = """
        =多行字符串
        =菜鸟教程
        =多行字符串
        =Runoob
        """.trimMargin("=")
        println(text3)    // 前置空格删除了

这里打印出来的text是和上面是一样的。

## 十.字符串模板 ##

### 1.字符串可以包含模板表达式 ，即一些小段代码，会求值并把结果合并到字符串中。 ###

模板表达式以美元符（$）开头，由一个简单的名字构成:

fun main(args: Array<String>) {
        val i = 10
        val s = "i = $i" // 求值结果为 "i = 10"
        println(s)
    }

### 2.或者用花括号扩起来的任意表达式: ###

fun main(args: Array<String>) {
        val s = "runoob"
        val str = "$s.length is ${s.length}" // 求值结果为 "runoob.length is 6"
        println(str)
    }

原生字符串和转义字符串内部都支持模板。 如果你需要在原生字符串中表示字面值 $ 字符（它不支持反斜杠转义），你可以用下列语法：

fun main(args: Array<String>) {
        val price = """
        ${'$'}9.99
        """
        println(price)  // 求值结果为 $9.99
    }

其实上面直接使用：val price = “\{'’\}9.99” 也是可以的

Kotlin的基本数据类型介绍到先介绍到这里了。  
如果想深刻理解可以一边学习，一边看运行结果，增加印象。  
这个在线编译的网址：[http://www.runoob.com/try/runcode.php?filename=hello&type=kotlin][http_www.runoob.com_try_runcode.php_filename_hello_type_kotlin]  
把代码放进去，点击运行就可以看到编译结果。

# 共勉：这个世界上还是有很多美好的事物，值得我们用一生去追寻。 #

[http_www.runoob.com_try_runcode.php_filename_hello_type_kotlin]: http://www.runoob.com/try/runcode.php?filename=hello&type=kotlin