2020-06-09

kotlin基础

基础入门

声明变量

1
2
3

val a :String = "hello"

val b = 2

val：只读； var：可读写
自动类型推导

Long标记

必须大写L

1	val a = 222L

类型转换

int转long不能直接转（跟java不同）

1
2
3

val a = 2
val b :Long = a // error
val b :Long = a.toLong() //ok

无符号类型

java没有

UInt ，UShort，ULong

1
2
3

val a = 1u

val b = 10000000000u

String

val content = "hello kotlin"
val html = """
            <html>
                <title>
                </title>
                <body>
                    <div> $content </div>
                </body>
            </html>
            """.trimIndent()

Kotlin 中 “==”比较的是内容，“===” 比较的是引用
字符串拼接可以使用“$”
格式化string，如上所示，trimIndent()方法的作用是去掉公共的缩进

数组

/**
* 定义
*/
val a = intArrayOf(1, 2)
val b = IntArray(2) { it + 1 }
print(b.contentToString())
print(a.size)

val c = arrayOf("hello", "kotlin")
c[1] = "world"
println("${c[0]},${c[1]}")

/**
* 遍历
*/
val d = floatArrayOf(1f, 2f)
for (item in d) {
  print(item)
}

d.forEach { item ->
           print(item)
          }

//带下标
for (i in a.indices){
  print("$i ,${a[i]}")
}

/**
* 判断元素是否存在
*/
if (1f in d) {
  print("exist")
}

if (3f !in d) {
  print("not exist")
}

区间

/**
* 定义
*/
val a = 1..10 //[1,10]

val b = 1 until 10 //[1,10)

val c = 10 downTo 1 //[10,1]

val d = 1..10 step 2 //[1,3,5,6,9]

val e = 1.0..2.0 //连续的，DoubleRange

print(a.joinToString())

/**
* 判断是否存在
*/
if (1.1 in e) {
  print("exist")
}

/**
* 遍历
*/
for (i in a) {
  print(i)
}

集合框架

增加了不可变的集合

/**
 * 定义
 */
val listOf = listOf(1, 23) //不可变
val mutableListOf = mutableListOf<Int>()

val mapOf = mapOf("name" to "wzq", "age" to 18)
val mutableMapOf = mutableMapOf("name" to "wzq", "age" to 18)

/**
 * 添加
 */
mutableListOf.add(3)
mutableListOf += 4
mutableListOf -= 4

/**
 * 访问
 */
listOf[0]

mapOf["name"]
mapOf.get("age")

增加了一些语法糖 filter，map等

基于Java，类型别名typealias，给java中的java.util.ArrayList在kotlin中起了一个别名ArrayList

typealias ArrayList<E> = java.util.ArrayList<E>
typealias LinkedHashMap<K, V> = java.util.LinkedHashMap<K, V>
typealias HashMap<K, V> = java.util.HashMap<K, V>
typealias LinkedHashSet<E> = java.util.LinkedHashSet<E>
typealias HashSet<E> = java.util.HashSet<E>

新类型

/**
 * 新类型pair
 */
val pair = "key" to "value"
val pair1 = Pair("key", "value")

//读取内容
pair.first
pair.second
val (x, y) = pair //解构表达式


/**
 *  新类型triple
 */
val tt = Triple(1, 2, 3)
val (m, n, z) = tt  //解构表达式
tt.first
tt.second
tt.third

函数基本概念

kotlin的函数有自己的类型，所以是“一等公民”。可以赋值，传递并在合适的条件下调用。

方法跟函数（概念性）
定义在类中的函数是方法

函数类型，函数引用

// 类型 ()->Unit
// 引用	::foo
fun foo(){}  

// (String)->Int
// ::foo
fun foo(str:String):Int{}   

class Foo{
  // Foo.(String)->Long     (Foo,String)->Long
  // Foo::bar
  fun bar(str: String):Long{}
}

val f: ()->Unit = ::foo
val h: (Foo,String)->Long = Foo::bar

