Kotlin基础(三)

文章目录

  • Kotlin基础(三)
    • 3.集合类
      • 3.1 不可变List
      • 3.2 可变集合MutableList
      • 3.3 遍历List元素
      • 3.4 List元素操作函数
      • 3.5 List集合类的函数算子(operator)
      • 3.6 过滤操作函数算子
      • 3.7 映射操作符
      • 3.8 分组操作符
      • 3.9 排序操作符
      • 3.10 生产操作符
      • 3.11 Set
      • 3.12 创建Set
      • 3.13 使用Java中的Set类
      • 3.15 Set元素的加减操作
      • 3.16 Map
      • 3.17 创建Map
      • 3.18 使用Java中的Set类
      • 3.19 访问Map的元素
      • 3.20 Map操作符函数
    • 参考资料

3.集合类

3.1 不可变List

  • 使用 listOf 函数来构建一个不可变的List（read-only，只读的List）。

    //空List，变量的类型不能省略
val list:List<Int> = listOf()
//只有1个元素的List
val list = listOf(1)
//有多个元素的List
val list = listOf(0,1, 2, 3, 4, 5, 6,7,8,9)
//可以使用 arrayListOf 函数创建一个Java中的ArrayList对象实例
val list = arrayListOf(0,1,2,3)

3.2 可变集合MutableList

  • MutableList中，除了继承List中的那些函数外，另外新增了add/addAll、remove/removeAll/removeAt、set、clear、retainAll等更新修改的操作函数。

  • 对于一个不可变的List，可以直接调用转换函数 toMutableList 转换成可变的List。

    val list = mutableListOf(1, 2, 3)
val mlist = list.toMutableList()
mlist.add(5)

3.3 遍历List元素

  • 使用Iterator迭代器：

    val list = listOf(0,1, 2, 3, 4, 5, 6,7,8,9)
val iterator = list.iterator()
while(iterator.hasNext()){println(iterator.next())
}

  • 使用 forEach ：

    val list = listOf(0,1, 2, 3, 4, 5, 6,7,8,9)
list.forEach{println(it)
}
//简写
list.forEach(::println)

  • 注：:: 是函数引用符。

3.4 List元素操作函数

  • add/addAll、remove/removeAll/removeAt、set、clear不介绍。

  • 取两个集合交集：retainAll

    val mlist1 = mutableListOf(1,2,3,4,5,6)
val mlist2 = mutableListOf(3,4,5,6,7,8,9)
mlist1.retainAll(mlist2)    //true
mlist1  //[3, 4, 5, 6]

  • 判断集合中是否有指定元素，有就返回true，否则返回false：contains(element: T): Boolean

  • 查找下标对应的元素：

    • elementAt(index: Int): T 越界会抛IndexOutOfBoundsException。
    • elementAtOrElse(index: Int, defaultValue: (Int) -> T): T 越界会根据方法返回默认值。
    • elementAtOrNull(index: Int): T? 越界返回null

  • 返回集合第1个元素：

    • first() 如果是空集，抛出异常NoSuchElementException。

    • firstOrNull(): T? 空集返回null

    • first(predicate: (T) -> Boolean): T 返回符合条件的第一个元素，没有则抛异常NoSuchElementException 。

      val list = listOf(1,2,3)
list.first({it%2==0})  //2

    • firstOrNull(predicate: (T) -> Boolean): T? 返回符合条件的第一个元素，没有就返回null。

  • 返回指定下标的元素，没有就返回-1：indexOf(element: T): Int

  • 返回第一个符合条件的元素下标，没有就返回-1 ：indexOfFirst(predicate: (T) -> Boolean): Int

  • 返回最后一个符合条件的元素下标，没有就返回-1 ：indexOfLast(predicate: (T) -> Boolean): Int

  • 返回集合最后1个元素：

    • last()
    • last(predicate: (T) -> Boolean): T
    • lastIndexOf(element: T): Int

  • 集合如果只有1个元素，则返回该元素,否则，抛异常：single(): T

  • 返回符合条件的单个元素，如有没有符合的抛异常NoSuchElementException，或超过一个的抛异常
    IllegalArgumentException：single(predicate: (T) -> Boolean): T

