Array为例
Kotlin中，常见的集合函数的运用。以Array数组的操作为例，先来直接看一下代码~
/**
* 数组详解
*/
class TestArray {
private var _array:Array<Int>
/**
* 初始化方法
*/
init {
_array = arrayOf(1, 3, 2, 3, 4)
}
/**
* 除去重复元素，返回List列表
*/
fun distinct() {
println("TestArray.distinct() -> " + this._array.distinct())
}
/**
* 追加元素
*/
fun plus() {
println("TestArray.plus() -> " + this._array.plus(arrayOf(5, 6)).toList())
}
/**
* 倒序
*/
fun reverse() {
println("TestArray.reverse() -> " + this._array.reversed())
}
/**
* 切片
*/
fun slice() {
println("TestArray.slice() -> " + this._array.slice(IntRange(0, 2)))
}
/**
* 切片
*/
fun sort() {
this._array.sort()
println("TestArray.sort() -> " + this._array.toList())
}
/**
* 对象排序
*/
fun sortWith() {
var array1 = ArrayEntity()
array1.id = 2
var array2 = ArrayEntity()
array2.id = 1
var array3 = ArrayEntity()
array3.id = 3
var array = arrayOf(array1, array2, array3)
array.sortWith(Comparator { o1, o2 -> o2.id.compareTo(o1.id) })
for (entity in array)
println("TestArray.sortWith() -> " + entity.id)
}
/**
* 如果至少有一个元素与指定条件相符，则返回true
*/
fun any() {
println("TestArray.any() -> " + this._array.any())
var tmp:Array<Int> = arrayOf()
println("TestArray.any() -> " + tmp.any())
}
/**
* 判断是否有指定的元素存在，有就返回true 2
*/
fun contains() {
println("TestArray.contains() -> " + this._array.contains(1))
}
/**
* 删除前两位
*/
fun drop() {
var tmp:Array<Int> = arrayOf(1, 2, 3, 4)
println("TestArray.drop() -> " + tmp.drop(2))
// dropWhile 这个方法的意思是返回所有元素列表，但不包括第一个满足指定条件的元素。
// 但看了里面的源代码，写得有点问题 2017/4/1 17:03
// tmp.dropWhile { it > 3 }
}
/**
* 删除后两位
*/
fun dropLast() {
var tmp:Array<Int> = arrayOf(1, 2, 3, 4)
println("TestArray.dropLast() -> " + tmp.dropLast(2))
}
/**
* 提取前两位元素返回
*/
fun take() {
var tmp:Array<Int> = arrayOf(1, 2, 3, 4)
println("TestArray.take() -> " + tmp.take(2))
}
/**
* 提取最后两位元素返回
*/
fun takeLast() {
var tmp:Array<Int> = arrayOf(1, 2, 3, 4)
println("TestArray.takeLast() -> " + tmp.takeLast(2))
}
/**
*过滤掉剩下条件为true的元素
*/
fun filter() {
println("TestArray.filter() -> " + this._array.filter { it % 2 == 0 })
}
/**
* 过滤掉剩下条件为true的元素，另一种写法
*/
fun filterTo() {
var list = ArrayList<Int>()
println("TestArray.filterTo() -> " + this._array.filterTo(list, { it % 2 == 0 }))
}
/**
* 过滤掉条件为true的元素
*/
fun filterNotTo() {
var list = ArrayList<Int>()
println("TestArray.filterNotTo() -> " + this._array.filterNotTo(list, { it % 2 == 0 }))
}
/**
* 返回所有元素列表，但不包括null元素
*/
fun filterNotNull() {
println("TestArray.filterNotNull() -> " + this._array.filterNotNull())
}
/**
* 根据指定索引，获取元素
*/
fun elementAt() {
println("TestArray.elementAt() -> " + this._array.elementAt(2))
}
/**
* 查找元素，可以判断是否存在该元素，没有的话返回null
*/
fun find() {
println("TestArray.find() -> " + this._array.find { it == 3 })
}
/**
* 遍历
*/
fun forEach() {
println("TestArray.forEach() -> " + this._array.toList())
this._array.forEach({
println(it)
})
}
/**
* 对每一个元素操作后，返回一个新的列表
*/
fun map() {
println("TestArray.forEach() -> " + this._array.map { it * 2 })
}
/**
* 从第一元素到最后一个元素运算的累加，acc每一个元素累计后的值，i当前的元素
*/
fun reduce() {
println("TestArray.reduce() -> " + this._array.reduce { acc, i -> acc + i })
}
/**
* 返回最小的元素
*/
fun min() {
println("TestArray.min() -> " + this._array.min())
}
/**
* 返回最大的元素
*/
fun max() {
println("TestArray.max() -> " + this._array.max())
}
}
/**
* 实体
*/
class ArrayEntity {
var id:Int = 0
var name:String? = null
}
以上的操作基本上是最常见的集合函数运用，我们再来看下各个函数的描述，是我整合网上的资源的，如下：
集合
虽然，我们可以只使用Java集合，然而Kotlin提供了一套很好的本机接口:
Iterable ：父类。任何类继承这个接口就表示可以遍历序列的元素。
MutableIterable ：在迭代期间支持移除项目的迭代。
Collection ：这个类表示元素的泛型集合。我们可以访问函数：返回集合尺寸、集合是否为空、包含一项或一组。由于集合是不可变的，这类集合的所有方法只能请求数据。
MutableCollection ：支持添加和移除元素的Collection。它提供额外的函数，如：add、remove或clear等等。
List ：或许这是最常用的集合。这表示有序的元素泛型集合。由于是有序的，我们可以用get函数，按照项目的位置请求项目。
MutableList ：支持添加和移除元素的List。
Set ：不支持重复元素的无序元素集合。
MutableSet ：支持添加和移除元素的Set。
Map ：key-value（键-值）对集合。在映射表（map）中key（键）是唯一的，就是说在一个映射表中不能有两对有相同的key。
MutableMap ：支持添加和移除元素的Map。
1、 聚合操作
/**
* 1.聚合操作
*/
//1.any
// 如果至少有一个元素与指定条件相符，则返回true。
val list = listOf(1,2,3,4,5)
// assertTrue(list.any { it % 2 == 0 })
assertTrue(list.any { it %2 == 0 })
assertFalse(list.any { it > 10 })
//2.all
// 如果所有元素与指定条件相符，则返回true
assertTrue(list.all { it < 10 })
assertFalse(list.all { it % 2 == 0 })
//3.conut
//返回指定条件相符的元素个数
assertEquals(3,list.count { it % 2 == 0 })
//4.fold
//将对集合从第一个到最后一个元素的操作结果进行累加，并加上初始值
assertEquals(25,list.fold(4){total,next -> total + next})
//5.foldRight
//同fold，但是，是从最后一个元素到第一个元素。
assertEquals(25,list.foldRight(4){total,next -> total + next})
//6.forEach
//对每个元素执行指定的操作
list.forEach { println(it) }
//7.forEachIndexed
//同forEach，不过同时还获得元素的索引
list.forEachIndexed { index, value -> println("position $index contains a $value") }
//8.max
//返回最大元素，如果没有元素，则返回null
assertEquals(6,list.max())
//9.maxBy
//返回使指定函数产生最大的第一个元素。如果没有元素，则返回null
// The element whose negative is greater
assertEquals(1,list.maxBy { -it })
//10.min
//返回最小元素，如果没有元素，则返回null
assertEquals(1,list.min())
//11.minBy
//返回使指定函数产生最小值的第一个元素，如果没有元素，则返回null
assertEquals(1,list.minBy { -it })
//12.none
//如果没有元素与指定条件相符，则返回true
// No elements are divisible by 7
assertTrue(list.none { it % 7 == 0 })
//13.同fold，但是不包括初始值，只是讲对集合从第一个元素到最后一个元素的操作结果进行累加
assertEquals(21,list.reduce { total, next -> total + next })
//14.reduceRight
//同reduce，但是，是从最后一个元素到第一个元素
assertEquals(21,list.reduceRight { total, next -> total + next })
//15.sumBy
//返回集合中元素进转换函数产生之的总和
assertEquals(3,list.sumBy { it % 2 })
2、 筛选操作
/**
* 2、 筛选操作
*/
//1.drop 返回所有元素列表，但不包括前N个元素。
assertEquals(listOf(5,6),list.drop(4))
//2.dropWhile 返回所有元素列表，但是不包括第一个满足指定条件的元素
assertEquals(listOf(3,4,5),list.dropWhile { it < 3 })
//3.dorpLastWhile 返回所有元素列表，但是不包括满足指定条件的最后一个
assertEquals(listOf(1,2,3,4),list.dropLastWhile { it > 4 })
//4.filter 返回所有与指定条件相符的元素列表
assertEquals(listOf(2,4,6),list.filter { it % 2 == 0})
//5.filterNot 返回与指定条件不符的所有元素列表
assertEquals(listOf(1,3,5),list.filterNot { it % 2 == 0 })
//6. filterNotNull
assertEquals(listOf(1,2,3,4), list.filterNotNull())
//7.slice 返回指定索引的元素列表
assertEquals(listOf(2,4,5),list.slice(listOf(1,3,4)))
//8.take 返回前N个元素列表
assertEquals(listOf(2,4,5),list.take(2))
//9.takeLast 返回最后N个元素列表
assertEquals(listOf(5,6),list.takeLast(2))
//10.takeWhile 返回满足指定条件第一个元素列表
assertEquals(listOf(1,2),list.takeWhile { it < 3 })
3、生成操作
1.merge
返回一个列表，该列表由两个集合中有相同索引元素经转换函数转换而组成的。这个列表的长度是最大集合的长度。
val list = listOf(1, 2, 3, 4, 5, 6)
val listRepeated = listOf(2, 2, 3, 4, 5, 5, 6)
assertEquals(listOf(3, 4, 6, 8, 10, 11), list.merge(listRepeated) { it1, it2 -> it1 + it2 })
2.partition
将原始集合拆分一对集合，一个集合包含判断条件为true的元素，另一个集合包含判断条件为false的元素。
assertEquals(Pair(listOf(2, 4, 6), listOf(1, 3, 5)), list.partition { it % 2 == 0 })
3.plus
返回一个列表，该列表包含原始集合的所有元素和指定集合的所有元素。由于函数名称原因，我们可以使用“+”操作符。
assertEquals(listOf(1, 2, 3, 4, 5, 6, 7, 8), list + listOf(7, 8))
4.zip
返回一个列表，该列表由两个集合中相同索引元素建立的元素对。这个列表长度为最短集合的长度。
assertEquals(listOf(Pair(1, 7), Pair(2, 8)), list.zip(listOf(7, 8)))
4、 排序操作
1.reverse
返回逆序元素列表。
val unsortedList = listOf(3, 2, 7, 5)
assertEquals(listOf(5, 7, 2, 3), unsortedList.reverse())
2.sort
返回所有元素分类排序列表。
assertEquals(listOf(2, 3, 5, 7), unsortedList.sort())
3.sortBy
返回所有元素列表，其元素通过特定的比较器分类排序。
assertEquals(listOf(3, 7, 2, 5), unsortedList.sortBy { it % 3 })
4.sortDescending
返回所有元素分类排序列表，其顺序为降序。
assertEquals(listOf(7, 5, 3, 2), unsortedList.sortDescending())
5.sortDescendingBy
返回所有元素的分类排序列表，其顺序为通过特定排序函数结果的降序。
assertEquals(listOf(2, 5, 7, 3), unsortedList.sortDescendingBy { it % 3 })
PS
感谢网友的提供，能让我也一同新的学习~~~
