基本语法

第一部分:2018年5月10日16:26:27

定义函数

fun 特定关键词

sum 方法名

vararg 可变参数类型

var 变量类型

Int 整型

返回数据

fun sum(vararg i: Int): Int {

    var sum = 0
    for (j in i.indices) {
        sum =sum+i[j]
    }
    return sum
}

两个参数，返回两个数据之和

fun sum(a: Int, b: Int): Int {

        return a + b
}

方法返回数据为空 Unit可以省略不写

fun out(s: String): Unit {
       println(s)
   }

数据类型

val 一次赋值的局部变量类似变量加上final

var 变量

可以推断变量类型

var a=0
a=10
val b=10
var c:String="Hello"
val d:Int=10

注释

有单行注释，块注释；可以嵌套

/*
LogUtil.out(a)
/*LogUtil.out(a)
LogUtil.out(a)*/
LogUtil.out(a)
*/

//LogUtil.out(a)

使用字符串模板

${} 调用方法 $a 变量可以不用{} 使用字符串形式

print("Hello World ${MathUtil.sum(1, 2, 4, 4)} and ${sb.name}")

使用条件表达式

直接返回结果，也可以使用常规方法

fun minOf(a:Int,b:Int)=if(a<b) a else b

使用可空值

toIntOrNull()当类型不是数字类型时候返回null，Int? 空检测

fun parseInt(s:String):Int?{
     return s.toIntOrNull()
 }

 fun printProduct(s1:String,s2:String):Int{

     val s1=parseInt(s1)
     val s2= parseInt(s2)

     if(s1==null){
         return 0
     }

     if(s2==null){
         return 0
     }

     return s1*s2
 }

toIntOrNull方法源码

@SinceKotlin("1.1")
public fun String.toIntOrNull(radix: Int): Int? {
    checkRadix(radix)

    val length = this.length
    if (length == 0) return null

    val start: Int
    val isNegative: Boolean
    val limit: Int

    val firstChar = this[0]
    if (firstChar < '0') {  // Possible leading sign
        if (length == 1) return null  // non-digit (possible sign) only, no digits after

        start = 1

        if (firstChar == '-') {
            isNegative = true
            limit = Int.MIN_VALUE
        } else if (firstChar == '+') {
            isNegative = false
            limit = -Int.MAX_VALUE
        } else
            return null
    } else {
        start = 0
        isNegative = false
        limit = -Int.MAX_VALUE
    }


    val limitBeforeMul = limit / radix
    var result = 0
    for (i in start..(length - 1)) {
        val digit = digitOf(this[i], radix)

        if (digit < 0) return null
        if (result < limitBeforeMul) return null

        result *= radix

        if (result < limit + digit) return null

        result -= digit
    }

    return if (isNegative) result else -result
}

类型判断

在判断类型的域中，或者判断语句之后，不需要转化类型了，可以直接使用相关方法； is 属于 !is 不属于

fun e(obj: Any) {
       println("===========================S==============================")
       if (obj is String) {
           println("字符串长度"+obj.length+"  "+obj)
       } 

       if(obj !is String){
           println("" + obj)
       }
       println("===========================E==============================")
   }

使用for循环

in [0,30] 都包含在内

for(i in 0..30){
     println(i)
 }

arrayOf 类似于集合，可接受不同类型，不同长度的功能；

//public inline fun arrayOf(vararg elements: T): Array

indices 范围，尺度

val  arr=arrayOf("1","2",3,false,"Hello World")
for(i in arr.indices){
    println(arr[i])
}

使用while循环

var index=0
while (index<arr.size){
    index++
    print("Hello  ")
}

使用when

有点类似 switch case 语句；适配到一个就结束，默认使用 else

fun main(args: Array<String>) {

    val arr = arrayOf("1", "2", 3, false, 4.5)
    for (i in arr.indices) {

        when (arr[i]) {
            "1" -> println("字符串数字1")
            is String -> println("String 类型")
            is Boolean -> println("布尔 类型")
            is Int -> println("整数 类型")
            3 -> println("数字3")
            else -> println("UnKnown")

        }
    }

}

输出结果

字符串数字1
String 类型
整数 类型
布尔 类型
UnKnown

使用区间（range）

in 在区间之内

for (i in 0..10) {
       println("i:"+i)
}

step 步长
for (i in 0..20 step 5 ) {
println(“i:” + i)
}

输出

i:0
i:5
i:10
i:15
i:20

downTo 减少

for(x in 27 downTo 9 step 2){
      println("x=$x" )
  }

输出

x=27
x=25
x=23
x=21
x=19
x=17
x=15
x=13
x=11
x=9

until 【0，10）

for (x in 0 until 10) {
    println("$x====")
}

输出

0====
1====
2====
3====
4====
5====
6====
7====
8====
9====

!in 在区间之外

Random().nextInt(1000) 产生一个1000之内的整数

