第一章 基数变量和表达式

一、数据类型

1、String、Int、Boolean。。。 没有 int 、floater 等

2、val 是只读类型， 可以声明在方法内。 Const val 是定义的常量，只能声明在方法外

二、表达式

1、range表达式

var number =11

//表示 在0到10的范围判断

if( number in  0..10){

}

2、when表达式

//KT 的 if 和when是表达式，有返回值 when 类似于Switch

int week = 0
val info  = when(week){
    1 -> "今天是星期一"
    2 -> "今天是星期二"
    3 -> "今天是星期三"
    4 -> "今天是星期四"
    else - >{
       println("忽略星期几")
    }
}
println(info)  //void 关键字 无返回  用Unit类代替了java void 关键字

3、if表达式

//Kt的if是表达式，有返回值，java if是语句，没有返回值

    boolean isLogin = false
       println("是否登录：${ if(isLogin) "登录成功" else "登录失败" }")

四、函数表达式

image.png

Kt函数是先有输入，后又输出，方法前不写修饰符，默认public

//参数可以给默认值
   private function1(age : Int  = 20){
      println(age)
    }

可以无序传参
Unit 无返回值可以不写，默认是

Noting 类

  fun

第二章 函数

一、匿名函数

      val len = "hello".count()
      println(len)
  
  val len = "hello".count{
      it == "l"
   }
  

image.png

//第一步：函数输入声明
  val actions : () -> String

// 第二步：对上面函数的实现
   actions = {
          "hello word"
    //匿名函数不用写return，最后一行就是返回值
   }

//下面是对上面两步进行合并
val actions : (Int,Int,Int) - > String = {arg1,arg2,arg3 ->
    "输入参数：$arg1 , $arg2,$arg3"
  
}

/*
   fun actions(arg1 : Int,arg2 : Int,arg3 : Int ) : String{
               return  "输入参数：$arg1 , $arg2,$arg3"       
 }
*/

二、it 关键字

匿名方法，如果只有一个参数，可以不写变量名，系统会自动加一个it
如下：

  val actions : (String) - > String = {
    "输入参数：$it"
   }

/*
     等效如下函数
    fun actions(it : String) : {
        "输入参数：$it"
  }
*/

三、匿名函数类型推断

     val method1 = { v1 Double, v2 Float, v3 Int ->
         "v1:$v1, v2:$v2,v3:$v3"
}

//等价于 method1 函数： （Double,Float,Int）-> String
总结：
//方法名： 必须指定参数类型，和 返回类型
// 方法 = { 类型自动推断}

第三章 空安全

1、空安全表示

name String  = "dfdfdfdf"   //表示不为空，默认就是不为空
sex String ? =null           //表示可为空 
sex?.length()             //表示可为空，如果为空，就不执行
sex!!.length()           //表示断言，如果是空就抛空指针异常

2、空合并操作符 xxx ?: “如果为空” //表示如果不为空则返回前面，如果为空则返回 ?: 后面的值

3、异常处理 和java一样

try{
                } catch(e:Exchation){
          }

第五章 常用数据操作

1、== 和 ===的区别

== 值 内容的比较 相当于java的 equals
=== 引用的比较，相当于java == ，注意对于声明的两个相同字符串常量，=== 依然是同一个引用

2、String forEach

   String str = "ABCDEFGDDDFF"

    str.forEach{
      print("$it")//it是每个字符
  }

3.类型转换

1、String 转 Int
    val number  = "666".toInt()
    
    val number = "33.22".toInt()//这个会崩溃，如何解决如下
    
    val number  = "33.22".toIntOrNull() //如果失败就返回null，

2、
Double转Int
  println(22.34556.toInt())//22四舍五入
println(22.34556.toInt())//22 四舍五入
println(22.54556.roundToInt())// 23四舍五入

//r的类型：String
val r  = "%.3f".format(32.34345434) //保留三位小数

4、apply内置函数

5、let内置函数

    val reuslt = listOf(5,6,3,3,2,1).let{
       it.first() + it.first()  
     //匿名函数返回的是最后一行，
     // it表示集合本身
}

6、run函数

      val ruslt =     "dfdfdff".run{ 
                //内部持有this，
                //返回值是最后一行
                  8888.8f
              }

