Kotlin关于集合函数列举，并推荐几个常用函数

这里不多说，长篇大论来一个

定义一个集合，下面的操作全部对这一个集合进行操作

val list = listOf(0,1,2,3,4,5,6)

（1）总数操作符

常用的有

(1)any{} 

(2)fold(){} 

(3)forEach{return@forEach} 

(4)forEachIndexed{index,value-> return@forIndexEach}

(5)reduce{}

(6)sumBy{}

1.1）any：查看list中是否有符合你给出条件的元素，哪怕只有一个

记得后面是{}，而不是（）

list.any { it%2==0 }----true

list.any{it>7}---false

1.2）all：查看list中元素是不是全部符合你给出的条件

记得后面是{}，而不是（）

ist.all { it>=0 }---true

list.all { it>0}---false

1.3)count:获取list中符合你给出条件的元素的个数

 list.count{it%2==0} ---4
list.count{it%8==0}---1

1.4）fold:简单理解就是，在你给出的初始值的基础上，对list中所有元素进行累计【正确说应该是迭代】，这一个不好理解啊

函数定义是这样的：

public inline fun <T, R> Iterable<T>.fold(initial: R, operation: (acc: R, T) -> R): R {
    var accumulator = initial
    for (element in this) accumulator = operation(accumulator, element)
    return accumulator
}

函数解释：

1.4.1） initial:R----------  传入了一个R类型的初始值 

1.4.2）for(element in this)

             -------element:元素的意思，就是遍历集合的value

            -------this：因为这是集合的扩展函数，this就表示，你调用这个方法的那个集合

            ------operation（acc:R,T）：这个是你自定义的那个传入这个方法的计算函数,必须传入两个变量，用于迭代

            -----遍历你的集合，把你集合中的元素进行你自定义的方法

1.43）举例子说明

         list.fold(0){next,total->

              next+total

        }----21

        进入到函数里：

 var accumulator = initial

 for (element in this) accumulator = operation(accumulator, element)

 list.fold(0){next,total->

              next+total

        }

next和total的关系就是：total = next+total

用java解释就是：

int inital = 0;

int accumlator = inital; //accumlator = 0

for(int next){

accumlator +=next;

}

1.4.4)你传入的函数不一定要是 next+total ,你也可以这样

 list.fold(0){next,total->

              next*total

        }---0

（1.5）foldRight{next,total->} ：功能与fold操作一样，其顺序是重最后一项到第一项

（1.6）forEach{}:遍历这个集合，想要实现java中continue的作用，需要使用 return@forEach

list.forEach { 
  print("   "+it)

}---------  0   1   2   3   4   5   6 

//注意看：打印结果没有2

list.forEach {
  if(it==2)return@forEach
  print("   "+it)
}--------0   1   3   4   5   6
   

（1.7）forEachIndexed{index,value->}:遍历这个集合

list.forEachIndexed{index,value->

  print("index=${index}  value=${value}\n")

}

index=0  value=0

index=1  value=1

index=2  value=2

index=3  value=3

index=4  value=4

index=5  value=5

index=6  value=6

list.forEachIndexed{index,value->

  if(index==2)return@forEachIndexed

  print("index=${index}  value=${value}\n")

}

index=0  value=0

index=1  value=1

index=3  value=3

index=4  value=4

index=5  value=5

index=6  value=6

（1.8）max():返回最大的一项，没有就返回null,这就是一个普通函数，直接调用，返回的是元素

看清楚这个是（）不是{ }

1.8.1) 

list.max()--6

1.8.2）

val list2 = listOf(0,0,0)

list2.max()---0

1.8.3)

val list4 = listOf<Int>()

list4.max()----null

(1.9)maxBy{}:根据给定的函数返回最大的一项，如果没有则返回null。

list.maxBy{it%2}--1

(1.10)min() minBy{}

（1.11）none：如果没有任何元素与给定的函数匹配，则返回true。

list.none{it+1==8}--true

list.none{it+1==7}--false

（1.12）reduce：与fold一样，但是没有一个初始值。通过一个函数从第一项到最后一项进行累计。

var list2 = list.reduce { acc, i ->  

  acc+i

}----21

（1.13）reduceRight：与reduce一样，但是顺序是从最后一项到第一项。

（1.14）sumBy：返回所有每一项通过函数转换之后的数据的总和。

list.sumBy { it%2 }---3

这只是总数操作符，后续还会写过滤操作符、映射操作符、元素操作符、生产操作符、顺序操作符