算子 ⭐️
var list = List(1, 2, 3, 4, 5)
// 1. head headOption
var head = list.head
println(head) // 输出:1
var headOption = list.headOption
println(headOption) // 输出:Some(1)
// 2. last lastOption
var last = list.last
println(last) // 输出:5
var lastOption = list.lastOption
println(lastOption) // 输出:Some(5)
// 3. tail
var tail = list.tail
println(tail) // 输出:List(2, 3, 4, 5)
// 4. init
var init = list.init
println(init) // 输出:List(1, 2, 3, 4)
// 5. length size
var length = list.length
println(length) // 输出:5
var size = list.size
println(size) // 输出:5
// 注:Seq中 size相当于length override def size = length
// 6. isEmpty nonEmpty
var isEmpty = list.isEmpty
println(isEmpty) // 输出:false
// 注:def isEmpty: Boolean = lengthCompare(0) == 0
var nonEmpty = list.nonEmpty
println(nonEmpty) // 输出:true
// 注:def nonEmpty: Boolean = !isEmpty
// 7. sum product max min
var sum = list.sum
println(sum) // 输出:15
var product = list.product
println(product) // 输出:120
var max = list.max
println(max) // 输出:5
var min = list.min
println(min) // 输出:1
算子 ⭐️ ⭐️
var list = List(606, 708, 105, 427, 147, 344, 447, 291, 850, 318)
// 8. count(pred)
// 统计所有元素中大于500的个数
var count = list.count(_ > 500)
println(count) // 输出:3
// 9. forall(pred)
// 查看所有元素是否全部大于500
var forall = list.forall(_ > 500)
println(forall) // 输出:false
// 10. exists(pred)
// 查看所有元素中是否存在大于500的元素
var exists = list.exists(_ > 500)
println(exists) // 输出:true
// 11. filter(pred)
// 过滤所有元素中大于500的元素
var filter = list.filter(_ > 500)
println(filter) // 输出:List(606, 708, 850)
// 12. filterNot(pred)
// 过滤所有元素中不大于500的元素
var filterNot = list.filterNot(_ > 500)
println(filterNot) // 输出:List(105, 427, 147, 344, 447, 291, 318)
// 13. partition(pred)
// 将所有元素按大于500一组,其他一组
var partition = list.partition(_ > 500)
println(partition) // 输出:List(105, 427, 147, 344, 447, 291, 318)
// 14. take(n) takeRight(n)
// 从左取出3个元素,返回新List
var take = list.take(3)
println(take) // 输出:List(606, 708, 105)
// 从右取出3个元素,返回新List
var takeRight = list.takeRight(3)
println(takeRight) // 输出:List(291, 850, 318)
// 15. drop(n) dropRight(n)
// 从左删除3个元素,返回剩下元素的新List
var drop = list.drop(3)
println(drop) // 输出:List(427, 147, 344, 447, 291, 850, 318)
// 从右删除3个元素,返回剩下元素的新List
var dropRight = list.dropRight(3)
println(dropRight) // 输出:List(606, 708, 105, 427, 147, 344, 447)
// 16. takeWhile(pred)
// 当元素大于500时,取出该元素放入新的List,找到第一个不满足条件时停止取值,返回新List
var takeWhile = list.takeWhile(_ > 500)
println(takeWhile) // 输出:List(606, 708)
// 17. dropWhile(pred)
// 当元素大于500时,移除该元素,找到第一个不满足条件时停止删除,返回剩下元素的新List
var dropWhile = list.dropWhile(_ > 500)
println(dropWhile) // 输出:List(105, 427, 147, 344, 447, 291, 850, 318)
// 18. splitAt(n)
// 以第3个元素位置进行分隔,分别放入List,作为整体返回一个Tuple
var splitAt = list.splitAt(3)
println(splitAt) // 输出:(List(606, 708, 105),List(427, 147, 344, 447, 291, 850, 318))
// 19. span(pred)
// 根据条件判断元素,找到第一个不满足条件时,将前半部分元素与剩下元素分别放入List,作为整体返回一个Tuple
var span = list.span(_>500)
println(span) // 输出:(List(606, 708),List(105, 427, 147, 344, 447, 291, 850, 318))
算子 ⭐️ ⭐️ ⭐️
var list = List[Int](606, 708, 105, 427, 147, 344, 447, 291, 850, 318)
// 20. map(f)
// def map[B, That](f: A => B): That = {..}
/*
· 参数:f 一元函数
f 的参数类型时原集合元素的类型
f 的返回值可以是任意类型
· 返回值:与原集合类型相同,泛型为 f 的返回值类型
· 作用:将 f 映射到原集合的所有元素上,并将 f 的返回值收集到新的集合中并返回
*/
var map = list.map(_ % 2)
println(map) // 输出:List(0, 0, 1, 1, 1, 0, 1, 1, 0, 0)
// 21. foreach(f)
// def foreach[U](f: A => U) {..}
/*
· 参数:f 一元函数
f 的参数类型时原集合元素的类型
f 的返回值可以是任意类型
· 返回值:Unit
· 作用:通常用于遍历集合元素,一般配合输出 print~
*/
var foreach = list.foreach(println)
// 22. flatMap(f)
// def flatMap[B, That](f: A => GenTraversableOnce[B]): That = {..}
/*
· 参数:f 一元函数
f 的参数类型时原集合元素的类型
f 的返回值是一个任意泛型的集合
· 返回值:与原集合类型相同,泛型为 f 的返回值泛型
· 作用:将 f 映射到原集合的所有元素上,并将 f 的返回值中的所有元素依次取出装入新的集合并返回(扁平化)
*/
var flatMap: List[Char] = list.flatMap(_.toString)
println(flatMap) // 输出:List(6, 0, 6, 7, 0, 8, 1, 0, 5, 4, 2, 7, 1, 4, 7, 3, 4, 4, 4, 4, 7, 2, 9, 1, 8, 5, 0, 3, 1, 8)
// 23. collect(pf)
// def collect[B, That](pf: PartialFunction[A, B]): That = {..}
/*
· 参数:pf 偏函数
· 返回值:与原集合类型相同,泛型为 pf 的返回值泛型
· 作用:collect 使用偏函数进行匹配,输出元素的个数可以与原元素个数不同,只有被 case 匹配的元素才进行操作,其他丢弃
*/
var collect = list.collect {
case i if i % 2 == 0 => i + 500
case i if i % 3 == 0 => i * 2
}
println(collect) // 输出:List(1106, 1208, 844, 1350, 818)
// 24. zip(coll2) zipAll(coll2, fil1, fil2)
// def zip[A1 >: A, B, That](that: GenIterable[B]) = {..}
// def zipAll[B, A1 >: A, That](that: GenIterable[B], thisElem: A1, thatElem: B) = {..}
/*
· 参数:coll2 与原集合相同的类型的集合
fil1 当原集合较短时,填充的默认值
fil2 当新集合较短时,填充的默认值
· 返回值:原集合类型的集合,泛型为二元组
· 作用:将两集合每个元素组成对偶(键值对),多出来的元素则抛弃
*/
var list2 = List[String]("a", "b", "c", "d", "e", "f")
var zip = list.zip(list2)
println(zip) // List((606,a), (708,b), (105,c), (427,d), (147,e), (344,f))
/*
· 作用:将两集合每个元素组成对偶(键值对),多出来的元素不会被抛弃
*/
// 当原集合较短时
var list1 = List[Int](606, 708, 105)
var zipAll1 = list1.zipAll(list2, 0, 1)
println(zipAll1) // List((606,a), (708,b), (105,c), (0,d), (0,e), (0,f))
// 当新集合较短时
var zipAll2 = list2.zipAll(list1, 0, 1)
println(zipAll2) // List((a,606), (b,708), (c,105), (d,1), (e,1), (f,1))
/*
· 作用:将集合中的元素与元素的小标位置组成对偶
*/
var zipWithIndex = list.zipWithIndex
println(zipWithIndex)
// 25. mkString
// def mkString: String = {..}
// def mkString: String = mkString("")
// def mkString(start: String, sep: String, end: String): String = {..}
/*
· 参数:无参 按空白字符串拼接
start 拼接的头部
sep 拼接的间隔符
end 拼接的尾部
· 返回值:String
· 作用:将原集合按指定的分隔符、头、尾进行拼接
*/
val mkString1 = list.mkString
println(mkString1) // 606708105427147344447291850318
val mkString2 = list.mkString(",")
println(mkString2) // 606,708,105,427,147,344,447,291,850,318
val mkString3 = list.mkString("头-(", ",", ")-尾")
println(mkString3) // 头-(606,708,105,427,147,344,447,291,850,318)-尾
算子 ⭐️ ⭐️ ⭐️ ⭐️
var list = List[Int](606, 708, 105, 427, 147, 344, 447, 291, 850, 318)
// 26. reduce(op) reduceLeft(op) reduceRight(op)
// def reduceLeft[B >: A](op: (B, A) => B): B = {..}
// def reduceRight[B >: A](op: (A, B) => B): B = {..}
/*
· 参数:op 二元函数
第一次将前两个元素从左到右作为 op 的参数
后面每次将上一次的结果作为 op 的第一个参数,集合中的下一个元素作为 op 的第二个参数
以此类推,直到取出所有的元素完成运算
· 返回值:op 的返回值类型
· 作用:将集合按顺序进行聚合
*/
var reduce = list.reduce(_ - _)
println(reduce) // -3031
// 注: def reduce[A1 >: A](op: (A1, A1) => A1): A1 = reduceLeft(op)
var reduceRight = list.reduceRight(_ - _)
println(reduceRight) // 输出:67
// 27. fold(op) foldLeft(op) foldRight(op)
// 聚合初始值 聚合函数
// def fold[A1 >: A] (z: A1) (op: (A1, A1) => A1): A1 = {..}
// def foldLeft[B] (z: B) (@deprecatedName('f) op: (B, A) => B): B = {..}
/*
· 参数:op 二元函数
第一次将前两个元素从左到右作为 op 的参数
后面每次将上一次的结果作为 op 的第一个参数,集合中的下一个元素作为 op 的第二个参数
以此类推,直到取出所有的元素完成运算
· 返回值:op 的返回值类型
· 作用:根据初始值,将集合按顺序进行聚合
*/
var fold = list.fold(0)(_ - _)
println(fold) // 输出:-4243
// 注:def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1 = foldLeft(z)(op)
var foldRight = list.foldRight(0)(_ - _)
println(foldRight) // 输出:67
❤️ END ❤️