丿灬安之若死

inline 介绍Kotlin inline 内联函数_安果移不动的博客-CSDN博客通过内联 ，函数可以直接插入到调用当中。这样会少调用一个Function函数。增加效率noinLine .局部关闭这个优化。来摆脱 不能把函数里欸选哪个的参数当对象的限制crossInline ：让内联函数里面的函数类型的参数可以被简介调用。代价是不能在Lambda表达式里面使用Retrun参考Kotlin 源码里成吨的 noinline 和 crossinline 是干嘛的？看完这个.

fun main() { create { "Derry" 123 true "AAAAA" }.map { println(it) it.replace("A","B") }.map { println(it) it.replace("B","C") }}//最初版本//inline fun <OUTPUT> create.

let 源码@kotlin.internal.InlineOnlypublic inline fun <T, R> T.let(block: (T) -> R): R { contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) } return block(this)}(T) -> R传入T返回R（T） 代表对本身的一个应用也是it 关键字的所在

ktclass KTHero { val translator = { utterance: String -> println(utterance) } val translator2 = { utterance: String ,test: Int-> println(utterance) println(test) }}javaimport kotlin.Unit;import kotlin

这里用到了 take函数他是从元数据里面取出来对应个数得元素并且返回如果没到这个元素也返回当前元素就是我要取出来1000个数据但是实际里面就是670个 那么他就会返回670个如果里面1001 个那么他就取出来1000个数据generateSequence般针对某个序列，你可能会定义一个只要序列有新值产生就被调用一下的函数，这样的函数叫迭代器函数。generateSequence 函数接受一个初始种子值作为序列的起步值，在用 generateSequence 定义的.

图中可以看到 .. 是左闭 右闭区间 范围 1-5000until 是 左闭 右开区间。也就是范围 1-4999

