Kotlin基础(三)

Kotlin基础(三)

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极简教程