美文网首页
Day09 常用集合以及集合操作符

Day09 常用集合以及集合操作符

作者: 鹅鹅鹅曲项向天歌呀 | 来源:发表于2019-05-06 11:00 被阅读0次

1、数组类型
2、集合类型

1、List
2、Map
3、Set

3、集合操作符操作符

1、toMutableList()
2、转换为数组
3、转换为集合
4、操作类
5、顺序操作符
6、映射操作符
7、过滤操作符
8、生产操作符
9、统计操作符

一、数组类型

几个常用的方法:

  • arr[index] 的获取元素。
  • arr.component1() ... arr.component5()获取数组的前5个元素。同样适用与集合。
  • arr.reverse() 反转元素。
fun main() {
    var arr = arrayOf(1, 2, 3, 4, 5)
    println(arr[0])
    println(arr.component1())
    println(arr.component2())
    arr.reverse()
    for (i in arr) {
        print(i)
    }
}

输出结果:


结果图

二、集合类型

  • Kotlin中的集合和其他语言不同的是,Kotlin集合可分为可变和不可变集合。
     1、使用List<E>、Set<E>、Map<K,V>声明的时候该集合则是不可变集合
     2、使用MutableList<E>、MutableSet<E>、MutableMap<K,V>的时候该集合才是可变类型集合
  • 在Kotlin中,集合类型包含三种类型:它们分别是:List、Set、Map,他们之间存在以下几个异同点:
     1、它们都是接口,并不是实际的类。
     2、它们只实现了 isEmpty()、size、contains() 等函数以及属性。
     3、List<E>Set<E> 都继承至Collection<out E>接口,且 Collection<out E> 继承于 Iterable<out T> 接口。 而 Map<K,V> 是独立出来的一个接口。这一点和Java相同。
     4、这三种集合类型分别有存在 MutableList<E>、MutableSet<E>、MutableMap<K,V> 接口,这些接口中提供了改变、操作集合的方法。例如 add()、clear()、remove() 等函数。
2.1 List

不可变集合:
1、声明
 使用listOf(..)函数

fun main() {
    var arr = arrayOf(1, 2, 3, 4, 5)
    var list = listOf(1, 2, 3, 4, 5) //随意创建
    var list1 = listOf<String>("1", "2", "3", "4", "5") //指定原始的数值类型
    var list2 = listOf(arr) //可传入一个数组
    for(value in list1){
        print("$value \t")
    }

}

可变集合:
1、声明
 (1) 使用mutableListOf()函数
 (2) 使用arrayListOf()函数

    var arr = arrayOf(1, 2, 3, 4, 5)
    var list = mutableListOf(1, 2, 3, 4, 5)
    var list1 = mutableListOf<String>("1", "2", "3", "4", "5")
    var list2 = mutableListOf(arr)
    list1.add("6")
    list1.add("7")
    list1.removeAt(1)
    for (value in list1) {
        print("$value \t")
    }

  var arrayListOf = arrayListOf<Int>(1, 2, 3, 4, 5)
    arrayListOf.add(6)
    for (value in arrayListOf) {
        print("$value \t")
    }
2.2 Map

可变集合:
1、声明:
 mutableMapOf()函数

  var mutableMapOf = mutableMapOf<String, String>("name" to "kotlin", "age" to "18")
  mutableMapOf.put("sex","boy")
  mutableMapOf.forEach { t, u -> println("$t"+" : "+"$u") }

  var hashMapOf = hashMapOf<String, String>("a" to "A", "b" to "B")  //同java的hashMap一样
  hashMapOf.put("c","C")
  hashMapOf.forEach { t, u -> println("$t" + " : " + "$u") }

不可变集合:

1、声明:
 mapOf()函数

    var mapOf = mapOf<Int, String>(1 to "value1", 2 to "value2")
    mapOf.forEach { t, u -> println("$t" + " : " + "$u") }

