主函数的两种方式

 //主函数的第一种方式
fun main(args: Array<String>) {
    println("Hello Kotlin!")
}
 
//主函数的第二种方式
class KotlinDemo1{
    companion object {
        @JvmStatic
        fun main(args: Array<String>) {
            println("Hello Kotlin!")
        }
    }
}

定义常量与变量
1, 可变变量定义：var 关键字，
2, 不可变变量定义：val 关键字，只能赋值一次的变量(类似Java中final修饰的变量)

 //可变变量定义
var a = 12
a += 1//正确
//不可变变量定义
val b = 1
b = 5//报错
//和java相反， 变量名在前， 变量类型在后。
var str: String = "kotlin"//等价于var str = "kotlin"
val num :Int = 5//等价于val num = 5

注释和java相同

字符串模板

 //字符串模板， 单个变量时， 可以省略大括号{}， 表达式必须加上大括号{},大括号中， 可以写各种表达式， 以及一些简单运算
var a = 1
// 模板中的简单名称：
val s1 = "a is $a" 
 
a = 2
// 模板中的任意表达式：
val s2 = "${s1.replace("is", "was")}, but now is $a"
val text = """
    |多行字符串
    |菜鸟教程
    |多行字符串
    |Runoob
    """.trimMargin()
    println(text)    // 前置空格删除了
没添加trimMargin()方法时, 输出结果, 有多少空格输出多少空格

                        |多行字符串
                        |菜鸟教程
                        |多行字符串
                        |Runoob

添加trimMargin()方法后, 输出结果, 前置空格(每行字符串前面的空格), 被删除

多行字符串
菜鸟教程
多行字符串
Runoob

函数定义和使用

 //函数定义使用关键字 fun，参数格式为：参数 : 类型
fun sum(a: Int, b: Int): Int {   // Int 参数类型，返回值 Int
    return a + b
}  
 
//表达式作为函数体，返回类型自动推断：
fun sum(a: Int, b: Int) = a + b
// public 方法则必须明确写出返回类型
public fun sum(a: Int, b: Int): Int = a + b  
 
//无参函数 
fun add(a:Int, b:Int):Unit{//Unit可以省略不写
   println(a+b);
}
 
//可变长参数函数
var sum = 0
fun add(vararg v:Int, a:Int) {
    for (i in 0..v.size) {
        sum += i
    }
    println(sum + a)
}
////类似于Java中的可变参数， int... num,其本身是一个数组，
  和Java不同，可变参数可以放在任意参数位置。
//调用方式 
add(1,2,3, a=4)//a=4为具名参数, 也就是形参 
 
//还可以给参数设置默认值 
fun add(num1:Int, num2:Int = 5){
}
//调用方式
add2(1)//不指定第二个值默认使用5
add2(1, 6)//默认值无效, 使用指定的值
add(num1=3, num3=6)//还可以这样调用 

lamda匿名函数

(参数类型1, 参数类型2) -> 返回值类型

(Int, Int) -> Int = {x, y -> x+y}

fun test(a: Int, b: Int, method: (Int, Int) -> Int): Int {
    return method.invoke(a, b)
}
//调用方式, 好处, 相当于把一个匿名函数, 当做参数传递到另一个方法中, 
  可以实现各种算法, 你可以写a+b, 或者a-b 或者a*b
val method: (Int, Int) -> Int = { a, b -> a + b }//lambda具体实现形式
val method: (Int, Int) -> Int = { a, b -> 
   val num = a * 8 + b
   ...n多行代码
   num//最后一行为返回值
}
val num2 = test(3, 2, method) 
println(num)//相当于Java的System.out.println(num)

kotlin基本数据类型, 和java一样, 全改成首字母大写

// 类型转换 int和double, float, str等转换, 原理一样, 变量.toFloat() ,变量.toDouble(), 变量.toString(), 变量.toInt()

异常时, 转换原理和java一样.

var d = 15.23//Double型

var f:Float = d.toFloat()

var f1 = 12.3f

var d1 = f1.toDouble()

位操作符 和 逻辑操作符

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

//位操作符
shl(bits) – 左移位 (Java’s <<)
shr(bits) – 右移位 (Java’s >>)
ushr(bits) – 无符号右移位 (Java’s >>>)
and(bits) – 与 (&)
or(bits) – 或 (|)
xor(bits) – 异或 (^)
inv() – 取反 (~)
//逻辑操作符
|| – 短路逻辑或
&& – 短路逻辑与
! - 逻辑非

字符

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