7、with函数

      val str =     "dfdfdff"
       with(str){
               //内部持有this，
                //返回值是最后一行
      1243.0.f
   }

8、also函数

      val str =     "dfdfdff"
      val result = str.also{
    //返回类型为本身，和apply函数一样
    //匿名持有it， it = str本身
}

9、takeIf函数和 takeUnless函数

    val String str = “take"
    str.takeIf{
     true/false
    //true 返回str本身
    // false 返回 null
}

takeUnless函数和takeIf刚好相反

 str.takeUnless{
     true/false
    //false 返回str本身
    // true 返回 null
}

第六章 集合框架

1、list

1.1不可变list

      val   list = listOf("小明","小红","小l")
      var value = list[0]//这种会出现角标越界异常


//下面两种方式可避免角标越界，如果越界就返回null
  var value = list.getOrElse(100){
      "你越界了"
        }
      var 
value = list.getOrNull(100){
      "你越界了"
        }

1.2可变list

   val list = mutableListOf("张三","李四","王五")
   list.add("haha")
   list.remove("张三")
  
//不可变list无法完成可变list的add和remove操作，
//只有转成可变list才能操作
  val list1 = listOf(1,22,33,11)
  val list2 = list1.toMutableList()

//当然可变list也可以转换成不可变list，
 val list3 = list2.toList()
  

1.3 mutataor函数

   val list = mutableListOf("df","dd","ccc","dd")
  list += "dfdfd"
  list -= "ccc" 
  // += 和 -= 相当于 add和remove ，是运算符重载

  list.removeIf{
    it.contains("2") //过滤删除
}

1.4 list遍历

      val list = listOf(1,2,3,4,5,6)
  //第一种
  for(i in list){
    print("元素：$I")//I是每个元素
   }
//第二种
list.forEach{
        print("元素：$it")//it是每个元素
     }

//第三种带下标的
list.forEachIndexed{ index,item
        print("元素：$item,下标：$index")//it是每个元素
     }

1.5 list 全量解构和部分解构

2、 Set集合

2.1 不可变set集合

    val   set = setOf("11","22","33","11")
    //set集合不能出现重复的元素
print(set.elementAt(5))
  //会崩溃，角标越界

  print(set.elementAtOrElse{
        "越界了"
      })
  set.elementAtOrNull(88)?:   "越界了"
    

2.2 可变set集合

    val   set = mutableSetOf("11","22","33","11")
    //set集合不能出现重复的元素
print(set.elementAt(5))
  //会崩溃，角标越界

  print(set.elementAtOrElse{
        "越界了"
      })
  set.elementAtOrNull(88)?:   "越界了"
    
   set.add("55")
   set.remove("11")

2.3 list快捷去重

    val   list = mutableListOf("11","22","33","11")
    list.toMutableSet().toList()   //这样去重
    等价于下面：
  list.distinct()

3、数组

数组和list的操作几乎一毛一样

list转数组

    val list = listOf(1,2,3)
  var intArray = list.toIntArray

 注意 Array<Object>   是对象类型

4、Map

4.1、map创建

 第一种方式创建
   var map1 = mapOf("value1" to("key1"),"value2" to("key2"),)
第二种方式创建
   var map2= mapOf(Pair("key1","value1"),Pair("key2","value2"),)

4.2、map操作

   var map1 = mutableMapOf("value1" to("key1"),"value2" to("key2"),)

   val value =   map1["key1"]
  //  或者通过
    map.getOrDefault("key","默认值")
 
    map1 +=  "AA" to  "value"
    map1["key" ] = value

4.3、map遍历

   var map1 = mapOf("value1" to("key1"),"value2" to("key2"),)
 第一种
 map.forEach{ 
    print( "key:$it.key,value:$it.value")
}
 第二种：
map.forEach   { key,value->
    
}
 第三种种：
map.forEach   { (key,value)->
    
}
第四种
        for(item in map){
      print(item.key,item.value)
    }

第七章 类和接口

构造函数

  class  KtClassDemo (name : String,age : Int) {
          var name = name    
          var age = age
    }

主构造、次构造、init方法的初始化顺序

    class Test(name : String,age : Int){//先调用主构造
     //第二步初始化init
  init{
          }
      construction():this
    }