val foo = Foo()
val a: (String)->Long = foo::bar

//通过引用调用
a.invoke("wzq")
//或者
a("wzq")

参数：变长，默认，具名

/**
* 变长参数
*/
fun mutiParams(vararg mutiParam: Int): Int {
  return mutiParam.sum()
}

/**
* 默认参数
*/
fun defaltParams(name: String, type: Int = 1) {
  print("$name,$type")
}

@Test
fun test() {
  defaltParams("wzq")
  /**
  * 具名参数
  */
  defaltParams(name = "zpy", type = 2)
  print(mutiParams(1, 2))
}

多返回值（借助Pair，Triple）

类和接口

kotlin中默认都是public的

kotlin中类的成员变量必须初始化（在构造器中完成初始化，或者定义的时候直接赋值）

//默认是public的  
class SimpleClass {
   		/**
   		* 这里不用初始化是因为在构造器中完成了
   		**/
       private var x: Int
     	/**
     	* 这里的y必须初始化，kotlin强调类必须对自己的成员变量负责。
     	**/
       private var y: Int = 0
     	/**
     	* 构造器方式（副构造器）
     	**/
       constructor(x: Int) {
           this.x = x
     }
 }

构造器，分为主构造器跟副构造器。新建类实例的路径必须经过主构造器（如果有的话）

以上类从副构造器转为主构造器如下：
1
2
3
4
5
6
/**
* 主构造器
**/
class SimpleClass(private var x: Int) {
private var y: Int = 0
}

在kotlin定义一个属性 = get方法+set方法+属相

class SimpleClass(x: Int) {
    var x = x
    /**
     * 以下默认生成，需要自定义的话可以改成自己的逻辑
    */
    get() {
        return field //backing field
    }
    set(value) {
        field = value
    }
}

fun test() {
    val simpleClass = SimpleClass(1)

    /**
    * 属相引用
    */
    val kProperty1 = simpleClass::x
    kProperty1.set(2)
    print(kProperty1.get())
}

类中的方法默认都是final的，如果子类想要重写，那么需要在类的方法前面加open关键字
接口中可以定义属性

继承类跟接口使用“:”，类的话需要带主构造，具体如下：

abstract class AbstractClass {
 abstract fun xxx()
 open fun canReWrite() {}
    
  /**
  * 没有open子类不能重写
    */
    fun cannotReWrite() {}
}

interface Interface {
	fun yyy()

  /**
  * 接口可以定义属相
    */
    val y: Int
}


class SimpleClass(private val x: Int) : AbstractClass(), Interface {
  /**
  * 实现接口定义的属相y
    */
    override val y: Int
    get() = TODO("Not yet implemented")

  override fun yyy() {
	  TODO("Not yet implemented")
  }

  override fun xxx() {
	  TODO("Not yet implemented")
  }

  override fun canReWrite() {
    super.canReWrite()
    print("xxx")
  }
}

空安全类型&平台类型

fun test() {
    /**
     * a不可为null
     */
    var a: String = ""
      /**
     * b可以为null
     */
    var b: String? = ""
    /**
     * 报错
     */
    b.length
    /**
     * 安全访问 ?.
     * ?:  如果b为null那么b?.length 返回null，使用?:可以设置默认值
     */
    val length = b?.length ?: 0
    /**
     * 强转 !!  如果确认b不为null，那么可以强转
     */
    b!!.length

    /**
     * 平台类型 String! ：调用java中的方法返回java的String时，类型为String!,这时需要我们自己去判断是否				为空
     * 我们无法自己创建
     *
     * 如下返回的类型是 TimeZone！
     */
    val default = TimeZone.getDefault()
}

扩展方法&属相

kotlin支持在不修改类代码的情况下，动态为类添加属性（扩展属性）和方法（扩展方法）

扩展方法定义

class StringUtils {
    var name: String = "StringUtils"
}

fun StringUtils.CustomGetLenth(): Int {
    return this.name.length
}