注意:当我们的键存在重复时,集合会过滤掉之前重复的元素。

2.3 Set

可变集合:

1、声明:
 setOf()函数

  var setOf = setOf<String>("1", "1", "2", "3")
  setOf.forEach { println(it) }

不可变集合:
1、声明:
 mutableSetOf()函数

   var mutableSetOf = mutableSetOf<Int>(1, 2, 3, 4, 4, 5, 5)
   mutableSetOf.add(6)
   mutableSetOf.forEach { println(it) }

注意 : Set类型集合会把重复的元素去除掉。

三、集合操作符操作符

1、toMutableList()
   将List转换成了MutableList,也成为协变,此外还有 toList()、toHashSet()、toSet()

    var listOf = listOf<String>("111", "222", "333")
    var mutableList = listOf.toMutableList()
    mutableList.add("444")
    mutableList.forEach { println(it) }

2、转换为数组
  集合类提供了 toTypedArray ,把这个集合根据调用集合类相应的高阶函数来转换成相应的数组。

    var listOf = listOf<String>("111", "222", "333")
    var toTypedArray = listOf.toTypedArray()       //转换
    println(listOf.javaClass.toString())          // 打印listOf的类型
    println(toTypedArray.javaClass.toString())     // 打印toTypedArray的类型

3、转换为集合
  我们声明一个集合或者数组,可以转换成相应类型的集合。调用toXXX()转换成不可变集合。调用toMutableXXX()转换为可变集合。集合类提供了toList()、toMutableList()、toSet()、toMutableSet()、toHashSet()、toMap()等高阶函数去处理。

    var arrayOf = arrayOf("111", "222", "333")
    var toList = arrayOf.toList()
    var toMutableList = arrayOf.toMutableList()
    println("变量arrayOf的类型为:${arrayOf.javaClass}")
    println("变量toList的类型为:${toList.javaClass}")
    println("变量toMutableList的类型为:${toMutableList.javaClass}")

4、操作类

名称 描述
contains(元素) 检查集合中是否包含指定的元素
elementAt(index) 获取对应下标的元素
first() 获取第一个元素,若集合为空集合,这会抛出NoSuchElementException异常
last() 同first()相反
indexOf(元素) 返回指定元素的下标,若不存在,则返回-1
forEach{...} 遍历元素。一般用作元素的打印
componentX() 这个函数在前面的章节中提过多次了。用于获取元素。其中的X只能代表1..5。
    var arrayListOf = arrayListOf<Int>(1, 2, 3, 4, 5)
    println("contains(元素) : " + arrayListOf.contains(1))
    println("elementAt(index) : " + arrayListOf.elementAt(2))
    println("first() : " + arrayListOf.first())
    println("last() : " + arrayListOf.last())
    println("indexOf() : " + arrayListOf.indexOf(5))
    arrayListOf.forEach { print(it) }
    println()
    println("componentX() : " + arrayListOf.component4())

5、顺序操作符

名称 描述
reversed() 反序。即和初始化的顺序反过来。
sorted() 自然升序。
sortedBy{} 根据条件升序,即把不满足条件的放在前面,满足条件的放在后面
sortedDescending() 自然降序。
sortedByDescending{} 根据条件降序。和sortedBy{}相反
   var arrayListOf = arrayListOf<Int>(6, 3, 8, -1, 2, 4)
    println("反转 : " + arrayListOf.reversed())
    println("升序 : " + arrayListOf.sorted())
    println("条件升序 : " + arrayListOf.sortedBy { it % 2 == 0 })
    println("降序 : " + arrayListOf.sortedDescending())
    println("条件降序 : " + arrayListOf.sortedByDescending { it % 2 == 0 })

6、映射操作符