3.5 List集合类的函数算子(operator)

  • any()： 判断集合至少有一个元素，有则返回 true ，否则返回 false 。

  • any(predicate: (T) -> Boolean) ：判断集合中是否有满足条件的元素。

  • all(predicate: (T) -> Boolean)： 判断集合中的元素是否都满足条件。

  • none()：判断集合无元素，没有任何元素返回 true ，否则返回 false 。

  • **count()：**计算集合中元素的个数。

  • count(predicate: (T) -> Boolean) ：计算集合中满足条件的元素的个数。

  • reduce：从第一项到最后一项进行累计运算。

    /*** 首先把第一个元素赋值给累加子accumulator，然后逐次向后取元素累加，新值继续赋值给   * 累加子accumulator = operation(accumulator, iterator.next())，以此类推。* 最后返回累加子的值。
*/
val list = listOf(1,2,3,4,5,6,7,8,9)
list.reduce({sum, next->sum+next}) //45
list.reduce({sum, next->sum*next}) //362880

  • reduceRight：从最后一项到第一项进行累计运算。

    /*** accumulator = operation(iterator.previous(), accumulator)* 可以看出，从右边累计运算的累加子是放在后面的。
*/
val list = listOf("a","b","c")
list.reduceRight({total, s -> s+total})  //cba

  • fold(initial: R, operation: (acc: R, T) -> R)：R：带初始值的reduce。

    val list=listOf(1,2,3,4)
list.fold(100,{total, next -> next + total})    //110
/*** foldRight 和 reduceRight 类似，有初始值。
**/
val list = listOf("a","b","c")
list.foldRight("xyz",{s, pre -> pre + s}) //xyzcba

  • forEach(action: (T) -> Unit): Unit：循环遍历元素，元素是it。

    val list = listOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
list.forEach { value -> if (value > 7) println(value) } //8 9

  • forEachIndexed ：带index(下标) 的元素遍历。

    val list = listOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
list.forEachIndexed { index, value -> if (value > 8) println("value of index $index is $value, greater than 8") }
// value of index 9 is 9, greater than 8

  • max 、 min ：查询最大、最小的元素，空集则返回null。

  • maxBy(selector: (T) -> R): T? 、 minBy(selector: (T) -> R): T? ：获取函数映射结果的最大值、最小值对应的那个元素的值，如果没有则返回null。

    val list = listOf(100,-500,300,200)
list.maxBy({it})    //300
list.maxBy({it*(1-it)}) //100
list.maxBy({it*it}) //-500

  • sumBy(selector: (T) -> Int): Int： 获取函数映射值的总和。

    val list = listOf(1,2,3,4)
list.sumBy({it})    //10
list.sumBy({it*it}) //30

3.6 过滤操作函数算子

  • take(n: Int): List ：挑出该集合前n个元素的子集合。

    val list = listOf("a","b","c")
list.take(2)    //[a, b]
list.take(10)   //[a, b, c]
list.take(0)    //[]

  • takeWhile(predicate: (T) -> Boolean): List ：挑出满足条件的元素的子集合。

    val list = listOf(1,2,4,6,8,9)
list.takeWhile({it%2==0}) //[]
list.takeWhile({it%2==1}) //[1]
val list = listOf(2,4,6,8,9,11,12,16)
list.takeWhile({it%2==0}) //[2, 4, 6, 8]

  • takeLast ：挑出后n个元素的子集合。

  • takeLastWhile(predicate: (T) -> Boolean) ：从最后开始挑出满足条件元素的子集合。

  • drop(n: Int) ：去除前n个元素返回剩下的元素的子集合。

    val list = listOf(2,4,6,8,9,11,12,16)
list.drop(5)    //[11, 12, 16]
list.drop(100)  //[]

  • dropWhile(predicate: (T) -> Boolean) ：去除满足条件的元素返回剩下的元素的子集合。

    val list = listOf(2,4,6,8,9,11,12,16)
list.dropWhile({it%2==0}) //[9, 11, 12, 16]

  • dropLast(n: Int)：从最后去除n个元素。

  • dropLastWhile(predicate: (T) -> Boolean) ：从最后满足条件的元素。

  • slice(indices: IntRange)：取开始下标至结束下标元素子集合。

    val list = listOf(2,4,6,8,9,11,12,16)
