1、数组类型
2、集合类型1、List
2、Map
3、Set3、集合操作符操作符
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 })
我尼玛.好多函数,咋记得过来.
网友评论