Kotlin

1. Kotlin

Kotlin就是一门可以运行在Java虚拟机、Android、浏览器上的静态语言，它与Java 100%兼容，如果你对Java非常熟悉，那么你就会发现Kotlin除了自己的标准库之外，大多仍然使用经典的Java集合框架；

1. Android官方开发语言
2. 100%兼容Java
3. Kotlin-Js 前端开发
4. Kotlin-Jvm 服务端开发
5. Kotlin-Native 本地执行程序

必备知识

1. 熟悉计算机基础、操作系统相关的知识
2. 了解Java及其生态
3. 了解Java工程组织的常用工具
4. 熟悉IntelliJ Idea

参考资料

1. 官方文档：https://kotlinlang.org/docs/reference
2. Kotlin源码:https://github.com/JetBrains/kotlin
3. Kotlin官博：https://blog.jetbrains.com/kotlin/

基本类型

1. Boolean类型
   Boolean 值 只有true或者false两个值，它无处不在，相当于Java类型的boolean

val aBoolean : Boolean = true
val anotherBoolean : Boolean = false
//var是可变变量（可读可写），val是可读变量（只能读）；
//同时 ： 后面的Boolean 是指它的类型，前面的aBoolean或anotherBoolean是它的变量名称，
//"="号后面的true或false是它的值；

2. Number类型

分类	类型	大小
浮点型	Double	64
浮点型	Float	32
整型	long	64
整型	Int 32
整型	Short	16
字节	Byte	8

Long类型的长整形后面可以加个L； Float类型后面必须加F,f；Float是浮点类型，有精度问题，计算钱相关的不要用这个；

3. Char类型
   1. 特点
      字符对应Java的Character
      占两个字节，表示一个16位的Unicode字符
      字符用单引号’‘引起来，例如： ‘a’,‘0’,’\n’

转义字符	含义
\t	制表符
\b	光标后退一个字符
\n	回车
\r	光标回到行首
\ ’	单引号
"	双引号
\	双斜杠
$	美元符号，Kotlin支持美元符号开头的字符串模板

2. 不可隐式转换
   在java中，一个int类型与Long相加，原本的Int类型会自动隐式转换为Long类型，这在Kotlin中是不允许的；
3. 比较相等
   ==表示equals 值得相等比较
   === 三个等号表示引用地址的比较，即比较两个值是否是同一个引用地址；

类与对象

1. 类
   1. 类，一个抽象的概念
   2. 具有某些特征的事物的概括
   3. 不特定指代任何一个具体的事物
   5. 写法：

class<类名>{<成员>}

2. 对象

   1. 是一个具体的概念，与类相对
   2. 描述某一种类的具体个体
   3. 举例
      某些人、领导的车、你手里的那本书

3. 类和对象的关系？

   1. 一个类通常可以有很多个具体的对象
   2. 一个对象本质上只能从属于一个类
   3. 某一个人，他是工程师，但本质上还是属于人这一类

4. 类的继承

   1. 提取多个类的共性得到一个更抽象的类，即父类；
   2. 子类拥有父类的一切特征
   3. 子类也可以自定义自己的特征
   4. 所有类都最终继承自Any
      

5. 父类子类
   

6. 空类型

   1. 任意类型都有可空和不可空两种
      1. val notNull:String = null // 错误，不能为空。 如果为空会抛出异常
      2. val nullable:String ?= null // 正确，可以为空。 如果为空，则被赋值的nullable的值为null
      3. notNull.length // 正确,不为空的值可以直接使用
      4. nullable.length // 错误，可能为空，不能直接获取长度
      5. nullable!!.length // 正确，强制认定nullable不可空（如果在这段代码前进行了if判断，比如不为空的时候才执行的这段代码，就没有问题。我们已经认定了这个nullable变量不为空）
      6. nullable?.length // 正确，若nullable为空，返回空

7. 区间

   1. 概述：
      1. 一个数学上的概念，表示范围
      2. ClosedRange的子类，IntRange最常用
   2. 基本写法：
      1. 0…100表示[0,100]
      2. 0 until 100 表示 [0,100)
      3. i in 0…100判断 i 是否在区间 [0,100]中
      4. 代码

// 前后都闭区间  [0,1024]
val range:IntRange=0..1024
// 前闭后开的区间  [0,1024) = [0,1023]
val range_exclusive:IntRange= 0 until 1024  
val empty_Range:IntRange=0..-1

fun main(args:Array<String>){
	// true   是为空，因为此范围中没有值
	println(emptyRange.isEmpty())
	// true 此范围中包含了50
	println(range.contains(50))
	// true 检查50是否在range的范围中
	println(50 in range)
}

// 下面打印出来的结果为： 0,1,2,3,4,5,6,7,8,9,10...
for(i in range_exclusive){
	println("$i,")
}

8. 数组
   就是一系列对象，这个对象可以是各类型的数字，字符，字符串，或者自定义对象等；
   1. 基本写法
      val array:Array arrayOf(…)
   2. 基本操作
      println array[i] 输出第i个成员
      array[i] 指定数组的第i个成员值；我们可以通过此进行赋值或者获取值
      array.length 数组的长度

java	Kotlin
int[]	IntArray
short[]	ShortIArray
long[]	LongArray
float[]	FloatArray
double[]	DoubleArray
char[]	CharArray

3. 创建数组