fun main(args: Array<String>) {
    val lenth = StringUtils().CustomGetLenth()
}

扩展方法本质

public final class StringUtilsKt
{
  public static final int CustomGetLenth(@NotNull StringUtils $receiver)
  {
    Intrinsics.checkParameterIsNotNull($receiver, "receiver$0");return 			$receiver.getName().length();
  }
}

如果父类和子类都扩展了同名的一个扩展方法，引用类型均为父类的情况下，会调用父类的扩展方法。

扩展属相没有backing field，（接口中的属相也没有）
参考：https://www.cnblogs.com/nicolas2019/p/10932131.html

智能类型转换

a as B
a as? B (失败返回null)

a is B

open class Parent

class Son(val name: String) : Parent() {

}

fun test() {
    val x: Parent = Son("wzq")
    /**
     * x is Son 之后，如果返回true，那么x就已经强转完成了
     */
    if (x is Son) {
        print(x.name)
    }
}

if，when，try catch 是表达式

var b: Boolean = false

var a = if (b) 1 else 2

var c = when (b) {
  true -> 1
  false -> 2
}

var d = when {
  b -> 1
  else -> 2
}

var e = try {
  //xxx
  1
} catch (e: Exception) {
  2
}

LAMBDA 表达式

fun name() {
    print("xxx")
}

/**
 * 匿名函数(去掉名字)
 */
val func = fun() {
    print("xxx")
}

/**
 * lambda是一种特殊的匿名函数
 * () -> Unit
 */
val func1 = {
    print("xxx")
}

/**
 * (Int,String) -> String
 */
val func2 = { p: Int, p1: String ->
    print("$p1,$p")
    p1
}

/**
 * 如果只有一个参数的话用it就行
 */
val func3: (Int) -> Unit = {
    print("$it")
}

fun main() {
    /**
     * IntArray接收一个lambda表达式（只有一个参数）用来初始化数组
     */
    IntArray(5, { it })
    /**
     * 另一种格式,简化版
     */
    IntArray(5) { it }
}

== & hashcode

版本1:

class Person(var name: String, var age: Int)

fun main() {
    val hashSet = HashSet<Person>()
    (0..5).forEach {
        hashSet += Person("wzq", 18)
    }
    /**
     * 输出6
     */
    print(hashSet.size)
}

版本2:

class Person(var name: String, var age: Int) {
    override fun equals(other: Any?): Boolean {
        val person = other as? Person ?: return false
        return person.age == age && person.name == name
    }

    override fun hashCode(): Int {
        return age + name.hashCode()
    }
}

fun main() {
    val hashSet = HashSet<Person>()
    (0..5).forEach {
        hashSet += Person("wzq", 18)
    }
    /**
     * 输出1
     */
    print(hashSet.size)
}

版本3:

fun main() {
    val hashSet = HashSet<Person>()
    val person = Person("wzq", 18)
    hashSet += person
    /**
     * 输出1
     */
    print(hashSet.size)
    person.name = "zpy"
    hashSet -= person
    /**
     * 输出1
     */
    print(hashSet.size)
}

把Person的name跟age改为 val之后可以避免这种错误，因为val不允许修改

版本4:

class Person(val name: String, val age: Int) {
    override fun equals(other: Any?): Boolean {
        val person = other as? Person ?: return false
        return person.age == age && person.name == name
    }

    override fun hashCode(): Int {
        return age + name.hashCode()
    }
}

函数进阶

高阶函数

概念：参数是函数或者返回值是函数的函数

例子：

1 2	// IntArray的构造方法 public inline constructor(size: Int, init: (Int) -> Int)

内联函数

概念：在程序编译时能将程序中内联函数的调用表达式直接替换成内联函数的函数体。

例子：

fun doSomething(m: () -> Unit) {
    print("doSomething start")
    m()
    print("doSomething end")
}


fun main() {
    print("main start")
    doSomething { print("lambda") }
    print("main end")
}

转为java