名称 描述
map{...} 把每个元素按照特定的方法进行转换,组成一个新的集合。
mapIndexed{index,result} 把每个元素按照特定的方法进行转换,只是其可以操作元素的下标(index),组成一个新的集合。
flatMap{...} 根据条件合并两个集合,组成一个新的集合。
groupBy{...} 分组。即根据条件把集合拆分为为一个Map<K,List<T>>类型的集合。具体看实例
    var arrayListOf = arrayListOf<Int>(6, -3, 8, -1, 2, 4)
    println("map : " + arrayListOf.map { "aa".plus(it) })
    println("mapIndexed{index,result} : " + arrayListOf.mapIndexed { index, i -> index.toString()+"aa" + i })
    println("flatMap : "+arrayListOf.flatMap { listOf(it,"new"+it) })
    println("groupBy : "+arrayListOf.groupBy { if (it>0) "big" else "small"})

7、过滤操作符

名称 描述
filter{...} 把不满足条件的元素过滤掉
filterNot{...} 和filter{}函数的作用相反
take(num) 返回集合中前num个元素组成的集合
takeWhile{...} 循环遍历集合,从第一个元素开始遍历集合,当第一个出现不满足条件元素的时候,退出遍历。然后把满足条件所有元素组成的集合返回。
takeLast(num) 返回集合中后num个元素组成的集合
takeLastWhile{...} 循环遍历集合,从最后一个元素开始遍历集合,当第一个出现不满足条件元素的时候,退出遍历。然后把满足条件所有元素组成的集合返回。
drop(num) 过滤集合中前num个元素
dropWhile{...} 相同条件下,和执行takeWhile{...}函数后得到的结果相反
dropLast(num) 过滤集合中后num个元素
dropLastWhile{...} 相同条件下,和执行takeLastWhile{...}函数后得到的结果相反
distinct() 去除重复元素
distinctBy{...} 根据操作元素后的结果去除重复元素
slice 过滤掉所有不满足执行下标的元素。
    var arrayListOf = arrayListOf<Int>(6, -3, 8, -1, 2, 4, 4)
    println("filter{...} : " + arrayListOf.filter { it > 0 })
    println("filterNot{...} : " + arrayListOf.filterNot { it > 0 })
    println()
    println("take(num) : " + arrayListOf.take(3))
    println("takeWhile{...} : " + arrayListOf.takeWhile { it > 0 })
    println("takeLast(num) : " + arrayListOf.takeLast(3))
    println("takeLastWhile{...} : " + arrayListOf.takeLastWhile { it > 0 })
    println()
    println("drop{...} : " + arrayListOf.drop(3))
    println("dropWhile{...} : " + arrayListOf.dropWhile { it > 0 })
    println("dropLast{...} : " + arrayListOf.dropLast(3))
    println("dropLastWhile{...} : " + arrayListOf.dropLastWhile { it > 0 })
    println()
    println("distinct() : " + arrayListOf.distinct())
    println("distinctBy() : " + arrayListOf.distinctBy { it + 3 })
    println()
    println("slice :"+arrayListOf.slice(IntRange(2,6)))

8、生产操作符

名称 描述
plus() 合并两个集合中的元素,组成一个新的集合。也可以使用符号+
zip 由两个集合按照相同的下标组成一个新集合。该新集合的类型是:List<Pair>
unzip 和zip的作用相反。把一个类型为List<Pair>的集合拆分为两个集合。看下面的例子
partition 判断元素是否满足条件把集合拆分为有两个Pair组成的新集合。
    var arrayListOf = arrayListOf<Int>(6, -3, 8, -1, 2, 4, 4)
    var subList = arrayListOf<Int>(40, 20, 30)
    val newList = listOf(Pair(1, "Kotlin"), Pair(2, "Android"), Pair(3, "Java"), Pair(4, "PHP"))
    println("plus() : " + arrayListOf.plus(subList))
    println("zip() : " + arrayListOf.zip(subList))
    println(newList.unzip())
    println("partition () : " + arrayListOf.partition { it > 0 })

9、统计操作符

