1.Java 里的 int 是 unbox 的，而 Integer 是 box 的：

☕️
int a = 1;
Integer b = 2; // 👈会被自动装箱 autoboxing
Java
Kotlin 里，Int 是否装箱根据场合来定：

🏝️
var a: Int = 1 // unbox
var b: Int? = 2 // box
var list: List<Int> = listOf(1, 2) // box


2.Java 中的数组和 Kotlin 中的数组的写法也有区别：

☕️
int[] array = new int[] {1, 2};
Java
而在 Kotlin 里，上面的写法是这样的：

🏝️
var array: IntArray = intArrayOf(1, 2)
// 👆这种也是 unbox 的

🏝️
fun main() {
    var activity: Activity = NewActivity()
    // 👇'(activity as? NewActivity)' 之后是一个可空类型的对象，所以，需要使用 '?.' 来调用
    (activity as? NewActivity)?.action()
}

🏝️
activity as? NewActivity
activity as NewActivity?
activity as? NewActivity?

@Test
   fun test() {
       val str = "hello"
       //str as Context
       //str as? Context
       str as? Context?

       /*
       1.直接抛异常 : java.lang.ClassCastException: java.lang.String cannot be cast to android.content.Context
       2.通过
       3.通过

       此时 : val str="hello"  -> val str=null
       str as? Context? 和 str 是等效的
        */

   }

🏝️
👇
val size: Int
    get() { // 👈 每次获取 size 值时都会执行 items.size
        return items.size
    }

发现不同点有：

Kotlin 的常量必须声明在对象（包括伴生对象）或者「top-level 顶层」中，因为常量是静态的。
Kotlin 新增了修饰常量的 const 关键字。
除此之外还有一个区别：

Kotlin 中只有基本类型和 String 类型可以声明成常量。
原因是 Kotlin 中的常量指的是 「compile-time constant 编译时常量」，它的意思是「编译器在编译的时候就知道这个东西在每个调用处的实际值」，因此可以在编译时直接把这个值硬编码到代码里使用的地方。


Java 中的常量可以认为是「伪常量」，因为可以通过上面这种方式改变它内部的值。而 Kotlin 的常量因为限制类型必须是基本类型，所以不存在这种问题，更符合常量的定义。

listOf() 创建不可变的 List，mutableListOf() 创建可变的 List。可通过 toMutableList 由不可变转成可变集合:
🏝️
val strList = listOf("a", "b", "c")
            👇
strList.toMutableList()

👉 toMutable*() 返回的是一个新建的集合，原有的集合还是不可变的，所以只能对函数返回的集合修改。

在 Java 中，外部类可以访问内部类的 private 变量：

☕️
public class Outter {
    public void method() {
        Inner inner = new Inner();
                            👇
        int result = inner.number * 2; // success
    }

    private class Inner {
        private int number = 0;
    }
}
Java
在 Kotlin 中，外部类不可以访问内部类的 private 变量：

🏝️
class Outter {
    fun method() {
        val inner = Inner()
                            👇
        val result = inner.number * 2 // compile-error: Cannot access 'number': it is private in 'Inner'
    }

    class Inner {
        private val number = 1
    }
}

fun b(param: Int): String {
    return ""
}
val d = ::b
val e = d

d(1) // 实际上会调用 d.invoke(1)
(::b)(1) // 实际上会调用 (::b).invoke(1)

🏝️
// 方法一，使用 runBlocking 顶层函数
runBlocking {
    getImage(imageId)
}

// 方法二，使用 GlobalScope 单例对象
//            👇 可以直接调用 launch 开启协程
GlobalScope.launch {
    getImage(imageId)
}

// 方法三，自行通过 CoroutineContext 创建一个 CoroutineScope 对象
//                                    👇 需要一个类型为 CoroutineContext 的参数
val coroutineScope = CoroutineScope(context)
coroutineScope.launch {
    getImage(imageId)
}

🏝️
launch(Dispatchers.Main) {              // 👈 在 UI 线程开始
    val image = getImage(imageId)
    avatarIv.setImageBitmap(image)     // 👈 执行结束后，自动切换回 UI 线程
}
//                               👇
suspend fun getImage(imageId: Int) = withContext(Dispatchers.IO) {
    ...
}

