kotlin 学习笔记_kotlin withindex-CSDN博客

本文链接：https://blog.csdn.net/mxthing/article/details/103049420

kotlin
一、Kotlin之变量用法

1.kotlin变量的声明方式与Java中声明变量有很大的区别，而且必须使用var或val关键字。其中：

       var: 用此关键字声明的变量表示可变变量，即可读且可写。相当于Java中普通变量
       val: 用此关键字声明的变量表示不可变变量，即可读且不可写。相当于Java中用final修饰的变量
       基础用法
       定义格式：关键字变量名: 数据类型 = xxx
           变量
               //立即初始化
               var var_a: Int = 10

//推导出类型
var var_b = 5

               //没有初始化的时候，必须声明类型
               var var_c: Float
               var_c = 12.3f

           常量
               //立即初始化
               val val_a: Int = 100

               //推导出类型
               val val_b = 50


   2.每一行代码的结束可以省略掉分号

   3.延迟初始化属性
       指当程序在第一次使用到这个变量（属性）的时候在初始化。
       使用lazy{}高阶函数，不能用于类型推断。且该函数在变量的数据类型后面，用by链接。
       必须是只读变量，即用val声明的变量。

二、Kotlin之常量的用法

       Kotlin中只用val修饰还不是常量，它只能是一个不能修改的变量。那么常量怎么定义呢？
       其实很简单，在val关键字前面加上const关键字
       即：

           const val NUM_A = 6
           其特点：const只能修饰val，不能修饰var
       声明常量的三种正确方式

       在顶层声明
       在object修饰的类中声明，在kotlin中称为对象声明，它相当于Java中一种形式的单例类
       在伴生对象中声明

       // 1. 顶层声明
       const val NUM_A : String = "顶层声明"

       // 2. 在object修饰的类中
       object TestConst{
           const val NUM_B = "object修饰的类中"
       }

       // 3. 伴生对象中
       class TestClass{
           companion object {
               const val NUM_C = "伴生对象中声明"
           }
       }
三、Kotlin之注释

Kotlin中的注释几乎和Java没什么区别。唯一的区别在于Kotlin中的多行注释中可以嵌套多行注释，
而Java中是不能的。

单行注释两个斜杠开头表示单行注释（//）
多行注释（块注释）以斜杠加星号开头（/*），同时以星号加斜杠结尾（*/），

四、数值类型

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

       Byte=> 字节 => 8位
       Short => 短整型 => 16位
       Int => 整型 => 32位
       Long => 长整型 => 64位
       Float => 浮点型 => 32位
       Double => 双精度浮点型 => 64位
       eg:
       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

       2、进制数

       二进制数
       八进制数（Kotlin不支持）
       十进制数
       十六进制数
       例：

       var g = 0x0F //十六进制数
       var h = 0b00001011 //二进制数
       var k = 123 //十进制数
       // ps：Kotlin不支持八进制数

       3、数字类型字面常量的下划线

       作用：分割数字进行分组，使数字常量更易读
           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

       4、装箱与拆箱

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

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

           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

五布尔类型（Boolean）
   1、关键字

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

2、逻辑操作符（与Java相同）

       ' || ' => 逻辑或（或者）
       ' && ' => 逻辑与（并且）
       ' ! ' => 逻辑非（取反）
六字符型（Char）
   1、关键字

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

   2、显示转换为其他类型
   字符型的变量不仅可以转换为数字，同时也可转换为其他类型
   例：

   var var1 = char1.toByte()
   var var2 = char1.toInt()
   var var3 = char1.toString()
   var var4 = char1.toFloat()
   var var5 = char1.toShort()
四、字符串类型（String）
   1、关键字

       String表示字符串类型。其是不可变的。所以字符串的元素可以通过索引操作的字符：str[index]来访问。可以使用for循环迭代字符串：
       其中str[index]中的str为要目标字符串，index为索引
   2、字符串字面量

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

   包含转义字符的字符串转义包括（\t、\n等）,不包含转义字符串的也同属此类型
   包含任意字符的字符串由三重引号（""" .... """）表示

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

   3、字符串模板

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

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