public static final void main() {
  String var0 = "main start";
  System.out.print(var0);
  /**
  * 1. 调用了doSomething方法，2. new了一个Function0的实例
  **/
  doSomething((Function0)null.INSTANCE);
  var0 = "main end";
  System.out.print(var0);
}

doSomething添加inline之后转为java

public static final void main() {
  String var0 = "main start";
  System.out.print(var0);
      // 第一次内联：少了doSomething的调用
      String var7 = "doSomething start";
      System.out.print(var7);
          // 第二次内联，少了lambda函数的调用
          String var4 = "lambda";
          System.out.print(var4);
      var7 = "doSomething end";
      System.out.print(var7);
  var0 = "main end";
  System.out.print(var0);
}

相比较

少了新建实例的开销
少了方法调用（进出方法栈）的开销，一个是doSomething方法的调用，一个是lambda函数的调用

高阶函数跟内联函数更配

内联函数的局部return跟非局部return

fun main() {
    intArrayOf(1,2,3).forEach {
        if(it == 2)
      			/**
             * 局部return，这里相当于continue
             */
            return@forEach
        println(it)
    }
    println("bbb")
    return
}
// 打印结果
1
3
bbb

fun main() {
    intArrayOf(1,2,3).forEach {
        if(it == 2)
      			/**
      			* 全局return。直接退出main函数
      			**/
            return
        println(it)
    }
    println("bbb")
    return
}
// 打印结果
1

因为foreach是内联函数，转为java之后

public static final void main() {
     int[] $this$forEach$iv = new int[]{1, 2, 3};
     int[] var2 = $this$forEach$iv;
     int var3 = $this$forEach$iv.length;
  
     for(int var4 = 0; var4 < var3; ++var4) {
        int element$iv = var2[var4];
        if (element$iv == 2) {
           return;
        }
        System.out.println(element$iv);
     }
     String var9 = "bbb";
     System.out.println(var9);
  }

noinline关键字可以取消函数参数的内联

inline fun limit( noinline p1:()->Unit){
    print("limit")
    p1()
}

fun main() {
   limit { print("xxx")  }
}

转为java

public static final void main() {
  Function0 p1$iv = (Function0)null.INSTANCE;
  int $i$f$limit = false;
  //函数内联了
  String var2 = "limit";
  System.out.print(var2);
  //函数参数没有内联
  p1$iv.invoke();
}

crossinline关键字不允许非局部返回

非局部return的时候return的是调用的地方，lambda函数就没有了返回值，这种情况在某些情景下是有问题的，所以就有了crossinline关键字

为什么要有crossinline可以参考：https://blog.csdn.net/u013009899/article/details/78584994，这里有例子。

说白了，就是我们如果直接在lambda参数中结束当前函数，而不给lambda提供一个返回值，这种情况是不被允许的
内联函数的没有被声明为noinline的函数（lambda）参数不能被存储
1
2
3
4
inline fun limit(p1:()->Unit){
//编译出错
val a = p1
}

几个有用的高阶函数

let 返回值是block的返回值

比如fragment的oncreate方法中解析bundle的内容

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    arguments?.let { // it
        imageId = it.getInt(ARG_IMAGE)
        tip = it.getString(ARG_TIP)
        bgColor = it.getInt(ARG_BG_COLOR)
        smallBgImg = it.getInt(ARG_SMALL_BG_IMAGE)
    }
}

run 返回值是block的返回值

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    arguments?.run { //this
        imageId = getInt(ARG_IMAGE)
        tip = getString(ARG_TIP)
        bgColor = getInt(ARG_BG_COLOR)
        smallBgImg = getInt(ARG_SMALL_BG_IMAGE)
    }
}

also 返回值跟调用者是同一个实例

apply T.apply(block: T.() -> Unit): T 返回值跟调用者是同一个实例（比如下面例子，loadingDialog实例调用的，返回值还是那个实例）

例子1: fragment的newInstance方法