fun check(c: Char) {
    if (c == 1) { // 错误：类型不兼容
        // ……
    }
}
字符字面值用单引号括起来: '1'。 特殊字符可以用反斜杠转义。 支持这几个转义序列：\t、 \b、\n、\r、\'、\"、\\ 和 \$。 编码其他字符要用 Unicode 转义序列语法：'\uFF00'。

我们可以显式把字符转换为 Int 数字：

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

数组和集合

数组

//初始化方式
 var arr = arrayOf(1, 2, 3, 4)
 var arr2 = arrayOf<String>("sd", "name", "test", "kjdsf")
// var arr4 = arrayOf()//这种方式, 不可空参数
//下面3代表数组长度,后面是lambda表达式, 也就是匿名函数, i代表角标
 var arr5 = Array(3) { i -> i*2} //等价于 var arr5 = Array(3, {i -> i*2}) 
 for (i in arr5) {//数组遍历方式 使用关键字in
     println(i)
 }//输出结果 0, 2, 4
//[] 运算符代表调用成员函数 get() 和 set()。赋值和获取值, 和数组一样, 不推荐get, set方式

//赋值操作

arr5[2] = 8 //注意角标越界

//获取值

val num = arr5[1]

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

val x: IntArray = intArrayOf(1, 2, 3)

x[0] = x[1] + x[2]

val newArr = arr.plus(6); //将arr数组和6拼接后, 返回一个新数组

val newArr2 = arr.plus(arr5) // 拼接两个数组

集合中的list

//初始化几种方式

val list1 = ArrayList<String>() //java方式

val list2 = arrayListOf<String>("apple", "banana", "pear")

val list3 = mutableListOf<String>() 

val list4 = MutableList(10) { i -> i*2} //10为集合长度, i为角标, 匿名函数(lambda表达式)

//增删改查 java中的方法都支持, 可以直接使用
list2.add("test")
list22.remove("test")
list2[0] = "apple1"
val pear = list[2] 

集合中的set

val set4 = HashSet<Int>() 
val set5 = mutableSetOf<String>()
val set = setOf<Int>(1, 3, 4)
val set2 = hashSetOf<Int>(5, 6, 7)
//增删改查, set不支持修改值
set.minus(4)//添加
set.plus(5) //删除
val set3 = set.plus(set2)
set.elementAt(0)//获取

Map

val map = HashMap<String, String>()
val map2 = mutableMapOf<String, String>("username" to "gyf", "password" to "123")
val map3 = hashMapOf<String, String>("username" to "gyf", "password" to "123")
 
//增删改查
// map2.put("one", "1")
map2["one"] = "1" //增加元素
map2.remove("one")//删除
map2["username"] = "alex"//修改
val username = map2["username"]//获取
println("$map2 = $username")

数组和集合的遍历(长度都一样 : 属性.size)

遍历:

//1. Array
val arr = arrayOf(1, 2, 3)
for (i in arr) {
    println(i)
}
for (i in 0 until arr.size) {//不包含arr.size
    println(i)
}
for (i in list.size-1 downTo 0) {//倒序输出
    println(arr[i])
}
for (i in 0..arr.size) {//包含arr.size
    println(i)
}
for (i in arr.indices) {
    println(arr[i])
}

//2, List
val list = mutableListOf<Int>(1, 2, 3)
for (i in 0 until list.size) {
    print(list[i])
}
for (i in list.size-1 downTo 0) {
    println(list[i])
}
for (i in list) {
    println(i)
}
 
for (i in list.indices) {
    println(list[i])
}

//3, Set
val set = mutableSetOf<Int>(1, 2, 3)
for (i in 0 until set.size) {
    println(set.elementAt(i))
}
for (i in set) {
    println(i)
}
for (i in set.indices) {
    println(set.elementAt(i))
}

//4, Map
val map = mutableMapOf<Int, Int>(1 to 1, 2 to 2, 3 to 3)// 1 to 2使用了中缀表达式, 对应Pair对象
 
for (mutableEntry in map) {
    println("${mutableEntry.key} = ${mutableEntry.value}")
}
 
for (i in map.entries) {
    println("${i.key} = ${i.value}")
}
for (key in map.keys) {
    println("$key = ${map[key]}")
}

数组的常用操作符总结

集合转换为数组

集合类提供了toIntArray()、toDoubleArray()、toFloatArray()、toBetArray()等高阶函数去处理。

val list = listOf<Int>(1,2,3,4,5,6)         // 声明一个Int类型的List
val listArray = list.toIntArray()           // 转换
println(list.javaClass.toString())          // 打印list的类型
println(listArray.javaClass.toString())     // 打印listArray的类型
println(listArray[1])

数组转换为集合