list.slice(1..3)    //[4, 6, 8]

  • slice(indices: Iterable<Int>) ：返回指定下标的元素子集合。

    val list = listOf(2,4,6,8,9,11,12,16)
list.slice(listOf(2,4,6))   //[6, 9, 12]

  • filterTo(destination: C, predicate: (T) -> Boolean) ：过滤出满足条件的元素并赋值给destination。

    val list = listOf(1,2,3,4,5,6,7)
val dest = mutableListOf<Int>()
list.filterTo(dest,{it>3})   //[4, 5, 6, 7]
dest    //[4, 5, 6, 7]

  • filter(predicate: (T) -> Boolean) ：过滤出满足条件的元素组成的子集合。

  • filterNot(predicate: (T) -> Boolean) ：过滤所有不满足条件的元素

  • filterNotNull()：过滤掉 null 元素。

3.7 映射操作符

  • map(transform: (T) -> R): List<R>：将集合中的元素通过转换函数 transform 映射后的结果，存到一个集合中返回。

    val list = listOf(1,2,3,4,5,6,7)
list.map({it})  //[1, 2, 3, 4, 5, 6, 7]
list.map({it*it})   //[1, 4, 9, 16, 25, 36, 49]

  • mapIndexed(transform: (kotlin.Int, T) -> R)：转换函数 transform 中带有下标参数。可以同时使用下标和元素的值来进行转换。

    val list = listOf(1,2,3,4,5,6,7)
list.mapIndexed({index,it -> index*it})  //[0, 2, 6, 12, 20, 30, 42]

  • mapNotNull(transform: (T) -> R?)：遍历集合每个元素，得到通过函数算子transform映射之后的值，剔除掉这些值中的null，返回一个无null元素的集合。

  • flatMap(transform: (T) -> Iterable<R>): List<R>：在原始集合的每个元素上调用 transform 转换函数，得到的映射结果组成的单个列表。

    val list = listOf("a","b","c")
list.map({it->listOf(it+1,it+2,it+3)})
//[[a1, a2, a3], [b1, b2, b3], [c1, c2, c3]]
// 对比
list.flatMap({it->listOf(it+1,it+2,it+3)})
//[a1, a2, a3, b1, b2, b3, c1, c2, c3]//等价于
val list = listOf("a","b","c")
list.map({it->listOf(it+1,it+2,it+3)})
//[[a1, a2, a3], [b1, b2, b3], [c1, c2, c3]]
//对比
list.map({it->listOf(it+1,it+2,it+3)}).flatten()
//[a1, a2, a3, b1, b2, b3, c1, c2, c3]

3.8 分组操作符

  • groupBy(keySelector: (T) -> K): Map<K, List<T>>：将集合中的元素按照条件选择器 keySelector （是一个函数）分组，并返回Map。

    val words = listOf("a", "abc", "ab", "def", "abcd")
val lengthGroup = words.groupBy { it.length }
lengthGroup //{1=[a], 3=[abc, def], 2=[ab], 4=[abcd]}

  • groupBy(keySelector: (T) -> K, valueTransform: (T) -> V)：根据条件选择器keySelector和转换函数valueTransform分组。

    val programmer = listOf("K&R" to "C", "Bjar" to "C++", "Linus" to "C", "James" to "Java")
programmer
//[(K&R, C), (Bjar, C++), (Linus, C), (James, Java)]
programmer.groupBy({it.second}, {it.first})
//{C=[K&R, Linus], C++=[Bjar], Java=[James]}//另一个例子val words = listOf("a", "abc", "ab", "def", "abcd")
words.groupBy( { it.length })
//{1=[a], 3=[abc, def], 2=[ab], 4=[abcd]}
words.groupBy( { it.length },{it.contains("b")})
//{1=[false], 3=[true, false], 2=[true], 4=[true]}//另一个例子
val words = "one two three four five six seven eight nine ten".split(' ')
words.groupingBy({it.first()}).eachCount()
//{o=1, t=3, f=2, s=2, e=1, n=1}

3.9 排序操作符

  • reversed()：倒序排列集合元素。
  • sorted()：升序排序。
  • sortedDescending()：降序排序。
  • sortedBy() 和 sortedByDescending()：可变集合MutableList的排序操作。根据函数映射的结果进行升序排序和降序排序。