五、数组型（Array）
   Kotlin中数组由Array<T>表示，可以去看看源码实现，里面就几个方法
       创建数组的3个函数
           arrayOf() 创建一个数组，参数是一个可变参数的泛型对象
           arrayOfNulls() 用于创建一个指定数据类型且可以为空元素的给定元素个数的数组
           工厂函数（Array()）

   4、原始类型数组

       Kotlin还有专门的类来表示原始类型的数组，没有装箱开销，它们分别是：
       ByteArray => 表示字节型数组
       ShortArray => 表示短整型数组
       IntArray => 表示整型数组
       LongArray => 表示长整型数组
       BooleanArray => 表示布尔型数组
       CharArray => 表示字符型数组
       FloatArray => 表示浮点型数组
       DoubleArray => 表示双精度浮点型数组

二、for语句
       Kotlin废除了Java中的for(初始值;条件；增减步长)这个规则。但是Kotlin中对于for循环语句新增了其他的规则，来满足刚提到的规则。
       for循环提供迭代器用来遍历任何东西
       for循环数组被编译为一个基于索引的循环，它不会创建一个迭代器对象
       1、新增的规则，去满足for(初始值;条件;增减步长)这个规则

1.1、递增

       关键字：until
       范围：until[n,m) => 即大于等于n,小于m

       1.2、递减

       关键字：downTo
       范围：downTo[n,m] => 即小于等于n,大于等于m ,n > m

       1.3、符号（' .. '）表示递增的循环的另外一种操作

       使用符号( '..').
       范围：..[n,m]=> 即大于等于n，小于等于m
       和until的区别，一是简便性。二是范围的不同。

       1.4、设置步长

       关键字：step

       2、迭代

       for循环提供一个迭代器用来遍历任何东西。
       for循环数组被编译为一个基于索引的循环，它不会创建一个迭代器对象
       2.1、遍历字符串



       2.4、使用数组的withIndex()方法遍历

例：

       var arrayListTwo = arrayOf(1,3,5,7,9)
       for ((index,value) in arrayListTwo.withIndex()){
           println("index => $index \t value => $value")
       }

       2.5、使用列表或数组的扩展函数遍历

       数组或列表有一个成员或扩展函数iterator()实现了Iterator<T>接口，且该接口提供了next()与hasNext()两个成员或扩展函数
       其一般和while循环一起使用

       例：

var arrayListThree = arrayOf(2,'a',3,false,9)
var iterator: Iterator<Any> = arrayListThree.iterator()

       while (iterator.hasNext()){
           println(iterator.next())
       }

三、when语句
   在Kotlin中已经废除掉了Java中的switch语句。而新增了when(exp){}语句。
   when语句不仅可以替代掉switch语句，而且比switch语句更加强大
       3.1、when语句实现switch语句功能

例：

       when(5){
           1 -> {
               println("1")
           }
           2 -> println("2")
           3 -> println("3")
           5 -> {
               println("5")
           }
           else -> {
               println("0")
           }
       }
       3.2、和逗号结合使用，相当于switch语句中的不使用break跳转语句

例：

       when(1){
           // 即x = 1,2,3时都输出1。
           1 , 2 , 3 -> {
               println("1")
           }
           5 -> {
               println("5")
           }
           else -> {
               println("0")
           }
           }

       3.4、检查值是否存在于集合或数组中

       操作符：
       （in）在
       (!in) 不在
       限定:只适用于数值类型
       例：

       var arrayList = arrayOf(1,2,3,4,5)
       when(1){
           in arrayList.toIntArray() -> {
               println("1 存在于 arrayList数组中")
           }
           in 0 .. 10 -> println("1 属于于 0~10 中")
           !in 5 .. 10 -> println("1 不属于 5~10 中")
           else -> {
               println("都错了哈哈！")
           }
       }

       3.5、检查值是否为指定类型的值

       操作符
       是（is）
       不是（!is）
       值得注意的是，Kotlin的智能转换可以访问类型的方法和属性
       例：

       when("abc"){
           is String -> println("abc是一个字符串")
           else -> {
               println("abc不是一个字符串")
           }
       }

       // 智能转换
       var a: Int = 2
       when(a){
           !is Int -> {
               println("$a 不是一个Int类型的值")
           }
           else -> {
               a = a.shl(2)
               println("a => $a")
           }
       }