Scala 常用算子

算子 ⭐️

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 ❤️