🏝️ 「协作式任务」
coroutineScope.launch(Dispatchers.Main) {
    //            👇  async 函数之后再讲
    val avatar = async { api.getAvatar(user) }    // 获取用户头像
    val logo = async { api.getCompanyLogo(user) } // 获取用户所在公司的 logo
    val merged = suspendingMerge(avatar, logo)    // 合并结果
    //                  👆
    show(merged) // 更新 UI
}

buildscript {
    ...
    // 👇
    ext.kotlin_coroutines = '1.3.1'
    ...
}

dependencies {
    ...
    //                                       👇 依赖协程核心库
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlin_coroutines"
    //                                       👇 依赖当前平台所对应的平台库
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$kotlin_coroutines"
    ...
}

🏝️
coroutineScope.launch(Dispatchers.Main) {
    //                      👇  async 函数启动新的协程
    val avatar: Deferred = async { api.getAvatar(user) }    // 获取用户头像
    val logo: Deferred = async { api.getCompanyLogo(user) } // 获取用户所在公司的 logo
    //            👇          👇 获取返回值
    show(avatar.await(), logo.await())                     // 更新 UI
}

🏝️
public suspend fun await(): T

🏝️
// 主线程中
GlobalScope.launch(Dispatchers.Main) {
  val image = suspendingGetImage(imageId)  // 获取图片
  avatarIv.setImageBitmap(image)           // 显示出来
}

suspend fun suspendingGetImage(id: String) = withContext(Dispatchers.IO) {
  ...
}

🏝️
handler.post {
  val image = suspendingGetImage(imageId)
  avatarIv.setImageBitmap(image)
}

GlobalScope.launch(Dispatchers.Main) {
    Log.w("coroutines","launch ${Thread.currentThread().name}")
    val bitmap = getSuspendImage()
    Log.w("coroutines","launch getImage Ok")
    iv1.setImageBitmap(bitmap)
    val bitmapHalf2 = Bitmap.createBitmap(bitmap, 0, 0, bitmap.width / 2, bitmap.height / 2)
    iv2.setImageBitmap(bitmapHalf2)
    val bitmapHalf3 = Bitmap.createBitmap(bitmap, 0, 0, bitmap.width / 3, bitmap.height / 3)
    iv3.setImageBitmap(bitmapHalf3)
}

private suspend fun getSuspendImage(): Bitmap = withContext(Dispatchers.IO) {
    Log.w("coroutines","suspend ${Thread.currentThread().name}")
    OkHttpClient()
            .newCall(Request.Builder()
                    .url("http://oss.tuyuing.com/TUYU/trend/20190930/trend257401569854904487.jpeg")
                    .get()
                    .build())
            .execute().body?.byteStream().use {
                Log.w("coroutines","suspend getImage Ok")
                BitmapFactory.decodeStream(it)
            }
}

Log :
W/coroutines: launch main
W/coroutines: suspend DefaultDispatcher-worker-1
W/coroutines: suspend getImage Ok
W/coroutines: launch getImage Ok

(Int::toFloat)(1)
Int::toFloat.invoke(1)
1.toFloat()
1.toFloat().invoke()

//扩展函数
fun String.method1(i: Int) {}

//扩展属性
val Float.dp
    get() = TypedValue.applyDimension(
        TypedValue.COMPLEX_UNIT_DIP,
        this,
        Resources.getSystem().displayMetrics
    )

val str: String.(Int) -> Unit = String::method1
val str2: (String, Int) -> Unit = String::method1
fun strTest() {
    str("hello", 1)
    str.invoke("hello", 1)
    "".method1(1)
}

//also
fun strTest2() {
    fun String.method1(i: Int) {
    }
    val str: String.(Int) -> Unit = String::method1
    val str2: (String, Int) -> Unit = String::method1
    "hello".method1(100)
}

Global.kt
fun method2(s:String,i: Int) {}  比 method1 多了一个 String 参数

MainActivity.kt
val str3: String.(Int) -> Unit = ::method2
val str4: (String, Int) -> Unit = ::method2