3.10 生产操作符

  • zip(other: Iterable<R>): List<Pair<T, R>>：两个集合按照下标配对，组合成的每个Pair作为新的List集合中的元素，并返回。如果两个集合长度不一样，取短的长度。

    val list1 = listOf(1,2,3)
val list2 = listOf(4,5,6,7)
val list3 = listOf("x","y","z")
list1.zip(list3)
//[(1, x), (2, y), (3, z)]
list3.zip(list1)
//[(x, 1), (y, 2), (z, 3)]
list2.zip(list3)
//[(4, x), (5, y), (6, z)] // 取短的长度
list3.zip(list2)
//[(x, 4), (y, 5), (z, 6)]
list1.zip(listOf<Int>())
//[]

  • zip(other) { t1, t2 -> t1 to t2 }:

    val list1 = listOf(1,2,3)
val list2 = listOf(4,5,6,7)
val list3 = listOf("x","y","z")
list1.zip(list3, {t1,t2 -> t2+t1})
//[x1, y2, z3]
list1.zip(list2, {t1,t2 -> t1*t2})
//[4, 10, 18]

  • unzip(): Pair<List<T>, List<R>>：作用在元素是Pair的集合类上。依次取各个Pair元素的first, second值，分别放到List、List中，然后返回一个first为List，second为List的大的Pair。

    val listPair = listOf(Pair(1,2),Pair(3,4),Pair(5,6))
listPair
//[(1, 2), (3, 4), (5, 6)]
listPair.unzip()
//([1, 3, 5], [2, 4, 6])

  • partition(predicate: (T) -> Boolean): Pair<List<T>, List<T>>：根据判断条件是否成立，将集合拆分成两个子集合组成的 Pair。

    val list = listOf(1,2,3,4,5,6,7,8,9)
list.partition({it>5})
//([6, 7, 8, 9], [1, 2, 3, 4, 5])

  • plus(elements: Iterable): List：合并两个List。

    val list1 = listOf(1,2,3)
val list2 = listOf(4,5)
list1.plus(list2)
//[1, 2, 3, 4, 5]
list1+list2 //可以用”+”替代 。
//[1, 2, 3, 4, 5]

  • plusElement(element: T): List<T>：在集合中添加一个元素。

3.11 Set

  • Kotlin中的Set也分为：不可变Set和支持增加和删除的可变MutableSet。

3.12 创建Set

//空集
val emptySet = emptySet<Int>()
emptySet    //[]
emptySet.size   //0
emptySet.isEmpty()  //true
emptySet.hashCode() //0//非空集
val set = setOf(1,1,2,3,3)
val s = setOf<Int>(1)//list 转 set  (可去重)
list.toSet()    //[1, 2, 3]

3.13 使用Java中的Set类

val hs = hashSetOf(1,3,2,7)
hs::class
//class java.util.HashSet
val ls = linkedSetOf(1,3,2,7)
ls::class
//class java.util.LinkedHashSet
val ms = mutableSetOf(1,3,2,7)
ms::class
//class java.util.LinkedHashSet
val ss = sortedSetOf(1,3,2,7)
ss::class
//class java.util.TreeSet
  • HashSet : 该类按照哈希算法来存取集合中的对象**，存取速度较快**。
  • TreeSet : 该类实现了SortedSet接口，能够对集合中的对象进行排序。
  • LinkedHashSet：具有HashSet的查询速度，且内部使用链表维护元素的顺序，在对Set元素进行频繁插入、删除的场景中使用。

3.15 Set元素的加减操作

val ms = mutableSetOf(1,3,2,7)
ms+10
//[1, 3, 2, 7, 10]
ms-1
//[3, 2, 7]
ms + listOf(8,9)
//[1, 3, 2, 7, 8, 9]
ms - listOf(8,9)
//[1, 3, 2, 7]
ms - listOf(1,3)
//[2, 7]

3.16 Map

  • Map是一种把键对象Key和值对象Value映射的集合。
  • Kotlin中的Map与List、Set一样，Map也分为只读Map和可变的MutableMap。

3.17 创建Map