fun main() { val mList1 = arrayListOf(1, 2, 3, 4, 5) val mList2: ArrayList<Int> = arrayListOf() val mList = arrayListOf(1, 2, 2, 3, 4, 5) val mList3 = arrayListOf(0, 2, 4, 6, 8, 10) //any //判断集合元素，如果集合为空，返回false, 集合中存有一个或多个.

fun main() { val numbers1 = listOf<Int>(1, 2, 3, 4); // i 代表元素 acc 代表0 val res = numbers1.fold(0) { acc, i -> println("Accumlated value $acc") // 元素 acc + (i * 3) } println(res)// Accumlated value .

fun main() { val numbers1 = listOf<Int>(213, 4, 534, 646, 757, 8, 97, 9); val numbers2 = listOf<Int>(214, 5, 535, 647, 758, 9, 98, 10); val res=numbers1.zip(numbers2) println(res)}

fun main() { val numbers1 = listOf<Int>(213, 4, 534, 646, 757, 8, 97, 9); val numbers2 = listOf<Int>(214, 5, 535, 647, 758, 9, 98, 10); val numbers3 = listOf(numbers1, numbers2); val res = numbers3.flatMap { it }.fi.

fun main() { val numbers = listOf<Int>(213, 4, 534, 646, 757, 8, 97, 9); val newNumbers=numbers.map{ it+1 } println(newNumbers)}他的原理是复制出来一个新的函数出来。

质数是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。fun main() {//找素数 通常写法 val numbers = listOf<Int>(213, 4, 534, 646, 757, 8, 97, 9); val primes = numbers.filter { it.isPrime() } println(primes) //高阶函数引用 val primes2 = numbers.filter { numbe

。。闻所未闻？非也看apply函数public inline fun <T> T.apply(block: T.() -> Unit): T { contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) } block() return this}他的方法参数就是 block:T.()->Unit那么。什么意思呢首先我们先看下普通的扩展函数i

fun String.addExt(amount: Int = 1)=this + "!".repeat(amount);fun main(){ val res="abc".addExt(4) println(res)}使用场景：对没有带open的类无法进行集成修饰。或者系统已经定义好的类无法进行常规的修改。所以使用扩展函数字节码import kotlin.Metadata;import kotlin.Unit;import kotlin.jvm.inter..

class MagicBox<T : Human>(vararg item: T) { private var subject: Array<out T> = item var available = false //泛型作为返回类型参数 fun fetch(index: Int): T? { //available 为空就返回空 不然就返回实例本身 return subject[index].takeIf { av.

基本使用。两个泛型类型处理class MagicBox<T>(item: T) { private var subject: T = item var available = false //泛型作为返回类型参数 fun fetch(): T? { //available 为空就返回空 不然就返回实例本身 return subject.takeIf { available } } //多泛型参数 .

abstract class Gun(val range: Int) { abstract fun pullTrigger(): String protected fun doSomething() { }}//接口里面有必须要实现的接口 或者不需要强制实现的方法class AK47(val price: Int) : Gun(range = 500) { override fun pullTrigger(): String { doSomethi.

interface Movable { var maxSpeed: Int var wheels: Int fun move(movable: Movable): String}class Car(_name: String, override var wheels: Int = 4) : Movable { override var maxSpeed: Int get() = 1 set(value) {} override.

代数数据类型可以用来标识一组类型得闭集，枚举类型就是一种简单得ADTenum class LicenseStatus { UNQUALIFIED, LEARNING, QUALIFIED;}class Driver(var status: LicenseStatus) { fun checkLicense(): String { return when (status) { LicenseStatus.UNQUALIFIED ->

data class Coordinate(var x: Int, var y: Int) { operator fun plus(c2: Coordinate2) = Coordinate(x + c2.x, y + c2.y)}enum class Direction (private val coordinate:Coordinate){ EAST(Coordinate(1,0)), WEST(Coordinate(-1,0)), SOUTH(Coordinat.

重写加法让他支持加法data class Coordinate2(var x: Int, var y: Int) { operator fun plus(c2: Coordinate2) = Coordinate2(x + c2.x, y + c2.y)}fun main() { val c1 = Coordinate2(10, 20) val c2 = Coordinate2(10, 20) println(c1 + c2)}其他的一些重载写法.

//open 修饰的类才可以被继承open class Product(val name: String) { fun description() = "Product:$name" //open 修饰的方法才可以重载 open fun load() = "Nothing.."}class LuxuryProduct : Product("Luxury") { override fun load() = "Luxury"}fun main() { v.

一 注意属性与init中的调用顺序class Player6() { init { val bloodBonus = blood.times(4) } val blood = 100;}fun main() {}像java的静态代码块。和成员变量的顺序是可以这样的但是在kotlin中不行。因为Kotlin是根据代码顺序进行初始化的编译成字节码就会是这样顺便证明了。init的执行地方是构造方法初始化后。。可行的初始化..

package setimport java.util.*import kotlin.math.absoluteValue//临时变量 只是用一次推荐使用下划线开头class Player( _name: String, _age: Int, _isNormal: Boolean //构造参数) { //属性 var name = _name get() = field.replaceFirstChar { if (it.isLowerCase...

import java.util.*class Player { var name: String = "jack" get() = field.replaceFirstChar { if (it.isLowerCase()) it.titlecase(Locale.getDefault()) else it.toString() } set(value) { field = value.trim() }}fun m.

fun main() { //创建map val map = mapOf("Jacky" to 20, "Jason" to 18, "Jack" to 10); mapOf(Pair("Jimmy", 10), Pair("Jacky", "20")) //读取map的值 println(map["Jacky"]) println(map.getValue("Jason")) println(map.getOrElse("Rose") { "NoR.

package setfun main() { val set = setOf("Jason", "Jack", "Jacky", "Jack"); //set 获取元素 val element3 = set.elementAt(2) val mutableSet = mutableSetOf("Jason", "Jack", "Jacky", "Jack"); mutableSet += "Jimmy" var list = set.toList().

fun main() { val list = listOf("Jason", "Jack", "Jacky") val mutableListOf = mutableListOf("Jason", "Jack", "Jacky") mutableListOf.add("狗蛋") println(mutableListOf) //相当于add mutableListOf += "张三" println(mutableListOf) // 相当.

fun main() { val list = listOf("Jason", "Jack", "Jacky") val mutableListOf = mutableListOf("Jason", "Jack", "Jacky") mutableListOf.add("狗蛋") mutableListOf.remove("Jack") println(mutableListOf) //集合转换为可变集合 val res= list.toMutabl.

一般代码过程中。我们时常要注意数组是否越界正常的java写起来非常的冗余 val list = listOf("Jason", "Jack", "Jacky") println(list[3]) var res = "Unknow" if (list.size >= 4) { res = list[3] } println(res)返回 Unknow也是势在必得Kotlin 给我们提供了更便捷的函数fun mai

import java.io.Filefun main() { //take if 需要一个条件判断 满足则往下执行。不满足则返回null val fileContent: String? = File("copy.txt").takeIf { it.exists() && it.canRead() }?.readText(); println(fileContent)}...

/** * run函数的匿名函数里持有的是this */fun main() { val str = "Derry is OK" val r1 = str.run { true 54.355f } println(r1) //具名函数配黑run函数 // 具名函数判断长度 isLong //匿名函数配合run str.run { } //具名函数 val v2 = str ..

import java.util.*fun main() { val res = "1,2,3,4,5" val list = res.split(",") //c++解构 val (v1, v2, v3, v4, v5) = list; println("v1:$v1 v2:$v2 v3:$v3 v4:$v4")}数组可以解构对象也可以 val (name, price) = Book("Kotlin入门", 66.6f)非常好用.

kotlin 迷人的地方在于他可以直接传入函数。。。对标java 接口但是他超级`迷人`的地方就在于 他可以。。返回函数。。这就离谱了兄弟们。。这java想也不敢想啊来吧 上Demoimport java.util.*fun main() { val test = testRetrunFun(611) val test1 = test("什么jb 泡沫？", 404) println(test1)}fun testRetrunFun(int: In

Kotlin 集百家长于一身。。据我所知。。php laravel中也是可以这么引用类对象。。。好了进入正题正常情况下我们调用 inlineTest 方法会让代码不够优雅。import java.util.*fun main() { inlineTest() { result, code -> println("resout:$result code:$code") }}inline fun inlineTest(res: (String,

什么时候用到内联在方法参数中包含有 lambda的时候内联的作用是什么提高性能 我们废话不多说直接上代码不加内联import java.util.*fun main() { inlineTest() { result, code -> println("resout:$result code:$code") }}fun inlineTest(res: (String, Int) -> Unit) { res("错了错了",

或许你对他很陌生 那么看这样一段代码指向TODO()运行起来会怎么样呢运行上述代码是没事的。但是下面的代码就报错了package com.anguomob.learnconst val number=1001;fun main() { when(number){ 1-> TODO(); 1001-> TODO(); }}报错内容Exception in thread "main" kotlin.N...

布局文件 <AutoCompleteTextView android:id="@+id/edRealName" android:layout_width="match_parent" android:paddingEnd="16dp" android:layout_height="44dp" android:layo

https://developer.android.com/kotlin/parcelize?hl=zh-cn#ktsplugins { id("kotlin-parcelize")}import kotlinx.parcelize.Parcelize@Parcelizeclass User(val firstName: String, val lastName: String, val age: Int): Parcelable@Parcelize要求在主要构造函数中声明.

首先 also 英语是而且的意思also的源码是这样的@kotlin.internal.InlineOnly@SinceKotlin("1.1")public inline fun <T> T.also(block: (T) -> Unit): T { contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) } block(this) return this}