package array
import java.util.Scanner
fun main(args: Array<String>) {

    //直接传入数字
    val arr1 = arrayOf(1,2)
    //全部是null并且大小为2
    val arr2 = arrayOfNulls<Int>(2) //定义数组长度为10,默认值为null
    //创建空数组
    var arr3: Array<String?> = arrayOfNulls(2)// a = [null, null]
    //设置好的控制传入值
    arr3.set(0, "java")
    arr3[1] = "Kotlin"

    //按照一定规律传入值
    val arr4 = Array<Int>(10, { i -> (i+1)*(i+1) })
   //传入String值
    val arr5 = arrayOf("Hello", "world")
    //创建一个空数组
    var arr6 = listOf("x", 4, 0.1)
    var arr7=(10..50).step(10).toList()
    var arr8=IntRange(10, 50).step(10).toList()
    var arr9=CharRange('a', 'z').step(1).toList()
    //输出[1，2，3]
    var arr10=arrayOf(1, 2, 3).contentToString()
    var arr11= IntArray(5).contentToString() // all 5
     var arr12= CharArray(5).contentToString() // all empty char
    var arr13=IntArray(5) {
        it * it
    }.contentToString()
    //输出字母
    var arr14=CharArray(5) { 'a' + it }
    //输出str1,str2,str3
    var  arr15=Array(3){"str$it"}
   //创建二维数组
    var arr16= Array(3){IntArray(3)}
    val arr17 = Array(3,{Array(3){it -> 0}})
    //读取键盘输入
    val sc = Scanner(System.`in`)

    for (i in 0..2)
        for (j in 0..2)
        {
            arr16[i][j]=sc.nextInt()
        }
//遍历二维数组
  for(a in arr16)
  {
      for (b in a){
          print(b)
          print("\t")
      }
      println()
  }
    //遍历一维数组
    for (item in arr1) {
       println(item)
    }
  //  for (item in arr) {
        //print(item)
    //}
}

1. 集合
   1. 集合与可空性
      前边我们知道如果一个变量可以为空，我们在定义的时候就在该变量前边加个?，来表示该变量的值可为null。同样集合也可以事先在定义的时候知道是否持有null元素。对于一个集合，我们也应该考虑到，这个集合是否可以存储null值，对应于有包含可空值的集合和包含非空值的集合。

  val result=ArrayList<Int?>()   ArrayList<Int?>是能持有Int?类型值的列表，换句话说就是，可以持有Int或者是null。

这里需要注意的是，变量自己类型的可空性和用作类型参数的类型的可控性是有区别的。 即包含可空Int列表和包含Int的可空列表
包含可空的int列表 ：（指的是列表中单个值是可空的），列表本身始终不为null，但是列表中的每个值都可以为null，
包含int的可空列表：（指的是整个列表是可空的） 可能包含空引用，而不是列表实例，但列表中的元素保证是非空的

所以要小心决定是集合的元素还是集合本身可空。

集合类型	只读	可变
List	listOf	mutableList OfarrayListOf
Set	setOf	mutableSetOf hashSetOf linkedSetOf sortedSetOf
Map	mapOf	mutableMapOf hashMapOf linkedMapOf sortedMapOf

3.集合的使用
声明一个集合并进行遍历

package array

fun main(args: Array<String>) {
    val titleList = listOf<String>("推荐", "热点", "视频", "北京", "社会", "问答", "图片", "科技", "财经", "军事", "国际")
    //集合遍历的方法 for-in  forEach   迭代器遍历
    for (i in titleList.indices) {
        val item = titleList[i]
        print(item)
    }
    println()
    for (title in titleList) {
        print(title + "\t")

    }
    println()
    val iterator = titleList.iterator()
    while (iterator.hasNext()) {
        val item = iterator.next()
        print(item + "\n")
    }
    //forEach遍历 内部使用it指代每条记录
    titleList.forEach {
        print(it + " ")
    }
    val fruits = listOf("banana", "avocado", "apple", "kiwifruit")
    fruits.filter { it.startsWith("a") }
        .sortedBy { it }
        .map { it.toUpperCase() }
        .forEach {
            println(it)    //集合遍历的方法 for-in  forEach   迭代器遍历

        }
    
    //map和MutableMap
    var goodsMap: Map<String, String> = mapOf("苹果" to "iphone8", "华为" to "Mate 10", "小米" to "小米9", "魅族" to "魅族Pro6s")

    //Pair方式初始化映射
    var goodsMutmap: MutableMap<String, String> =
        mutableMapOf(Pair("苹果", "iphone9"), Pair("华为", "荣耀10"), Pair("Vivo", "Vivox9"))


    //打印元素的总个数
    println(goodsMap.size)
    //获取某个key对应的value
    println(goodsMap.get("苹果"))  //iphone8

    println(goodsMap.getOrDefault("11", "不存在值"))  //不存在值

    //获取所有的key，和 value
    for (key in goodsMap.keys) {
        println(key)
    }
    for (value in goodsMap.values) {
        println(value)
    }

    //可以将map转换成mutablemap
    val toMutableMap = goodsMap.toMutableMap()
    toMutableMap["苹果"] = "iphone x max"

    println(toMutableMap.get("苹果"))  //iphone x max

    //移除元素
    toMutableMap.remove("小米")


    //也是3种遍历map的方式 for-in forEach iterator
    for (item in goodsMutmap) {
        println(item.key + "")
        println(item.value + "/")
    }

    val iterator1 = goodsMutmap.iterator()
    while (iterator1.hasNext()) {
        val item = iterator1.next()
        println(item.key + "")
        println(item.value + "/")
    }

    // 使用forEach遍历
    goodsMap.forEach { key, value ->
        println(key)
        println(value)
    }

    goodsMutmap.forEach { key, value ->
        println(key)
        println(value)
    }
}