//创建一个只读空Map
val map1 = mapOf<String, Int>()
map1.size   //0
map1.isEmpty()  //true
//方式2
val map2 = emptyMap<String, Int>()
map2.size   //0
map2.isEmpty()  //true
//空Map都是相等的
map2==map1
true//使用二元组Pair创建一个只读Map
val map = mapOf(1 to "x", 2 to "y", 3 to "z")
map //{1=x, 2=y, 3=z}
map.get(1)  //x
map.entries //[1=x, 2=y, 3=z]//创建一个空的可变的Map
val map = mutableMapOf<Int, Any?>()
map.isEmpty()   //true
map[1] = "x"
map[2] = 1
map     //{1=x, 2=1}//创建一个非空的可变的Map
val map = mutableMapOf(1 to "x", 2 to "y", 3 to "z")
map     //{1=x, 2=y, 3=z}
map[1]="a"
map     //{1=a, 2=y, 3=z}
  • 如果Map中有重复的key键，后面的会直接覆盖掉前面的。

3.18 使用Java中的Set类

  • 创建HashMap对象。Kotlin直接使用的是Java的HashMap。
val map: HashMap<Int, String> = hashMapOf(1 to "x", 2 to "y", 3 to "z")
map     //{1=x, 2=y, 3=z}

  • 创建空对象LinkedHashMap。直接使用的是Java中的LinkedHashMap。

  • 创建带二元组Pair元素的LinkedHashMap对象。直接使用的是Java中的LinkedHashMap。

    val map: LinkedHashMap<Int, String> = linkedMapOf()
map     //{}val map: LinkedHashMap<Int, String> = linkedMapOf(1 to "x", 2 to "y", 3 to "z")
map     //{1=x, 2=y, 3=z}

  • 创建一个根据Key升序排序好的TreeMap。对应的是使用Java中的SortedMap。

    val map = sortedMapOf(Pair("c", 3), Pair("b", 2), Pair("d", 1))
map     //{b=2, c=3, d=1}

3.19 访问Map的元素

  • 访问entries属性：
val map = mapOf("x" to 1, "y" to 2, "z" to 3)
map     //{x=1, y=2, z=3}
map.entries     //[x=1, y=2, z=3]
map.entries.forEach({println("key="+ it.key + " value=" + it.value)})
//key=x value=1
//key=y value=2
//key=z value=3

  • 访问keys属性：

    map.keys //[x, y, z]

  • 访问values属性：

    map.values        //[1, 2, 3]

  • size属性：

    map.size      //3

  • get(key: K)：使用get函数来通过key来获取value的值，对应的操作符是 [] ：

    map["x"]    //1
map.get("x")  //1
//如果这个key不在Map中，就返回null
map["k"]  //null
//不想返回null，可以使用getOrDefault函数,设置的一个默认值,默认值的类型要对应
map.getOrDefault("k",0)       //0

3.20 Map操作符函数

  • containsKey(key: K): Boolean：是否包含该key。

  • containsValue(value: V): Boolean：是否包含该value。

  • component1()、 component2()：Map.Entry<K, V> 的操作符函数，分别用来直接访问key和value。

    val map = mapOf("x" to 1, "y" to 2, "z" to 3)
map.entries.forEach({println("key="+ it.component1() + " value=" + it.component2())})
//key=x value=1
//key=y value=2
//key=z value=3

  • Map.Entry<K, V>.toPair(): Pair<K, V>：把Map的Entry转换为Pair。

    map.entries       //[x=1, y=2, z=3]
map.entries.forEach({println(it.toPair())})
//(x, 1)
//(y, 2)
//(z, 3)

  • getOrElse(key: K, defaultValue: () -> V): V：通过key获取值，当没有值可以设置默认值。

  • getValue(key: K): V：当Map中不存在这个key，调用get函数，如果不想返回null，直接抛出异常，可调用此方法。

  • getOrPut(key: K, defaultValue: () -> V): V：如果不存在这个key，就添加这个key到Map中，对应的value是defaultValue。

  • iterator(): Iterator<Map.Entry<K, V>>：返回的是 entries.iterator() 。

    val map = mapOf("x" to 1, "y" to 2, "z" to 3 )