val arr = arrayOf(1,3,5,7,9)

val list = arr.toList()

操作类

  contains(元素) : 检查集合中是否包含指定的元素，若存在则返回true，反之返回false

  elementAt(index) : 获取对应下标的元素。若下标越界，会抛出IndexOutOfBoundsException（下标越界）异常，同  get(index)一样

  elementAtOrNull(index) : 获取对应下标的元素。若下标越界，返回null

  first() : 获取第一个元素，若集合为空集合，这会抛出NoSuchElementException异常

  first{} : 获取指定元素的第一个元素。若不满足条件，则抛出NoSuchElementException异常

  firstOrNull() : 获取第一个元素，若集合为空集合，返回null

  firstOrNull{} : 获取指定元素的第一个元素。若不满足条件，返回null

  last() : 获取最后一个元素，若集合为空集合，这会抛出NoSuchElementException异常

  last{} : 获取指定元素的最后一个元素。若不满足条件，则抛出NoSuchElementException异常

  lastOrNull{} : 获取最后一个元素，若集合为空集合，返回null

  lastOrNull() : 同firstOrNull{}相反

  indexOf(元素) : 返回指定元素的下标，若不存在，则返回-1

  indexOfFirst{...} : 返回第一个满足条件元素的下标，若不存在，则返回-1

  indexOfLast{...} : 返回最后一个满足条件元素的下标，若不存在，则返回-1

  forEach{...} : 遍历元素。一般用作元素的打印

  componentX() ： 用于获取元素。其中的X代表序号， 从0开始

排序操作符

    val list = mutableListOf<Int>(1, 34, 6, 7, 4)
//  reverse()对原有集合排序，没有返回值 , reversed()返回一个新数组 : 反序。即和初始化的顺序反过来。
    println(list.reversed())
 
//  sort()对原有集合排序 sorted()排序后， 生成一个新数组 : 自然升序。
    list.sort()
    println(list.sorted())
 
//  sortedBy{} : 根据条件升序，即把不满足条件的放在前面，满足条件的放在后面
    list.sortBy { it < 7 }
    println(list)
//  sortedDescending() : 自然降序。
    val list2 = list.sortedDescending()
    println(list2)
//  sortedByDescending{} : 根据条件降序, 即把不满足条件的放在后面，满足条件的放在前面
    val list3 = list.sortedByDescending { it > 6 }
    println(list3)

映射操作符

//map{...} : 把每个元素按照特定的方法进行转换，组成一个新的集合。一对一
val list = mutableListOf<String>("name", "password")
val list2 = list.map { it.plus("_add") }
println(list2)
//输出结果
// [name_add, password_add]
 
//mapNotNull{...} : 同map{}函数的作用相同，只是过滤掉转换之后为null的元素
val list3 = mutableListOf<String>("name", "password", "")
val list4 = list3.mapNotNull {
    if (it.contentEquals("")) {
        it.plus("_test")
    } else {
        it.plus("_add")
    }
}
println(list4)
//输出结果
// [name_add, password_add, _test]
 
//mapIndexed{index,result} : 把每个元素按照特定的方法进行转换，可以操作元素的下标(index)，组成一个新的集合。
val list6 = mutableListOf<Int>(1, 2, 3)
val list7 = list6.mapIndexed { index, result ->
    index.toString().plus("-").plus(result)
}
println(list7)
//输出结果
// [0-1, 1-2, 2-3]
 
//mapIndexedNotNull{index,result} : 同mapIndexed{}函数的作用相同，只是过滤掉转换之后为null的元素
//flatMap{...} : 根据条件合并两个集合，组成一个新的集合。 一对多
val list8 = mutableListOf<Int>(1, 2, 3, 4, 5)
val list9 = list8.flatMap {
    listOf(it, "a", "b")
}
println(list9)
[1, a, b, 2, a, b, 3, a, b, 4, a, b, 5, a, b]
 
//groupBy{...} : 分组。即根据条件把集合拆分为为一个Map<K,List<T>>类型的集合
val list10 = mutableListOf<Person>(Person("wwf", 12),
        Person("alex", 12),Person("eva", 23),
        Person("maggie", 23))
val map : Map<Int, List<Person>> = list10.groupBy {
    it.age//以年龄来分组
}
println(map)
//输出结果
// {12=[Person(name=wwf, age=12), Person(name=alex, age=12)],
// 23=[Person(name=eva, age=23), Person(name=maggie, age=23)]}

过滤操作符

val list = mutableListOf<Person>(
        Person("wwf", 12),
        Person("alex", 12),
        Person("jack", 23),
        Person("eva", 23),
        Person("jani", 18),
        Person("maggie", 18))