val s = Random().nextInt(1000)
if (s !in 10..100) {
    println("$s 不在10到100之内...")
} else {
    println("$s 在10到100之内...")
}

使用集合

listOf 转换成一个集合，遍历 for(item in list)

//public fun listOf(vararg elements: T): List = if (elements.size > 0) elements.asList() else emptyList()

val list = listOf("1", 2, 3.0, true)
println(list.get(0))
for(item in list){
    println(item)
}

ArrayList

val mList = ArrayList<Any>()
mList.add(1)
mList.add("2")
mList.add(3.0)
mList.remove(1)
mList.add("22")

for (i in mList.indices) {
    println("第${i}个数据:${mList[i]}")
}

HashMap

val map = HashMap<String, String>()
map.put("one", "1")
map.put("two", "2")
map.put("three", "3")
for (key in map.keys) {
    println("键值对 ${key} :${map.get(key)}")
}

输出结果

1
1
2
3.0
true
第0个数据:2
第1个数据:3.0
第2个数据:22
键值对 one :1
键值对 two :2
键值对 three :3

新方式遍历map

val map = HashMap<String, String>();
map.put("one", "1")
map.put("two", "2")
for ((x, y) in map) {
    println("$x====$y")
}

初始值，map2不可变

val map2 = mapOf("1" to "one", "2" to "two", "3" to "three")
for ((m, n) in map2) {
    println("$m--->$n")
}

lambda表达式

对集合数据进行筛选、整合、排序等，很好、很强大

val f = listOf("black1", "red1", "white", "black2", "red2", "black7", "black2", "black6")
f.filter { it.startsWith("b") || it.startsWith("r") }
        .map { it.toUpperCase() }
        .sortedBy { it }
        .forEach { println(it) }

输出結果

BLACK1
BLACK2
BLACK2
BLACK6
BLACK7
RED1
RED2

if not null 缩写 ?

此时我D盘有文件夹”1”不存在文件夹”Test”

val files = File("D://1").listFiles()
println(files?.size)

val files2 = File("D://test").listFiles()
  //println(files2?.size)

println(files2.size)

输出结果

3
Exception in thread "main" java.lang.NullPointerException
    at HelloKt.main(hello.kt:38)

if null 缩写 ?:

val s1 = null
val email = s1 ?: "数据为空!"
val s2 = "qishuichixi@126.com"
val emai2 = s2 ?: "数据为空!"

println("email:${email} emai2:${emai2}");

输出

email:数据为空! emai2:qishuichixi@126.com

if not null else 缩写 ? ?: 相当于将null 转成其他处理

val files = File("D://1").listFiles()
println(files?.size ?: "empty")

val files2 = File("D://test").listFiles()
println(files2?.size ?: "empty")

输出结果

3
empty

if not null 缩写 ?.let 如果不为空则执行

val s1 = null
val email = s1
val s2 = "qishuichixi@126.com"
val emai2 = s2
//不为空
email?.let {
    println("email不为空....")
}

//不为空
emai2?.let {
    println("emai2不为空....")
}

輸出

emai2不为空....

基本内容

第二部分: 2018年5月10日16:29:28

基本类型

数字

Double 64

Float 32

Long 64

Int 32

Short 16

Byte 8

在kotlin中字符不是数字

字面常量

十进制： 123 123L 123.5 123.5e10 123.5F

十六进制: 0xAF22

二进制: 0b1000101010

不支持八进制

数字字面值中的下划线

val l = 1_000_000
val l1 = 1234_1234_5478_7895L
val l2 = 0xFF_EE_5E
val l3 = 0b10001010_000111001_00011100

LogUtil.all(l, l1, l2, l3)

更加易读

输出

===========================S==============================

1000000

1234123454787895

16772702

18102556

===========================E==============================

打印方法

fun all(vararg any: Any) {

      println("===========================S==============================")
      for (a in any) {
          println(a)
      }
      println("===========================E==============================")

  }

显示转换

较小类型的隐式转成较大类型，可以通过显示转换来拓宽数字

val a: Int? = null
val b: Int? = 20
//错误写法
//val c:Long?=b
val c: Long? = b?.toLong()
val d: Long? = a?.toLong()

LogUtil.all(c, d)

输出

===========================S==============================

null

===========================E==============================

Long+Int=Lont

val x: Int = (3L + 1).toInt()
val y = 3L + 12
println(x)
println(y)

每个数字类型支持如下转换

toByte() Byte

toShort Short

toInt Int

toLong Long

toFloat Float

toDouble Double

toChar Char

运算

import com.qishui.util.LogUtil