for((k,v) in map){println("key=$k, value=$v")}
//key=x, value=1
//key=y, value=2
//key=z, value=3

  • mapKeys(transform: (Map.Entry<K, V>) -> R): Map<R, V>：把Map的Key设置为通过转换函数transform映射之后的值。

    val map:Map<Int,String> = mapOf(1 to "a", 2 to "b", 3 to "c", -1 to "z")
val mmap = map.mapKeys{it.key * 10}
mmap    //{10=a, 20=b, 30=c, -10=z}/*** 注意* 如果不巧，有任意两个key通过映射之后相等了，那么后面的key将会覆盖掉前面的key。**/

  • mapValues(transform: (Map.Entry<K, V>) -> R): Map<K, R>：把Map的value设置为通过转换函数transform转换之后的新值。

    val map:Map<Int,String> = mapOf(1 to "a", 2 to "b", 3 to "c", -1 to "z")
val mmap = map.mapValues({it.value + "$"})
mmap    //{1=a$, 2=b$, 3=c$, -1=z$}

  • filterKeys(predicate: (K) -> Boolean): Map<K, V>：返回过滤出满足key判断条件的元素组成的新Map。

    val map:Map<Int,String> = mapOf(1 to "a", 2 to "b", 3 to "c", -1 to "z")
map.filterKeys({it>0})       //{1=a, 2=b, 3=c}

  • filterValues(predicate: (V) -> Boolean): Map<K, V>：返回过滤出满足value判断条件的元素组成的新Map。

    val map:Map<Int,String> = mapOf(1 to "a", 2 to "b", 3 to "c", -1 to "z")
map.filterValues({it>"b"})     //{3=c, -1=z}

  • filter(predicate: (Map.Entry<K, V>) -> Boolean): Map<K, V>：返回过滤出满足Entry判断条件的元素组成的新Map。

    val map:Map<Int,String> = mapOf(1 to "a", 2 to "b", 3 to "c", -1 to "z")
map.filter({it.key>0 && it.value > "b"})        //{3=c}

  • Iterable<Pair<K, V>>.toMap(destination: M): M：把持有Pair的Iterable集合转换为Map。

    val pairList = listOf(Pair(1,"a"),Pair(2,"b"),Pair(3,"c"))
pairList    //[(1, a), (2, b), (3, c)]
pairList.toMap()    //{1=a, 2=b, 3=c}

  • Map<out K, V>.toMutableMap(): MutableMap<K, V>：把一个只读的Map转换为可编辑的MutableMap。

  • plus、 minus：

    val map = mapOf(1 to "a", 2 to "b", 3 to "c", -1 to "z")
map+Pair(10,"g")
//{1=a, 2=b, 3=c, -1=z, 10=g}
map + listOf(Pair(9,"s"),Pair(10,"w"))
//{1=a, 2=b, 3=c, -1=z, 9=s, 10=w}
//map + arrayOf(Pair(9,"s"),Pair(10,"w"))
{1=a, 2=b, 3=c, -1=z, 9=s, 10=w}
map + sequenceOf(Pair(9,"s"),Pair(10,"w"))
//{1=a, 2=b, 3=c, -1=z, 9=s, 10=w}
map + mapOf(9 to "s", 10 to "w")
//{1=a, 2=b, 3=c, -1=z, 9=s, 10=w}

  • put(key: K, value: V): V?：根据key设置元素的value。如果该key存在就更新value；不存在就添加，但是put的返回值是null。

  • putAll(from: Map<out K, V>): Unit：把一个Map全部添加到一个MutableMap中。

    val map = mutableMapOf(1 to "a", 2 to "b", 3 to "c", -1 to "z")
val map2 = mapOf(99 to "aa", 100 to "bb")
map.putAll(map2)
map //{1=a, 2=b, 3=c, -1=z, 99=aa, 100=bb}//如果有key重复的，后面的值会覆盖掉前面的值。

  • MutableMap<out K, V>.remove(key: K): V?：根据键值key来删除元素。

  • MutableMap<K, V>.clear(): Unit：清空MutableMap。

参考资料

  • Kotlin极简教程