companion object {
    @JvmStatic
    fun newInstance(
        @DrawableRes imageId: Int,
        tip: String? = null,
        @ColorRes bgColor: Int = -1,
        @DrawableRes smallBgImg: Int = -1
    ) =
        LoadingDialog().apply { // this
            arguments = Bundle().apply { // this
                putInt(ARG_IMAGE, imageId)
                putString(ARG_TIP, tip)
                putInt(ARG_BG_COLOR, bgColor)
                putInt(ARG_SMALL_BG_IMAGE, smallBgImg)
            }
        }
}

例子2: build模式 ( OkHttpClient源码 )

fun addInterceptor(interceptor: Interceptor) = apply {
  interceptors += interceptor
}

fun addNetworkInterceptor(interceptor: Interceptor) = apply {
  networkInterceptors += interceptor
}

use

不用自己关闭流

File("build.gradle").inputStream().reader().buffered()
    .use {
        print(it.readLine())
    }

集合变换与序列

filter

过滤集合
map

元素一对一映射之后拼接
flatmap

每个元素映射为一个集合，之后把所有的集合拼接起来
asSequence

懒汉式序列

eg：饿汉式如下

arr.filter {
  println("filter $it")
  it % 2 == 0
}.map {
  println("map $it")
  it * 2
}.flatMap {
  println("flatMap $it")
  0..it
}.forEach {
  println("foreach $it")
}
//输出：
filter 1
filter 2
filter 3
filter 4
map 2
map 4
flatMap 4
flatMap 8
foreach 0
foreach 1
foreach 2
foreach 3
foreach 4
foreach 0
foreach 1
foreach 2
foreach 3
foreach 4
foreach 5
foreach 6
foreach 7
foreach 8

添加 asSequence之后变为懒汉，foreach类似水龙头开关，没有的话，啥也不会输出

arr.asSequence()
    .filter {
        println("filter $it")
        it % 2 == 0
    }.map {
        println("map $it")
        it * 2
    }.forEach {
        println("foreach $it")
    }

//输出：
filter 1
filter 2
map 2
foreach 4
filter 3
filter 4
map 4
foreach 8

sum 求和

reduce （没有初始值，返回值跟item一个类型）

源码：

public inline fun IntArray.reduce(operation: (acc: Int, Int) -> Int): Int {
    if (isEmpty())
        throw UnsupportedOperationException("Empty array can't be reduced.")
    var accumulator = this[0]
    for (index in 1..lastIndex) {
        accumulator = operation(accumulator, this[index])
    }
    return accumulator
}

例子：求和

val arr = intArrayOf(1, 2, 3, 4)
arr.reduce { acc, i ->
    acc + i
}

fold（给一个初始值，对每一个item做同样的operation,返回值跟初始值一个类型）

源码：

public inline fun <R> IntArray.fold(initial: R, operation: (acc: R, Int) -> R): R {
    var accumulator = initial
    for (element in this) accumulator = operation(accumulator, element)
    return accumulator
}

例子：求和

val arr = intArrayOf(1, 2, 3, 4)
val fold = arr.fold(0) { acc, i ->
    acc + i
}
print(fold)
//10

sam转换（single abstract method）

eg:匿名内部类Runnable

Thread(
    object : Runnable {
        override fun run() {
            print("run")
        }
    }
).start()

简写如下：

1
2
3

Thread(
    Runnable { print("run") }
).start()

SAM之后

1 2	Thread { print("run") } .start()

eg:设置点击监听

callWithDialog.setOnClickListener(object:View.OnClickListener{
  override fun onClick(v: View?) {
    println("onclick")
  }
})

sam之后，可以简写为

1	callWithDialog.setOnClickListener { println("onclick") }

调用java的时候可以，如果单方法接口是kotlin，那么不支持。

实例：统计文本中字符（不含空格）出现个数

File("build.gradle")
    .readText()
    .toCharArray()
    .filterNot {
        it.isWhitespace()
    }
    .groupBy { it }
    .map { it.key to it.value.size }
    .let {
        print(it)
    }

tip

this@MainActivity : 内部类获取context的方法