//filter{...} : 把不满足条件的元素过滤掉
val list2 = list.filter { it.name.contentEquals("wwf") }
println(list2)//[Person(name=wwf, age=12)]
 
//filterIndexed{...} : 和filter{}函数作用类似，只是可以操作集合中元素的下标（index）
val list3 = list.filterIndexed { index, person ->
    index > 1 && person.name.contentEquals("eva")
}
println(list3)
 
//filterNot{...} : 把满足条件的元素过滤掉， 和filter{}相反
//filterNotNull() : 过滤掉集合中为null的元素。
//take(num) : 返回集合中前num个元素组成的集合
val list4 = list.take(2)//取前两个
println(list4)
 
//takeWhile{...} : 循环遍历集合，从第一个元素开始遍历集合，当第一个出现不满足条件元素的时候，退出遍历。然后把满足条件所有元素组成的集合返回。
//takeLast(num) : 返回集合中后num个元素组成的集合
//takeLastWhile{...} : 循环遍历集合，从最后一个元素开始遍历集合，当第一个出现不满足条件元素的时候，退出遍历。然后把满足条件所有元素组成的集合返回。
//drop(num) : 过滤集合中前num个元素
//dropWhile{...} : 相同条件下，和执行takeWhile{...}函数后得到的结果相反
//dropLast(num) : 过滤集合中后num个元素
//dropLastWhile{...} : 相同条件下，和执行takeLastWhile{...}函数后得到的结果相反
//distinct() : 去除重复元素
//distinctBy{...} : 根据操作元素后的结果去除重复元素
val list5 = list.distinctBy { it.age }
println(list5) //[Person(name=wwf, age=12), Person(name=jack, age=23), Person(name=jani, age=18)]
 
//slice : 过滤掉所有不满足执行下标的元素。
val list6 = list.slice(0..3) //取前三个，和take(2)类似
println(list6)

生产操作符

val list1 = mutableListOf<Int>(1, 2, 3)
val list2 = mutableListOf<Int>(4, 5, 6)
//plus() : 合并两个集合中的元素，组成一个新的集合。也可以使用符号+
val list3 = list1.plus(list2)
println(list3) //[1, 2, 3, 4, 5, 6]
//zip : 由两个集合按照相同的下标组成一个新集合。该新集合的类型是：List<Pair>
val list4 = list1.zip(list2)
println(list4) // [(1, 4), (2, 5), (3, 6)]
//unzip : 和zip的作用相反。把一个类型为List<Pair>的集合拆分为两个集合。看下面的例子
val set = list1.union(list2)
println(set)
//partition : 判断元素是否满足条件把集合拆分为有两个Pair组成的新集合。
val list6 = listOf<Int>(1, 2, 3, 4, 5, 6)
val list5 = list6.partition {
    it > 3
}
println(list5) //([4, 5, 6], [1, 2, 3])

统计操作符，Android不常用， 练一下， 感受一下即可

any{...} : 判断集合中是否存在满足条件的元素。若存在则返回true,反之返回false

all{...} : 判断集合中的所有元素是否都满足条件。若是则返回true,反之则返回false

none{...} : 和all{...}函数的作用相反

max() : 获取集合中最大的元素，若为空元素集合，则返回null

maxBy{...} : 获取方法处理后返回结果最大值对应那个元素的初始值，如果没有则返回null

min() : 获取集合中最小的元素，若为空元素集合，则返回null

minBy{...} : 获取方法处理后返回结果最小值对应那个元素的初始值，如果没有则返回null

sum() : 计算出集合元素累加的结果。

sumBy{...} : 根据元素运算操作后的结果，然后根据这个结果计算出累加的值。

sumByDouble{...} : 和sumBy{}相似，不过sumBy{}是操作Int类型数据，而sumByDouble{}操作的是Double类型数据

average() : 获取平均数

reduce{...} : 从集合中的第一项到最后一项的累计操作。

reduceIndexed{...} : 和reduce{}作用相同，只是其可以操作元素的下标(index)

reduceRight{...} : 从集合中的最后一项到第一项的累计操作。

reduceRightIndexed{...} : 和reduceRight{}作用相同，只是其可以操作元素的下标(index)

fold{...} : 和reduce{}类似，但是fold{}有一个初始值

foldIndexed{...} : 和reduceIndexed{}类似，但是foldIndexed{}有一个初始值

foldRight{...} : 和reduceRight{}类似，但是foldRight{}有一个初始值

foldRightIndexed{...} : 和reduceRightIndexed{}类似，但是foldRightIndexed{}有一个初始值