Kotlin基础(三)相关推荐

  1. 第一章 kotlin基础知识

    第一章 kotlin基础知识 文章目录 第一章 kotlin基础知识 前言 一.kotlin是什么? 二.kotlin基础知识 1.变量的声明 2.函数定义的几种方式 3.字符串与数字的转换 4.数组 ...

  2. Kotlin基础学习（1）

    Kotlin基础学习(1) 本文主要讲解kotlin的部分基础知识,并不是全部基础. 提示:纯属个人理解,如有理解错误,欢迎留言指正批评. 一.Null检查机制 kotlin对于声明可为空的参数,使用 ...

  3. Kotlin 基础——Map集合详解

    Kotlin基础--Map集合详解 一.声明和创建Map集合 二.使用Map的方法 三.遍历Map四种方式 四.可变的Map Kotlin的Map集合用于保存key-value对,其也被分为可变的和不 ...

  4. Kotlin Bootcamp 自学（2）：Kotlin基础

    Kotlin Bootcamp 自学(2):Kotlin基础 目录 Kotlin Bootcamp 自学(2):Kotlin基础 前言 运算符与数据类型 (Operators and Types) 数 ...

  5. Kotlin基础 字符串操作与数字类型转换、标准库函数

    一.字符串操作 1.substring 字符串截取,substring函数支持IntRange类型(表示一个整数范围的类型)的参数,until创建的范围不包括上限值(包前不包后). const val ...

  6. Kotlin 基础——Set集合详解

    Kotlin基础--Set集合详解 一.声明和创建 二.使用Set的方法 三.遍历Set 四.可变的Set 4.1.添加元素 4.2.删除元素 Kotlin的集合类由两个接口派生:Collection ...

  7. Kotlin Jetpack 实战：01. Kotlin 基础

    背景 近几年,Android 相关的新技术层出不穷.往往这个技术还没学完,下一个新技术又出来了.很多人都是一脸黑人问号?不少开发者甚至开始哀嚎:"求求你们别再创造新技术了,我们学不动了!&q ...

  8. Kotlin基础 （二）

    Kotlin基础 (二) 11_kotlin命令行交互式终端 12_kotlin函数加强 函数的本质 kotlin函数编写规则 实战编写一个计算器: 作业练习 14_kotlin字符串模版 15_ko ...

  9. Kotlin基础语法（上）

    文章目录 Kotlin基础语法(下) Kotlin基础语法(上) 输出Hello world!!! 变量与输出 kotlin常见数据类型 变量的取值范围 kotlin函数 kotlin布尔类型 kot ...

最新文章

  1. Shell 脚本知识回顾 (五) —— Shell 循环
  2. easyui(一) 初始easyui
  3. Win11如何查看电池情况 Win11查看电池情况的方法
  4. 根据select的选项不同跳转到不同的页面
  5. 如何从超级用户进入非超级用户
  6. Angular Taskmgr 登录
  7. vscode自动整理代码_再见了， VS Code！
  8. C语言 谭浩强第五版 课后习题解答
  9. C语言实现二维伊辛模型的蒙特卡罗方法模拟
  10. 2ASK调制解调实验
  11. 虚拟现实计算机理论文献,虚拟现实在计算机教学中的应用研究
  12. python读取文本两个数字的成语_只要2步！将搜狗词库(scel)转为Python可读的文本...
  13. 游戏设计师：如何对待高考倒数100天
  14. 微信公众号开发 - 开发环境搭建
  15. 解决UnicodeDecodeError: ‘utf-8‘ codec can‘t decode byte 0xc8 in position 0: invalid continuation byte
  16. 刹车离合同时踩非常危险
  17. 骨牌铺方格java_[ACM_HDU_2046]骨牌铺方格 | 学步园
  18. 论文格式检测网站经验总结第一弹
  19. 上海水务局智慧水务解决方案
  20. 【AHK】微信自定义快捷键/微信体验优化/微信常用快捷键

热门文章

  1. 什么是拷贝构造函数?拷贝构造函数何时被调用
  2. SEED Labs信息安全实验
  3. UVA514 Rails
  4. 在jasperreports中自定义字体
  5. 三百左右的蓝牙耳机哪款好？三百左右的蓝牙耳机推荐
  6. 威客理论看维基经济学的三个漏洞
  7. PCL点云与深度图像
  8. SCVMM 2012R2 集群 升级 2016 后 问题解决记录 -- 日常维护
  9. elasticsearch数据库搭建 linux版
  10. DataFound 2019用户画像竞赛分析