fun main(args: Array<String>) {


    // 错误  没有>> <<  >>>等
    // val x1=1>>2
    //左移2位 2^3
    val x2 = (1 shl 3)
    //右移4位 1/(2^2)  减到 0 不再减少
    val x3:Double=(x2 shr 2).toDouble()
    val x4:Double=(x2 shr 5).toDouble()
    //无符号右移 >>> ushr
    val x5=10 ushr 2
    // 且 &&
    val f=true and false and true
    val h=true && false
    //或 ||
    val m=true or false or false
    val n=true || false || false
    //异或  0∧0＝0，0∧1＝1，1∧1＝0
    val p=12 xor 3



    LogUtil.all("x2=$x2,x3=$x3,x4=$x4,x5=$x5 ,f=$f,h=$h,m=$m，n=$n，p=$p")

}

输出

===========================S==============================
x2=8,x3=2.0,x4=0.0,x5=2 ,f=false,h=false,m=true，n=true，p=15
===========================E==============================

字符

用char表示，不能直接当做数字。’1’, 支持几个转义序列，\t \b \n \r \’ \ \$ ;编码其他要用Unicode转义：’\uFF00’。

布尔

Boolean类型，有两个值 true、false。

内置运算 && 、|| 、！

数组

用Array表示

arrayof(1,2,3) 初始化数组

arrayOfNulls 表示空数组长度为10

val b = arrayOfNulls<String>(10)
for (x in b) {
    println(x)
}

输出

null
null
null
null
null
null
null
null
null
null

还有表示同一类 IntArray 、ByteArray 、等与 Array 没有继承关系，可以表示弄一类型数组。

字符串

用String表示

val b : String ="HelloWorld"
println("b[2]=${b[2]}")
   for (x in b) {
       println(x)
   }

可以遍历，使用字符访问。

输出

b[2]=l
H
e
l
l
o
W
o
r
l
d

字符串字面值

“”” 有点类似于html pre标签，把字符串预定输出样式

val text = """
        for(c in  "Hello"){
        println(c)
        }
"""

println(text)

输出

for(c in  "Hello"){
println(c)
}

trimMargin() 函数去除前导空格

字符串模板

在字符串里面调用方法，属性

val b: String = "HelloWorld"
println("b[2]=${b[2]}")

包

申明，源文件通常以包申明开头

package com.qishui.util

默认导入

import kotlin.*
import kotlin.annotation.*
import kotlin.collections.*
import kotlin.comparisons.*
import kotlin.io.*
import kotlin.ranges.*
import kotlin.sequences.*
import kotlin.test.*


import kotlin.*

导入kotlin中所有方法、属性

import com.qishui.util.StringUtils

导入util包中StringUtils类

根据不同平台，还会导入其他额外的包。

如果名字相同的类，可以使用别名

import com.qishui.util.LogUtil
import com.qishui.LogUtil as SecLogUtil

顶层声明可见性

如果顶层声明是private的，声明它的文件是私有的。

控制流

if表达式

使用if就可以返回数据，不需要三元表达式。

fun minOf(a:Int,b:Int)=if(a<b) a else b

如果是表达式，如要使用else 。

when表达式

类似switch方法，直到某一分支符合，结束语句。

   for (f in 0..5) {

    val x = Random().nextInt(10)
    when (x) {
        0 -> {
            LogUtil.e("x=0")
        }

        1 -> {
            LogUtil.e("x=1")
        }

        2, 3, 4 -> {
            LogUtil.e("x=${x}属于【2，4】")
        }

        in 5..7 -> {
            LogUtil.e("x=${x}属于【5，7】")
        }
        else -> {
            LogUtil.e("x=${x}属于【5，10】")
        }
    }
}

输出

===========================S==============================
字符串长度10  x=3属于【2，4】
===========================E==============================
===========================S==============================
字符串长度3  x=0
===========================E==============================
===========================S==============================
字符串长度10  x=6属于【5，7】
===========================E==============================
===========================S==============================
字符串长度10  x=2属于【2，4】
===========================E==============================
===========================S==============================
字符串长度10  x=2属于【2，4】
===========================E==============================
===========================S==============================
字符串长度3  x=0
===========================E==============================

基本语法

定义函数

数据类型

注释

使用字符串模板

使用条件表达式

使用可空值

类型判断

使用for循环

使用while循环

使用when

使用区间 （range）

使用集合

lambda表达式

if not null 缩写 ?

if null 缩写 ?:

if not null else 缩写 ? ?: 相当于将null 转成 其他处理

if not null 缩写 ?.let 如果不为空则执行

基本内容

基本类型

数字

字面常量

数字字面值中的下划线

显示转换

运算

字符

布尔

数组

字符串

字符串字面值

字符串模板

包

顶层声明可见性

控制流

if表达式

when表达式

返回和跳转

类和对象

类和继承

属性和字段

接口

可见性修饰符

扩展

数据类

密封类

泛型

嵌套类

枚举类

对象

委托

委托属性

函数和Lambda

函数

Lambda表达式

内联函数

协程

使用区间（range）

if not null else 缩写 ? ?: 相当于将null 转成其他处理