名称 描述
any() 判断是不是一个集合,若是,则在判断集合是否为空,若为空则返回false,反之返回true,若不是集合,则返回hasNext
any{...} 判断集合中是否存在满足条件的元素。若存在则返回true,反之返回false
all{...} 判断集合中的所有元素是否都满足条件。若是则返回true,反之则返回false
none() 和any()函数的作用相反
none{...} 和all{...}函数的作用相反
max() 获取集合中最大的元素,若为空元素集合,则返回null
maxBy{...} 获取方法处理后返回结果最大值对应那个元素的初始值,如果没有则返回null
min() 获取集合中最小的元素,若为空元素集合,则返回null
minBy{...} 获取方法处理后返回结果最小值对应那个元素的初始值,如果没有则返回null
sum() } 计算出集合元素累加的结果。
sumBy{...} 根据元素运算操作后的结果,然后根据这个结果计算出累加的值。
sumByDouble{...} 和sumBy{}相似,不过sumBy{}是操作Int类型数据,而sumByDouble{}操作的是Double类型数据
average() 获取平均数
reduce{...} 从集合中的第一项到最后一项的累计操作。
reduceIndexed{...} 和reduce{}作用相同,只是其可以操作元素的下标(index)
reduceRight{...} 从集合中的最后一项到第一项的累计操作。
reduceRightIndexed{...} 和reduceRight{}作用相同,只是其可以操作元素的下标(index)
fold{...} 和reduce{}类似,但是fold{}有一个初始值
foldIndexed{...} 和reduceIndexed{}类似,但是foldIndexed{}有一个初始值
foldRight{...} 和reduceRight{}类似,但是foldRight{}有一个初始值
foldRightIndexed{...} 和reduceRightIndexed{}类似,但是foldRightIndexed{}有一个初始值
 var arrayListOf = arrayListOf<Int>(1, -1, 1, -1, 1, 2, 3)
    println("any() : " + arrayListOf.any())
    println("any{...} : " + arrayListOf.any { it > 0 })
    println("all{...} : " + arrayListOf.all { it > 0 })
    println()
    println("none() : " + arrayListOf.none())
    println("none{...} : " + arrayListOf.none { it > 0 })
    println()
    println("max() : " + arrayListOf.max())
    println("maxBy{...} : " + arrayListOf.maxBy { it % 3 })
    println()
    println("min() : " + arrayListOf.min())
    println("minBy{...} : " + arrayListOf.minBy { it % 2 })
    println()
    println("sum() : " + arrayListOf.sum())
    println("sumBy() : " + arrayListOf.sumBy { it + 2 })
    println()
    println("average() : " + arrayListOf.average())
    println()
    println("reduce{...} : " + arrayListOf.reduce { acc, i -> acc + i })// acc 是 1,2,3,4,5 i是 和 i+=acc
    println("reduceIndexed{...} : " + arrayListOf.reduceIndexed { index, acc, i -> index + acc + i }) //index是下表 0+1+2+3+4+i(i+=acc)
    println("reduceRight{...} : " + arrayListOf.reduceRight { acc, i -> acc + i })
    println("reduceRightIndexed{...} : " + arrayListOf.reduceRightIndexed { index, acc, i -> index + acc + i })
    println()
    println("fold{...} : " + arrayListOf.fold(1) { result, next -> result + next })
    println("foldIndexed{...} : " + arrayListOf.foldIndexed(1) { index, result, next -> index + result + next })
    println("reduce{...} : " + arrayListOf.foldRight(1) { result, next -> result + next })
    println("foldRightIndexed{...} : " + arrayListOf.foldRightIndexed(1) { index, result, next -> index + result + next })

我尼玛.好多函数,咋记得过来.

The End.

相关文章

网友评论

      本文标题:Day09 常用集合以及集合操作符

      本文链接:https://www.haomeiwen.com/subject/nowloqtx.html