scala数组、集合函数大全--最全的实例解析

已于 2024-02-10 20:58:51 修改
阅读量4.1k 收藏 2
点赞数 3
文章标签： scala数组、集合函数大全
于 2020-08-03 08:21:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/and52696686/article/details/107722579
版权

scala数组、集合函数大全

一、查看scala数组、集合函数

++counthasDefiniteSizemaxBysameElementstoBuffer
++:deepheadminscantoIndexedSeq
+:diffheadOptionminByscanLefttoIterable
/:distinctindexOfmkStringscanRighttoIterator
:+dropindexOfSlicenonEmptysegmentLengthtoList
:\dropRight indexWhereorElseseqtoMap
addStringdropWhileindicespadTosizetoSeq
aggregateelemManifestinitparslicetoSet
andThenelemTaginitspartitionslidingtoStream
applyendsWithintersectpatchsortBytoTraversable
applyOrElseexistsisDefinedAtpermutationssortWithtoVector
arrayfilterisEmptyprefixLengthsortedtransform
canEqualfilterNotisTraversableAgainproductspantranspose
clonefinditeratorreducesplitAtunion
collectflatMaplastreduceLeftstartsWithunzip
collectFirstflattenlastIndexOfreduceLeftOptionstringPrefixunzip3
combinationsfoldlastIndexOfSlicereduceOptionsumupdate
companionfoldLeftlastIndexWherereduceRighttailupdated
composefoldRightlastOptionreduceRightOptiontailsview
containsforalllengthreprtakewithFilter
containsSliceforeachlengthComparereversetakeRightzip
copyToArraygenericBuilderliftreverseIteratortakeWhilezipAll
copyToBuffergroupBymapreverseMaptozipWithIndex
correspondsgroupedmaxrunWithtoArray

补充：

subSequence
substring


查看方法：

  1. 在 window DOS 窗口，输入 scala 进入scala命令行
  2. 随意定义一个数组：val arr = Array(1,2,3,4)
  3. 输入： arr. + Tab 键即可显示scala所有数组、集合函数，如下图所示：
    在这里插入图片描述

二、sacla数组、集合函数实例解析

关于源码中泛型的使用可以参考：

[B>: A] 表示B 是A的超类

[B <: A] 表示B 是A的子类

方法名： ++
源码定义：

 def ++[B >: A, That](that : scala.collection.GenTraversableOnce[B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述： 合并两个序列,若类型不同以左边类型为主
返回值： 左边序列类型
示例：

val a = Array(1,2,3)
val b = Array(4,5,6)
val c = List(7,8,9)
val d = a ++ b
val d = a ++ c
val d = c ++ a

如下图：
在这里插入图片描述

方法名： ++:
源码定义：

def ++:[B >: A, That](that : scala.collection.TraversableOnce[B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述： 合并两个序列,若类型不同以右边类型为主
返回值： 右边序列类型
示例：

val a = Array(1,2,3)
val b = Array(4,5,6)
val c = List(7,8,9)
val d = a ++: b
val d = a ++: c
val d = c ++: a

如下图：
在这里插入图片描述

方法名： +:
源码定义：

def +:[B >: T](elem : B)(implicit evidence$3 : scala.reflect.ClassTag[B]) : scala.Array[B] = { /* compiled code */ }

描述： 在数组前面添加一个元素(添加的元素在前，就在数组 头部 添加，冒号要离数组近)
返回值： 数组
示例：

val a = Array(1,2,3)
val b = 1 +: a

如下图：
在这里插入图片描述

方法名： /:
源码定义：

def /:[B](z : B)(op : scala.Function2[B, A, B]) : B = { /* compiled code */ }

描述： 对数组中所有的元素从左向右遍历，进行相同的迭代操作，foldLeft 的简写(冒号要离数组近)
返回值： 计算结果
示例：

val a = List(1, 2, 3, 4)
val b = (10 /: a) (_ + _) // (((10+1)+2)+3)+4
val c = (10 /: a) (_ * _) // (((10*1)*2)*3)*4

如下图：
在这里插入图片描述

方法名： :+
源码定义：

 def :+[B >: T](elem : B)(implicit evidence$2 : scala.reflect.ClassTag[B]) : scala.Array[B] = { /* compiled code */ }

描述： 在数组后面添加一个元素(添加的元素在后，就在数组 尾部 添加，冒号要离数组近)
返回值： 数组
示例：

val a = Array(1,2,3)
val b = a :+ 1

如下图：
在这里插入图片描述

方法名： :\
源码定义：

def :\[B](z : B)(op : scala.Function2[A, B, B]) : B = { /* compiled code */ }

描述： 对数组中所有的元素从右向左遍历，进行相同的迭代操作，foldRight 的简写(冒号要离数组近)
返回值： 计算结果
示例：

val a = List(1, 2, 3, 4)
val b = (a :\ 10) (_ - _) // 1-(2-(3-(4-10)))
val c = (a :\ 10) (_ * _) // 1*(2*(3*(4*10)))

如下图：
在这里插入图片描述

方法名： addString
源码定义：

def addString(b : scala.StringBuilder, start : scala.Predef.String, sep : scala.Predef.String, end : scala.Predef.String) : scala.StringBuilder = { /* compiled code */ }
def addString(b : scala.StringBuilder, sep : scala.Predef.String) : scala.StringBuilder = { /* compiled code */ }
def addString(b : scala.StringBuilder) : scala.StringBuilder = { /* compiled code */ }

描述： 将数组中的元素逐个添加到StringBuilder中
返回值： StringBuilder
示例：

val a = List(1, 2, 3, 4)
val b = new StringBuilder()
a.addString(b)

如下图：
在这里插入图片描述


方法名： aggregate
源码定义：

def aggregate[B](z : => B)(seqop : scala.Function2[B, A, B], combop : scala.Function2[B, B, B]) : B = { /* compiled code */ }

描述： aggregate 方法是一个聚合函数，接受多个输入，并按照一定的规则运算以后输出一个结果值
返回值：
示例：

def seqno(m: Int, n: Int): Int = {
  val s = "seq_exp = %d + %d"
  println(s.format(m, n))
  m + n
}

def combine(m: Int, n: Int): Int = {
  val s = "com_exp = %d + %d"
  println(s.format(m, n))
  m + n
}

def main(args: Array[String]) {
  val a = List(1, 2, 3, 4)

  val b = a.aggregate(5)(seqno, combine) // 不分区
  println("b = " + b)
  /*
   * seq_exp = 5 + 1
   * seq_exp = 6 + 2
   * seq_exp = 8 + 3
   * seq_exp = 11 + 4
   * b = 15
   */
   
  val c = a.par.aggregate(5)(seqno, combine) // 分区
  println("c = " + c)
  /*
   * seq_exp = 5 + 3
   * seq_exp = 5 + 2
   * seq_exp = 5 + 4
   * seq_exp = 5 + 1
   * com_exp = 6 + 7
   * com_exp = 8 + 9
   * com_exp = 13 +17
   * c = 30
   */
}

如下图：
在这里插入图片描述

方法名： andThen
源码定义：

override def andThen[C](k : scala.Function1[B, C]) : scala.PartialFunction[A, C] = { /* compiled code */ }

描述： 表示方法的连续调用，相当于嵌套函数 g(f(x)) （需满足第一个函数的返回值类型是第二个函数的输入值类型），与 compose 相反
返回值：
示例：

def f(a:Int) = {
 println("2*"+a)
 2*a
}

def g(b:Int) = {
 println("3*"+b)
 3*b
}

def  result1 = f _ andThen g _
println(result1(1))
/*
2*1
2*3
6
*/
def  result2 = f _ compose  g _
println(result2(1))
/*
3*1
3*2
6
*/

如下图：
在这里插入图片描述

方法名： apply
源码定义：

 def apply(i : scala.Int) : T = { /* compiled code */ }

描述： 按下标取数组数据
返回值： 数组中的元素类型
示例：

val a = Array(1,2,3,4)
a.apply(2)  //等同于直接写a(2)
a(2)

如下图：
在这里插入图片描述

方法名： applyOrElse
源码定义：

 def applyOrElse[A1 <: A, B1 >: B](x : A1, default : scala.Function1[A1, B1]) : B1 = { /* compiled code */ }

描述： 接收2个参数，第一个是调用的参数，第二个是个回调函数。如果第一个调用的参数匹配，返回匹配的值，否则调用回调函数。（回调函数的输入类型需与调用参数类型一致）
返回值：
示例：

val pf1:PartialFunction[Int,String] = {   //定义一个偏函数，输入 1 返回 "one"
case i if i == 1 => "One"
}
pf1.applyOrElse(1,{num:Int=>"two"})  //输入1匹配到"one"
pf1.applyOrElse(2,{num:Int=>"two"})  //输入2匹配失败则触发回调函数，返回 "Two" 字符串
pf1.applyOrElse(3,{num:Int=>"two"})  //输入3匹配失败则触发回调函数，返回 "Two" 字符串

如下图：
在这里插入图片描述

方法名： array
描述： Array是scala中数组是用来存储同类型的元素结构，数组中本身size不可变，但是数组中元素可变，可重新赋值
返回值：
示例：

//声明一个String类型的数组
var arr:Array[String] = new Array[String](3)  //长度为3，未赋值：null  null null
var arr = new Array[String](3)  //长度为3，未赋值：null  null null
var arr1 = Array("java","scala","python")   //长度为3，赋值："java","scala","python"
//添加、修改元素
arr(0) = "java"
arr(1) = "scala"
arr(2) = "python"
//索引
arr(0)
arr(1)
arr(2)
//遍历打印
arr.foreach(println)

如下图：
在这里插入图片描述

方法名： canEqual
源码定义：

override def canEqual(that : scala.Any) : scala.Boolean = { /* compiled code */ }

描述： 判断两个对象是否可以进行比较(基本上都可以比较)
返回值： boolean
示例：

val a = Array(1,2,3)
val b = List(4,5,6)
val c = "hello"
val d = 5
a.canEqual(b)
a.canEqual(c)
a.canEqual(d)

如下图：
在这里插入图片描述

方法名： clone
源码定义：

override def clone() : scala.Array[T] = { /* compiled code */ }

描述： 创建一个数组的副本，复制数组的值,但不会引用地址
返回值： 数组
示例：

val a = Array(1,2,3,4)
val b = a.clone()

如下图：
在这里插入图片描述

方法名： collect
源码定义：

 def collect[B, That](pf : scala.PartialFunction[A, B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述： 输入参数类型为偏函数，对序列中的元素进行转换
返回值：
示例：

val fun: PartialFunction[String,Int] = {
 case "java" => 1
 case "scala" => 2
 case "python" => 3
}
val a = Array("java","scala","python")
val b = a.collect(fun)
println(b) // 1,2,3

如下图：
在这里插入图片描述

方法名： collectFirst
源码定义：

 def collectFirst[B](pf : scala.PartialFunction[A, B]) : scala.Option[B] = { /* compiled code */ }

描述： 查找序列中第一个符合偏函数的元素执行相应操作
返回值： Option类型
示例： 定义一个偏函数，当被执行对象为 int类型时，执行+1

val fun: PartialFunction[Any, Int] = {
  case x: Int => x + 1
}
val a = Array('a',1,3, "A")
val b = a.collectFirst(fun)
println(b) // Some(2)

如下图：
在这里插入图片描述

方法名： combinations
源码定义：

def combinations(n : scala.Int) : scala.collection.Iterator[Repr] = { /* compiled code */ }

描述： 排列组合l列出所有包含字符不一样的组合，不考虑顺序，参数n表示每个组合的序列长度。(如对于 “ab”、“ba”，视为相同组合)
返回值：
示例：

val a = Array("a", "b", "c")
val b = a.combinations(2)
b.foreach(x => println(x.mkString(",")))
/*
* a,b
* a,c
* b,c
*/

如下图：
在这里插入图片描述

方法名： companion
源码定义：

override def companion : scala.collection.generic.GenericCompanion[scala.collection.mutable.IndexedSeq] = { /* compiled code */ }

描述：
返回值：
示例：

如下图：

方法名： compose
源码定义：

def compose[A](g : scala.Function1[A, T1]) : scala.Function1[A, R] = { /* compiled code */ }

描述：
返回值： 表示方法的连续调用，与 andThen 相反，不同的是需满足第二个函数的返回值类型是第一个函数的输入值类型
示例：

def f(a:Int) = {
 println("2*"+a)
 2*a
}

def g(b:Int) = {
 println("3*"+b)
 3*b
}

def  result1 = f _ andThen g _
println(result1(1))
/*
2*1
2*3
6
*/
def  result2 = f _ compose  g _
println(result2(1))
/*
3*1
3*2
6
*/

如下图：
在这里插入图片描述

方法名： contains
源码定义：

override def contains[A1 >: A](elem : A1) : scala.Boolean = { /* compiled code */ }

描述： 判断序列中是否包含指定对象
返回值：
示例：

val a = List(1, 2, 3, 4)
println(a.contains(1)) // true

如下图：
在这里插入图片描述

方法名： containsSlice
源码定义：

def containsSlice[B](that : scala.collection.GenSeq[B]) : scala.Boolean = { /* compiled code */ }

描述： 判断当前序列中是否包含另一个序列
返回值：
示例：

val a = List(1,2,3,4)
val b = List(2,3)
val c = List(2,3,5)
println(a.containsSlice(b)) // true
println(a.containsSlice(c)) //false

如下图：
在这里插入图片描述

方法名： copyToArray
源码定义：

def copyToArray[B >: A](xs : scala.Array[B], start : scala.Int) : scala.Unit = { /* compiled code */ }
def copyToArray[B >: A](xs : scala.Array[B]) : scala.Unit = { /* compiled code */ }

描述： 将当前数组元素复制到另一个数组中(可以指定起始下标引入，选择引入几个元素)
返回值：
示例：

val a = Array(1, 2, 3)
val b: Array[Int] = new Array(10)
a.copyToArray(b)
println(b.mkString(",")) // 1,2,3,0,0,0,0,0,0,0
a.copyToArray(b, 4, 2) //从5位引入2个数字
println(b.mkString(",")) // 1,2,3,0,1,2,0,0,0,0

如下图：
在这里插入图片描述

方法名： copyToBuffer
源码定义：

def copyToBuffer[B >: A](dest : scala.collection.mutable.Buffer[B]) : scala.Unit = { /* compiled code */ }

描述： 将数组中的元素复制到 Buffer 中
返回值：
示例：

//需先引入ArrayBuffer jar包
import scala.collection.mutable.ArrayBuffer
val a = Array(1, 2, 3, 4)
val b: ArrayBuffer[Int] = ArrayBuffer()
a.copyToBuffer(b)
println(b.mkString(",")) // 1,2,3,4

如下图：
在这里插入图片描述

方法名： corresponds
源码定义：

def corresponds[B](that : scala.collection.GenSeq[B])(p : scala.Function2[A, B, scala.Boolean]) : scala.Boolean = { /* compiled code */ }

描述： 判断两个序列的长度以及对应位置元素是否符合某个条件,满足返回true，不满足返回false
返回值：
示例： 下面代码检查 a 和 b、c长度是否相等，并且 a 中元素是否都小于 b、c 中对应位置的元素

val a = Array(1, 2, 3, 4)
val b = Array(5, 6, 7, 8)
val c = Array(2, 1, 4, 5)
println(a.corresponds(b)(_ < _)) // true
println(a.corresponds(c)(_ < _)) // 第二个元素不满足，false

如下图：
在这里插入图片描述

方法名： count
源码定义：

def count(p : scala.Function1[A, scala.Boolean]) : scala.Int = { /* compiled code */ }

描述： 统计符合条件的元素个数
返回值：
示例： 下面代码统计数组中大于 2 的元素个数

val a = Array(1, 2, 3, 4)
println(a.count(x => x > 2)) // 2

如下图：
在这里插入图片描述

方法名： deep
源码定义：

def deep : scala.collection.IndexedSeq[scala.Any] = { /* compiled code */ }

描述：
返回值：
示例：

如下图：

方法名： diff
源码定义：

def diff[B >: A](that : scala.collection.GenSeq[B]) : Repr = { /* compiled code */ }

描述： 计算当前数组与另一个数组的差集，即返回另外一个数组中没有的元素
返回值： 数组
示例：

val a = Array(1, 2, 3, 4)
val b = Array(3, 4, 5, 6)
val c = a.diff(b)
println(c.mkString(",")) // 1,2

如下图：

在这里插入图片描述

方法名： distinct
源码定义：

def distinct : Repr = { /* compiled code */ }

描述： 去除当前集合中重复的元素，只保留一个
返回值： 数组
示例：

val a = Array(1, 2, 2, 3, 3,4, 4)
val b = a.distinct
println(b.mkString(",")) // 1,2,3,4

如下图：

在这里插入图片描述

方法名： drop
源码定义：

override def drop(n : scala.Int) : Repr = { /* compiled code */ }

描述： 删除数组中前 n 个元素
返回值： 数组
示例：

val a = Array(1, 2, 3, 4)
val b = a.drop(2)   //删除前两个元素
println(b.mkString(",")) // 3,4

如下图：
在这里插入图片描述

方法名： dropRight
源码定义：

override def dropRight(n : scala.Int) : Repr = { /* compiled code */ }

描述： 删除数组中尾部的 n 个元素
返回值： 数组
示例：

val a = Array(1, 2, 3, 4)
val b = a.dropRight(2)
println(b.mkString(",")) // 1,2

如下图：

在这里插入图片描述

方法名： dropWhile
源码定义：

override def dropWhile(p : scala.Function1[A, scala.Boolean]) : Repr = { /* compiled code */ }

描述： 删除数组中符合条件的元素，从第一个元素起，直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），若第一个条件就不满足就返回整个数组
返回值： 数组
示例：

val a = Array(1,2,3,4,3,2,1)
val b = a.dropWhile(x => x < 3)  //删除小于3的元素
println(b.mkString(",")) // 3,4,3,2,1   遇到4截止
val b = a.dropWhile(x => x > 2)
println(b.mkString(",")) // 1,2,3,4,3,2,1  第一个条件就不满足，返回整个数组

如下图：

在这里插入图片描述

方法名： elemManifest
源码定义：

在这里插入代码片

描述：
返回值：
示例：

如下图：

方法名： elemTag
源码定义：

在这里插入代码片

描述：
返回值：
示例：

如下图：

方法名： endsWith
源码定义：

override def endsWith[B](that : scala.collection.GenSeq[B]) : scala.Boolean = { /* compiled code */ }

描述： 判断当前序列是否以某个序列结尾
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = Array(3, 4)
println(a.endsWith(b)) // true

如下图：
在这里插入图片描述

方法名： exists
源码定义：

override def exists(p : scala.Function1[A, scala.Boolean]) : scala.Boolean = { /* compiled code */ }

描述： 判断当前数组是否包含符合条件的元素
返回值： boolean
示例：

val a = Array(1, 2, 3, 4)
println(a.exists(x => x == 3)) // true
println(a.exists(x => x == 5)) // false

如下图：
在这里插入图片描述

方法名： filter
源码定义：

def filter(p : scala.Function1[A, scala.Boolean]) : Repr = { /* compiled code */ }

描述： 筛选数组中符合条件的元素
返回值： 数组
示例：

val a = Array(1, 2, 3, 4)
val b = a.filter(x => x > 2)
println(b.mkString(",")) // 3,4

如下图：

在这里插入图片描述

方法名： filterNot
源码定义：

def filterNot(p : scala.Function1[A, scala.Boolean]) : Repr = { /* compiled code */ }

描述： 与filter相反，将不满足条件的元素筛选出来
返回值：
示例：

val a = Array(1, 2, 3, 4,0)
val b = a.filterNot(x => x > 2)
println(b.mkString(",")) // 1,2,0

如下图：
在这里插入图片描述

方法名： find
源码定义：

override def find(p : scala.Function1[A, scala.Boolean]) : scala.Option[A] = { /* compiled code */ }

描述： 查找第一个符合条件的元素
返回值： Option
示例：

val a = Array(1, 2, 3, 4)
val b = a.find(x => x > 2)
println(b) // Some(3)

如下图：

在这里插入图片描述

方法名： flatMap
源码定义：

def flatMap[B, That](f : scala.Function1[A, scala.collection.GenTraversableOnce[B]])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述： flatMap = map + flatten 即先对集合中的每个元素进行map，再对map后的每个元素（map后的每个元素必须还是集合）中的每个元素进行flatten
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = a.flatMap(x => 1 to x)
println(b.mkString(","))   //展开返回一个数组  1,1,2,1,2,3,1,2,3,4
/*
1
1,2
1,2,3
1,2,3,4
*/

//与map的区别
val c = a.map(x => 1 to x)
println(c.mkString(","))  //分别返回4个数组  Range(1),Range(1, 2),Range(1, 2, 3),Range(1, 2, 3, 4)

//展开一个Array[Array]类型的数组
val arr = Array(Array(1, 2, 3), Array(4, 5, 6), Array(7, 8, 9))
val ints = arr.flatMap(x => x)
println(ints.mkString(","))  //展开arr中每一个数组元素  1,2,3,4,5,6,7,8,9

如下图：

方法名： flatten
源码定义：

 def flatten[U](implicit asTrav : scala.Function1[T, scala.collection.Traversable[U]], m : scala.reflect.ClassTag[U]) : scala.Array[U] = { /* compiled code */ }

描述： 扁平化操作，通常配合map使用
返回值： 序列
示例：

val arr = Array("java python scala ", "math English chinese")
arr.map(_.split(" "))  //Array(Array(java, python, scala), Array(math, English, chinese))
arr.map(_.split(" ")).flatten  //Array(java, python, scala, math, English, chinese)

如下图：
在这里插入图片描述

方法名： fold
源码定义：

def fold[A1 >: A](z : A1)(op : scala.Function2[A1, A1, A1]) : A1 = { /* compiled code */ }

描述： 从左到右计算，对序列中的每个元素进行二元运算，和 aggregate 有类似的语义，但执行过程有所不同
返回值：
示例：

def seqno(m: Int, n: Int): Int = {
  val s = "seq_exp = %d + %d"
  println(s.format(m, n))
  m + n
}

def main(args: Array[String]) {
  val a = Array(1, 2, 3, 4)
  
  val b = a.fold(5)(seqno) // 不分区
  println("b = " + b)
  /*
   * seq_exp = 5 + 1
   * seq_exp = 6 + 2
   * seq_exp = 8 + 3
   * seq_exp = 11 + 4
   * b = 15
   */
    
  val c = a.par.fold(5)(seqno) // 分区
  println("c = " + c)
  /*
   * seq_exp = 5 + 3
   * seq_exp = 5 + 2
   * seq_exp = 5 + 4
   * seq_exp = 5 + 1
   * com_exp = 6 + 7
   * com_exp = 8 + 9
   * com_exp = 13 + 17
   * c = 30
   */
}

如下图：
在这里插入图片描述

方法名： foldLeft
源码定义：

def foldLeft[S](z : S)(op : scala.Function2[S, T, S]) : S = { /* compiled code */ }

描述： 同fold，但是foldLeft使用分区并行计算没有效果
返回值：
示例：

def seqno(m: Int, n: Int): Int = {
  val s = "seq_exp = %d + %d"
  println(s.format(m, n))
  m + n
}

def main(args: Array[String]): Unit = {
  val a = Array(1, 2, 3, 4)

  val b = a.foldLeft(5)(seqno) // 简写: (5 /: a)(_ + _)
  println("b = " + b)
  /*
   * seq_exp = 5 + 1
   * seq_exp = 6 + 2
   * seq_exp = 8 + 3
   * seq_exp = 11 + 4
   * b = 15
   */ 
  val c = a.par.fold(5)(seqno) // 分区
  println("c = " + c)
   /*
   * seq_exp = 5 + 1
   * seq_exp = 6 + 2
   * seq_exp = 8 + 3
   * seq_exp = 11 + 4
   * c = 15
   */
}

如下图：
在这里插入图片描述

方法名： foldRight
源码定义：

def foldRight[S](z : S)(op : scala.Function2[T, S, S]) : S = { /* compiled code */ }

描述： 从右到左计算，与foldLeft相反
返回值：
示例：

def seqno(m: Int, n: Int): Int = {
  val s = "seq_exp = %d + %d"
  println(s.format(m, n))
  m + n
}

def main(args: Array[String]): Unit = {
  val a = Array(1, 2, 3, 4)

  val b = a.foldRight(5)(seqno) // 简写: (a :\ 5)(_ + _)
  println("b = " + b)
  /*
   * seq_exp = 4 + 5
   * seq_exp = 3 + 9
   * seq_exp = 2 + 12
   * seq_exp = 1 + 14
   * b = 15
   */
  val c = a.par.fold(5)(seqno) // 分区
  println("c = " + c)
   /*
   * seq_exp = 4 + 5
   * seq_exp = 3 + 9
   * seq_exp = 2 + 12
   * seq_exp = 1 + 14
   * c = 15
   */
}

如下图：
在这里插入图片描述

方法名： forall
源码定义：

override def forall(p : scala.Function1[A, scala.Boolean]) : scala.Boolean = { /* compiled code */ }

描述： 检测序列中的元素是否都满足条件 p，满足则返回true
返回值： boolean
示例：

val a = Array(1, 2, 3, 4)
println(a.forall(x => x > 0)) // true
println(a.forall(x => x > 2)) // false

如下图：

在这里插入图片描述

方法名： foreach
源码定义：

override def foreach[U](f : scala.Function1[A, U]) : scala.Unit = { /* compiled code */ }

描述： 遍历序列中的元素
返回值：
示例：

val a = Array(1, 2, 3, 4)
a.foreach(x => println(x * 10))
/**
* 10
* 20
* 30
* 40
*/

如下图：
在这里插入图片描述

方法名： genericBuilder
源码定义：

def genericBuilder[B] : scala.collection.mutable.Builder[B, CC[B]] = { /* compiled code */ }

描述：
返回值：
示例：

如下图：

方法名： groupBy
源码定义：

def groupBy[K](f : scala.Function1[A, K]) : scala.collection.immutable.Map[K, Repr] = { /* compiled code */ }

描述： 按条件分组，条件由 f 匹配，返回值是 Map 类型，每个 key 对应一个数组
返回值：
示例： 把数组中小于 3 的元素分到一组，其他元素的分到另一组，返回 Map[String, Array[Int]]

val a = Array(1, 2, 3, 4)
val b = a.groupBy(x => x match {
 case x if (x < 3) => "small"
 case _ => "big"
})
b.foreach(x => println(x._1 + ": " + x._2.mkString(",")))
/*
* small: 1,2
* big: 3,4
*/

如下图：

在这里插入图片描述

方法名： grouped
源码定义：

def grouped(size : scala.Int) : scala.collection.Iterator[Repr] = { /* compiled code */ }

描述： 按指定数量分组，每组有 size 个元素
返回值： 迭代器
示例：

val a = Array(1, 2, 3, 4, 5)
val b = a.grouped(3).toList
b.foreach(x => println("第 " + (b.indexOf(x) + 1) + " 组: " + x.mkString(",")))
/*
* 第 1 组: 1,2,3
* 第 2 组: 4,5
*/

如下图：
在这里插入图片描述

方法名： hasDefiniteSize
源码定义：

def hasDefiniteSize : scala.Boolean = { /* compiled code */ }

描述： 检测序列是否存在有限的长度，对应 Stream 类型的流数据则返回 false
返回值： boolean
示例：

val a = Array(1, 2, 3, 4)
println(a.hasDefiniteSize) // true

如下图：
在这里插入图片描述

方法名： head
源码定义：

override def head : A = { /* compiled code */ }

描述： 返回序列的第一个元素，如果序列为空会报错
返回值：
示例：

val a = Array(1, 2, 3, 4)
println(a.head) // 1

如下图：
在这里插入图片描述

方法名： headOption
源码定义：

def headOption : scala.Option[A] = { /* compiled code */ }

描述： 返回序列的第一个元素的 Option 类型对象，如果序列为空，则返回 None
返回值： Option
示例：

val a = Array(1, 2, 3, 4)
println(a.headOption) // Some(1)

如下图：
在这里插入图片描述

方法名： indexOf
源码定义：

def indexOf[B >: A](elem : B) : scala.Int = { /* compiled code */ }

描述： 返回元素 elem 在序列中第一次出现的索引，也可以指定从索引 from 开始查找
返回值： 索引值
示例：

val a = Array(1,2,3,4,2,3)
println(a.indexOf(3)) // 2
println(a.indexOf(3, 4)) // 5

如下图：

在这里插入图片描述

方法名： indexOfSlice
源码定义：

def indexOfSlice[B >: A](that : scala.collection.GenSeq[B]) : scala.Int = { /* compiled code */ }
def indexOfSlice[B >: A](that : scala.collection.GenSeq[B], from : scala.Int) : scala.Int = { /* compiled code */ }

描述： 检测当前序列中是否包含序列 that，并返回第一次出现该序列的索引(可以指定从索引 from 开始查找，并返回第一次出现该序列的索引)
返回值： 索引值
示例：

val a = Array(1,2,3,4,5,2,3,6,7,2,3)
val b = Array(2, 3)
println(a.indexOfSlice(b)) // 1
println(a.indexOfSlice(b,3)) // 5

如下图：
在这里插入图片描述

方法名： indexWhere
源码定义：

def indexWhere(p : scala.Function1[A, scala.Boolean]) : scala.Int = { /* compiled code */ }

描述： 返回当前序列中第一个满足条件 p 的元素的索引,可以指定从索引 from 开始查找
返回值： 索引值
示例：

val a = Array(1, 2, 3, 4)
println(a.indexWhere(x => x > 2)) // 2
println(a.indexWhere(x => x > 2, 3)) // 3

如下图：
在这里插入图片描述

方法名： indices
源码定义：

def indices : scala.collection.immutable.Range = { /* compiled code */ }

描述： 返回当前序列索引集合
返回值： Range
示例：

val a = Array(1, 2, 3, 4)
val b = a.indices
println(b.mkString(",")) // 0,1,2,3

如下图：
在这里插入图片描述

方法名： init
源码定义：

override def init : Repr = { /* compiled code */ }

描述： 返回当前序列中不包含最后一个元素的序列
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = a.init
println(b.mkString(",")) // 1,2,3

如下图：
在这里插入图片描述

方法名： inits
源码定义：

def inits : scala.collection.Iterator[Repr] = { /* compiled code */ }

描述： 对集合中的元素进行 init 迭代操作，该操作的返回值中， 第一个值是当前序列的副本，最后一个值为空，每一步都进行 init 操作，上一步的结果作为下一步的操作对象
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = a.inits.toList
for (i <- 0 until b.length) {
  val s = "第 %d 个值: %s"
  println(s.format(i + 1, b(i).mkString(",")))
}
/*
 * 第 1 个值: 1,2,3,4
 * 第 2 个值: 1,2,3
 * 第 3 个值: 1,2
 * 第 4 个值: 1
 * 第 5 个值: 
 */

如下图：
在这里插入图片描述

方法名： intersect
源码定义：

def intersect[B >: A](that : scala.collection.GenSeq[B]) : Repr = { /* compiled code */ }

描述： 取两个集合的交集
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = Array(3, 4, 5, 6)
val c = a.intersect(b)
println(c.mkString(",")) // 3,4

如下图：
在这里插入图片描述

方法名： isDefinedAt
源码定义：

def isDefinedAt(idx : scala.Int) : scala.Boolean = { /* compiled code */ }

描述： 判断序列中是否存在指定索引
返回值： boolean
示例：

val a = Array(1, 2, 3, 4)
println(a.isDefinedAt(1)) // true
println(a.isDefinedAt(5)) // false

如下图：
在这里插入图片描述

方法名： isEmpty
源码定义：

override def isEmpty : scala.Boolean = { /* compiled code */ }

描述： 判断序列是否为空
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = new Array[Int](0)
println(a.isEmpty) // false
println(b.isEmpty) // true

如下图：
在这里插入图片描述

方法名： isTraversableAgain
源码定义：

final def isTraversableAgain : scala.Boolean = { /* compiled code */ }

描述： 判断序列是否可以反复遍历，该方法是 GenTraversableOnce 中的方法，对于 Traversables 一般返回 true，对于 Iterators 返回 false，除非被复写
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = a.iterator
println(a.isTraversableAgain) // true
println(b.isTraversableAgain) // false

如下图：
在这里插入图片描述

方法名： iterator
源码定义：

override def iterator : scala.collection.Iterator[A] = { /* compiled code */ }

描述： 生成当前序列的迭代器
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = a.iterator
println(b.mkString(",")) // 1,2,3,4

如下图：
在这里插入图片描述

方法名： last
源码定义：

override def last : A = { /* compiled code */ }

描述： 返回序列的最后一个元素，如果序列为空，将引发错误
返回值：
示例：

val a = Array(1, 2, 3, 4)
println(a.last) // 4

如下图：
在这里插入图片描述

方法名： lastIndexOf
源码定义：

def indexOfSlice[B >: A](that : scala.collection.GenSeq[B]) : scala.Int = { /* compiled code */ }
def indexOfSlice[B >: A](that : scala.collection.GenSeq[B], from : scala.Int) : scala.Int = { /* compiled code */ }

描述： 返回元素 elem 在序列中最后一次出现的索引 (返回元素 elem 在序列中最后一次出现的索引，然后往前遍历寻找)
返回值：
示例：

val a = Array(1, 3, 2, 3, 4)
println(a.lastIndexOf(3)) // 3
println(a.lastIndexOf(3, 2)) // 1

如下图：
在这里插入图片描述

方法名： lastIndexOfSlice
源码定义：

def lastIndexOfSlice[B >: A](that : scala.collection.GenSeq[B]) : scala.Int = { /* compiled code */ }
def lastIndexOfSlice[B >: A](that : scala.collection.GenSeq[B], end : scala.Int) : scala.Int = { /* compiled code */ }

描述： 检测当前序列中是否包含序列 that，并返回最后一次出现该序列的索引 (可以指定索引，往前查找)
返回值：
示例：

val a = Array(1, 2, 3, 2, 3, 4)
val b = Array(2, 3)
println(a.lastIndexOfSlice(b))    // 3
println(a.lastIndexOfSlice(b, 2)) // 1

如下图：
在这里插入图片描述

方法名： lastIndexWhere
源码定义：

def lastIndexWhere(p : scala.Function1[A, scala.Boolean]) : scala.Int = { /* compiled code */ }
def lastIndexWhere(p : scala.Function1[A, scala.Boolean], end : scala.Int) : scala.Int

描述： 返回当前序列中最后一个满足条件 p 的元素的索引 (可以指定索引，往前查找)
返回值：
示例：

val a = Array(1, 2, 3, 4)
println(a.lastIndexWhere(x => x > 2)) // 3
println(a.lastIndexWhere(x => x > 2, 2)) // 2

如下图：
在这里插入图片描述

方法名： lastOption
源码定义：

def lastOption : scala.Option[A] = { /* compiled code */ }

描述： 返回序列的最后一个元素的 Option 类型对象，如果序列为空，则返回 None
返回值： Option
示例：

val a = Array(1, 2, 3, 4)
println(a.lastOption) // Some(4)

如下图：

在这里插入图片描述

方法名： length
源码定义：

def length : scala.Int = { /* compiled code */ }

描述： 返回序列元素个数
返回值：
示例：

val a = Array(1, 2, 3, 4)
println(a.length) // 4

如下图：

在这里插入图片描述

方法名： lengthCompare
源码定义：

override def lengthCompare(len : scala.Int) : scala.Int = { /* compiled code */ }

描述： 比较序列的长度和参数 len，返回序列的长度 - len
返回值：
示例：

val a = Array(1, 2, 3, 4)
println(a.lengthCompare(3)) // 1
println(a.lengthCompare(4)) // 0
println(a.lengthCompare(5)) // -1

如下图：
在这里插入图片描述

方法名： lift
源码定义：

在这里插入代码片

描述：
返回值：
示例：

如下图：

方法名： map
源码定义：

def map[B, That](f : scala.Function1[A, B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述： 对序列中的元素进行 f 操作，返回生成的新序列
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = a.map(x => x * 10)
println(b.mkString(",")) // 10,20,30,40

如下图：
在这里插入图片描述

方法名： max
源码定义：

def max[B >: A](implicit cmp : scala.Ordering[B]) : A = { /* compiled code */ }

描述： 返回序列中最大的元素
返回值：
示例：

val a = Array(1, 2, 3, 4)
println(a.max) // 4

如下图：
在这里插入图片描述

方法名： maxBy
源码定义：

def maxBy[B](f : scala.Function1[A, B])(implicit cmp : scala.Ordering[B]) : A = { /* compiled code */ }

描述： 返回序列中符合条件的第一个元素
返回值：
示例：

val a = Array(1, 2, 3, 4)
println(a.maxBy(x => x > 2)) // 3

如下图：
在这里插入图片描述

方法名： min
源码定义：

def min[B >: A](implicit cmp : scala.Ordering[B]) : A = { /* compiled code */ }

描述： 返回序列中最小的元素
返回值：
示例：

val a = Array(1, 2, 3, 4)
println(a.min) // 1

如下图：
在这里插入图片描述

方法名： minBy
源码定义：

def minBy[B](f : scala.Function1[A, B])(implicit cmp : scala.Ordering[B]) : A = { /* compiled code */ }

描述： 返回序列中不符合条件的第一个元素(找不到满足条件的元素返回一个元素)
返回值：
示例：

val a = Array(1, 2, 3, 4)
println(a.minBy(x => x < 2)) // 2
println(a.minBy(x => x > 9)) // 1 默认第一个元素为最小，当遍历完发现没有大于5的元素，就返回第一个元素

如下图：
在这里插入图片描述

方法名： mkString
源码定义：

def mkString(start : scala.Predef.String, sep : scala.Predef.String, end : scala.Predef.String) : scala.Predef.String = { /* compiled code */ }

描述： 将序列中所有元素拼接成一个字符串，可以设置参数：mkString(start, sep, end) 将序列中所有元素拼接成一个字符串，以 start 开头，以 sep 作为元素间的分隔符，以 end 结尾)
返回值：
示例：

val a = Array(1, 2, 3, 4)
println(a.mkString)   // 1234
println(a.mkString("(", ",", ")")) // (1,2,3,4)

如下图：
在这里插入图片描述

方法名： nonEmpty
源码定义：

def nonEmpty : scala.Boolean = { /* compiled code */ }

描述： 判断序列是否不为空
返回值： boolean
示例：

val a = Array(1, 2, 3, 4)
val b = new Array[Int](0)
println(a.nonEmpty) // true
println(b.nonEmpty) // false

如下图：
在这里插入图片描述

方法名： orElse
源码定义：

final def orElse[B >: A](alternative : => scala.Option[B]) : scala.Option[B] = { /* compiled code */ }

描述： 与 getOrElse(value) 类似，只不过 orElse 参数为Some， 返回Option里的Some或从参数传递进去的Some
返回值： Option
示例：

val a = Some("Hello Option")
a.orElse(null)  //返回option的Some
val b = None
b.orElse(Some("New Value"))  //返回参数的Some

如下图：
在这里插入图片描述

方法名： padTo
源码定义：

def padTo[B >: A, That](len : scala.Int, elem : B)(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述： 填充序列，如果当前序列长度小于 len，那么新产生的序列长度是 len，多出的几个位值填充 elem，如果当前序列长度大于等于 len ，则返回当前序列
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = a.padTo(7, 8)  //填充一个长度为 7 的序列，不足位补 8
println(b.mkString(",")) // 1,2,3,4,8,8,8
val c = a.padTo(3, 5)  //填充序列长度3，不足位补5
println(c.mkString(","))  //1,2,3,4

如下图：
在这里插入图片描述

方法名： par
源码定义：

override def par : scala.collection.parallel.mutable.ParArray[T] = { /* compiled code */ }

描述： 开启分区，并行执行任务
返回值：
示例：

val a = Array(1, 2, 3, 4, 5)
a.foreach(print)  //12345
println()
a.par.foreach(print)  //32145

//获取参与执行任务的线程
(0 to 10000).collect{case _ => Thread.currentThread.getName}.distinct
//获取并行参与执行任务的线程
(0 to 10000).par.collect{case _ => Thread.currentThread.getName}.distinct

如下图：
在这里插入图片描述

方法名： partition
源码定义：

def partition(p : scala.Function1[A, scala.Boolean]) : scala.Tuple2[Repr, Repr] = { /* compiled code */ }

描述： 按条件将序列拆分成两个数组，满足条件的放到第一个数组，其余的放到第二个数组，返回的是包含这两个数组的元组
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b: (Array[Int], Array[Int]) = a.partition(x => x % 2 == 0)
println("偶数: " + b._1.mkString(",")) // 偶数: 2,4
println("奇数: " + b._2.mkString(",")) // 奇数: 1,3

如下图：
在这里插入图片描述

方法名： patch
源码定义：

def patch[B >: A, That](from : scala.Int, patch : scala.collection.GenSeq[B], replaced : scala.Int)(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述： 批量替换，从原序列的 from 处开始，后面的 replaced 个元素，将被替换成序列 that
返回值：
示例： 从 a 的第二个元素开始，取两个元素，即 2 和 3 ，将这两个元素替换为序列 b

val a = Array(1, 2, 3, 4)
val b = Array(7, 8, 9)
val c = a.patch(1, b, 2)
println(c.mkString(",")) // 1,7,8,9,4

如下图：
在这里插入图片描述

方法名： permutations
源码定义：

def permutations : scala.collection.Iterator[Repr] = { /* compiled code */ }

描述： 排列组合会选出所有排列顺序不同的字符组合，与 combinations 不同的是，对于相同的字符组合，比如 “abc”、“cba”，视为不同的组合
返回值：
示例：

val a = Array("a", "b", "c")
val b = a.permutations.toList
b.foreach( x => println(x.mkString(",")))
/*
* a,b,c
* a,c,b
* b,a,c
* b,c,a
* c,a,b
* c,b,a
*/

如下图：
在这里插入图片描述

方法名： prefixLength
源码定义：

def prefixLength(p : scala.Function1[A, scala.Boolean]) : scala.Int = { /* compiled code */ }

描述： 给定一个条件 p，返回满足条件的元素个数
返回值：
示例：

val a = Array(1, 2, 3, 4)
println(a.prefixLength(x => x < 3)) // 2

如下图：
在这里插入图片描述

方法名： product
源码定义：

def product[B >: A](implicit num : scala.Numeric[B]) : B = { /* compiled code */ }

描述： 返回所有元素乘积的值
返回值：
示例：

val a = Array(1, 2, 3, 4)
println(a.product) // 1*2*3*4=24

如下图：
在这里插入图片描述

方法名： reduce
源码定义：

def reduce[A1 >: A](op : scala.Function2[A1, A1, A1]) : A1 = { /* compiled code */ }

描述： 同 fold，不需要初始值
返回值：
示例：

def seqno(m: Int, n: Int): Int = {
  val s = "seq_exp = %d + %d"
  println(s.format(m, n))
  m + n
}

def main(args: Array[String]) {
  val a = Array(1, 2, 3, 4)
  val b = a.reduce(seqno)
  println("b = " + b)
}  
/*
* seq_exp = 1 + 2
* seq_exp = 3 + 3
* seq_exp = 6 + 4
* b = 10
*/

如下图：
在这里插入图片描述

方法名： reduceLeft
源码定义：

override def reduceLeft[B >: A](op : scala.Function2[B, A, B]) : B = { /* compiled code */ }

描述： 同 fold、foldLeft、reduce，从左向右计算，不需要初始值
返回值：
示例：

def seqno(m: Int, n: Int): Int = {
	val s = "seq_exp = %d + %d"
	println(s.format(m, n))
	m + n
}

def main(args: Array[String]) {
val a = Array(1, 2, 3, 4)
val b = a.reduceLeft(seqno)
println("b = " + b)
}
/*
 * seq_exp = 1 + 2
 * seq_exp = 3 + 3
 * seq_exp = 6 + 4
 * b = 10
 */

如下图：
在这里插入图片描述

方法名： reduceLeftOption
源码定义：

def reduceLeftOption[B >: A](op : scala.Function2[B, A, B]) : scala.Option[B] = { /* compiled code */ }

描述： 同 reduceLeft
返回值： Option
示例：

def seqno(m: Int, n: Int): Int = {
 val s = "seq_exp = %d + %d"
 println(s.format(m, n))
 m + n
}

def main(args: Array[String]) {
	val a = Array(1, 2, 3, 4)
	val b = a.reduceLeftOption(seqno)
	println("b = " + b)	
} 
 
/*
 * seq_exp = 1 + 2
 * seq_exp = 3 + 3
 * seq_exp = 6 + 4
 * b = Some(10)
 */

如下图：
在这里插入图片描述

方法名： reduceOption
源码定义：

def reduceOption[A1 >: A](op : scala.Function2[A1, A1, A1]) : scala.Option[A1] = { /* compiled code */ }

描述： 同 reduceLeftOption
返回值： Option
示例：

def seqno(m: Int, n: Int): Int = {
 val s = "seq_exp = %d + %d"
 println(s.format(m, n))
 m + n
}

def main(args: Array[String]) {
	val a = Array(1, 2, 3, 4)
	val b = a.reduceOption(seqno)
	println("b = " + b)	
} 
/*
 * seq_exp = 1 + 2
 * seq_exp = 3 + 3
 * seq_exp = 6 + 4
 * b = Some(10)
 */

如下图：
在这里插入图片描述

方法名： reduceRight
源码定义：

override def reduceRight[B >: A](op : scala.Function2[A, B, B]) : B = { /* compiled code */ }

描述： 同 foldRight，从右向左计算，不需要初始值
返回值：
示例：

def seqno(m: Int, n: Int): Int = {
	val s = "seq_exp = %d + %d"
	println(s.format(m, n))
	m + n
}

def main(args: Array[String]) {
	val a = Array(1, 2, 3, 4)
	val b = a.reduceRight(seqno)
	println("b = " + b)
}
/*
 * seq_exp = 3 + 4
 * seq_exp = 2 + 7
 * seq_exp = 1 + 9
 * b = 10
 */

如下图：
在这里插入图片描述

方法名： reduceRightOption
源码定义：

def reduceRightOption[B >: A](op : scala.Function2[A, B, B]) : scala.Option[B] = { /* compiled code */ }

描述： 同 reduceRight
返回值： Option
示例：

def seqno(m: Int, n: Int): Int = {
	val s = "seq_exp = %d + %d"
	println(s.format(m, n))
	m + n
}

def main(args: Array[String]) {
	val a = Array(1, 2, 3, 4)
	val b = a.reduceRightOption(seqno)
	println("b = " + b)
}
/*
 * seq_exp = 3 + 4
 * seq_exp = 2 + 7
 * seq_exp = 1 + 9
 * b = 10
 */

如下图：
在这里插入图片描述

方法名： repr
源码定义：

def repr : Repr = { /* compiled code */ }

描述： repr() 函数将对象转化为供解释器读取的形式
返回值：
示例：

val a = Map(1 -> "a",2 -> "b")
println(a.repr) //等于 println(a)  Map(1 -> a, 2 -> b)

val b = Array("java","scala")
println(b.repr) // 等于 println(b)  打印地址[Ljava.lang.String;@71423665

如下图：
在这里插入图片描述

方法名： reverse
源码定义：

override def reverse : Repr = { /* compiled code */ }

描述： 反转序列
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = a.reverse
println(b.mkString(",")) // 4,3,2,1

如下图：
在这里插入图片描述

方法名： reverseIterator
源码定义：

 override def reverseIterator : scala.collection.Iterator[A] = { /* compiled code */ }

描述： 生成反向迭代器
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = a.reverseIterator
b.foreach(x => print(x + " ")) // 4 3 2 1

如下图：
在这里插入图片描述

方法名： reverseMap
源码定义：

def reverseMap[B, That](f : scala.Function1[A, B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述： 同 map，方向相反
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = a.reverseMap(x => x * 10)
println(b.mkString(",")) // 40,30,20,10

如下图：
在这里插入图片描述

方法名： runWith
源码定义：

def runWith[U](action : scala.Function1[B, U]) : scala.Function1[A, scala.Boolean] = { /* compiled code */ }

描述： 执行偏函数，当参数不在定义域内时，返回false，否则返回true，并执行action
返回值：
示例：

val pf: PartialFunction[Int, Int] = { case m: Int if m % 2 == 1=> m * 2 }
pf.runWith(println)(3)
// return: Boolean = true
pf.runWith(println)(2)
// return: Boolean = false

如下图：
在这里插入图片描述

方法名： sameElements
源码定义：

override def sameElements[B >: A](that : scala.collection.GenIterable[B]) : scala.Boolean = { /* compiled code */ }

描述： 判断两个序列是否顺序和对应位置上的元素都一样
返回值：
示例：

val a = Array(1, 2, 3, 4)

val b = Array(1, 2, 3, 4)
println(a.sameElements(b)) // true

val c = Array(1, 3, 2, 4)
println(a.sameElements(c)) // false

val d = Array(1, 2, 3, 4, 5)
println(a.sameElements(d)) // false

如下图：
在这里插入图片描述

方法名： scan
源码定义：

def scan[B >: A, That](z : B)(op : scala.Function2[B, B, B])(implicit cbf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述： 同 fold，scan 会把每一步的计算结果放到一个新的集合中返回，而 fold 返回的是最后的结果
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = a.scan(5)(_ + _)
println(b.mkString(",")) // 5,6,8,11,15

如下图：
在这里插入图片描述

方法名： scanLeft
源码定义：

def scanLeft[B, That](z : B)(op : scala.Function2[B, A, B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述： 同 foldLeft，从左向右计算，每一步的计算结果放到一个新的集合中返回
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = a.scanLeft(5)(_ + _)
println(b.mkString(",")) // 5,6,8,11,15

如下图：
在这里插入图片描述

方法名： scanRight
源码定义：

def scanRight[B, That](z : B)(op : scala.Function2[A, B, B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述： 同 foldRight，从右向左计算，每一步的计算结果放到（从右向左放）一个新的集合中返回
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = a.scanRight(5)(_ + _)
println(b.mkString(",")) // 15,14,12,9,5

如下图：
在这里插入图片描述

方法名： segmentLength
源码定义：

override def segmentLength(p : scala.Function1[A, scala.Boolean], from : scala.Int) : scala.Int = { /* compiled code */ }

描述： 从序列的 from 开始向后查找，返回满足条件 p 的连续元素的长度，只返回第一个
返回值：
示例：

val a = Array(1, 2, 3, 1, 1, 1, 4, 1, 2, 3)
println(a.segmentLength(x => x < 3, 3)) // 3

如下图：
在这里插入图片描述

方法名： seq
源码定义：

def seq : scala.collection.mutable.IndexedSeq[T] = { /* compiled code */ }

描述： 产生一个引用当前序列的 sequential 视图
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = a.seq
println(b.mkString(",")) // 1,2,3,4

如下图：
在这里插入图片描述

方法名： size
源码定义：

override def size : scala.Int = { /* compiled code */ }

描述： 返回序列元素个数，同 length
返回值：
示例：

val a = Array(1, 2, 3, 4)
println(a.size) // 4

如下图：
在这里插入图片描述

方法名： slice
源码定义：

override def slice(from : scala.Int, until : scala.Int) : Repr = { /* compiled code */ }

描述： 返回当前序列中从 from 到 until 之间的序列，不包括 until 处的元素(左闭右开)
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = a.slice(1, 3)
println(b.mkString(",")) // 2,3

如下图：
在这里插入图片描述

方法名： sliding
源码定义：

def sliding(size : scala.Int) : scala.collection.Iterator[Repr] = { /* compiled code */ }
def sliding(size : scala.Int, step : scala.Int) : scala.collection.Iterator[Repr] = { /* compiled code */ }

描述： 滑动，从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素个数不够 size 时，则结束 。默认步长为1， (sliding(size, step) 可以设置步长 step，每一组元素组合完后，下一组从上一组起始元素位置 + step 后的位置处开始)
返回值： 迭代器
示例：

val a = Array(1, 2, 3, 4, 5)
val b = a.sliding(3).toList   //每次滑3步，步长为1
for (i <- 0 to b.length - 1) {
  val s = "第 %d 组: %s"
  println(s.format(i + 1, b(i).mkString(",")))
}
/*
 * 第 1 组: 1,2,3
 * 第 2 组: 2,3,4
 * 第 3 组: 3,4,5
 */
val c = a.sliding(3, 2).toList   //每次滑3步，步长为2
for (i <- 0 to c.length - 1) {
  val s = "第 %d 组: %s"
  println(s.format(i + 1, c(i).mkString(",")))
}
/*
 * 第 1 组: 1,2,3
 * 第 2 组: 3,4,5
 */

如下图：
在这里插入图片描述

方法名： sortBy
源码定义：

def sortBy[B](f : scala.Function1[A, B])(implicit ord : scala.math.Ordering[B]) : Repr = { /* compiled code */ }

描述： 按指定的排序规则对序列排序
返回值：
示例：

val a = Array(3, 2, 1, 4)

val b = a.sortBy(x => x) // 按 x 从小到大，即对原序列升序排列
println("升序: " + b.mkString(",")) // 1,2,3,4

val c = a.sortBy(x => 0 - x) // 按 -x 从小到大，即对原序列降序排列
println("降序: " + c.mkString(",")) // 4,3,2,1

如下图：
在这里插入图片描述

方法名： sortWith
源码定义：

在这里插入代码片

描述：
返回值：
示例：

如下图：

方法名： sorted
源码定义：

def sorted[B >: A](implicit ord : scala.math.Ordering[B]) : Repr = { /* compiled code */ }

描述： 默认升序排列，无参数
返回值： 序列
示例：

val a = Array(3, 2, 1, 4)
val b = a.sorted 
println(b.mkString(",")) // 1,2,3,4

如下图：
在这里插入图片描述

方法名： span
源码定义：

override def span(p : scala.Function1[A, scala.Boolean]) : scala.Tuple2[Repr, Repr] = { /* compiled code */ }

描述： 将序列按条件拆分成两个数组，从第一个元素开始，直到第一个不满足条件的元素为止，满足条件的元素放到第一个数组，其余元素放到第二个数组
返回值： 包含这两个数组的元组
示例：

val a = Array(1, 2, 3, 4, 1, 2)
val b = a.span(x => x < 3)
println(b._1.mkString(",")) // 1,2
println(b._2.mkString(",")) // 3,4

如下图：
在这里插入图片描述

方法名： splitAt
源码定义：

override def splitAt(n : scala.Int) : scala.Tuple2[Repr, Repr] = { /* compiled code */ }

描述： 从指定位置开始，把序列拆分成两个数组
返回值：
示例：

val a = Array(5,6,7,8,9)
val b = a.splitAt(2)
println(b._1.mkString(",")) //  5,6
println(b._2.mkString(",")) //  7,8,9

如下图：
在这里插入图片描述

方法名： startsWith
源码定义：

def startsWith[B](that : scala.collection.GenSeq[B]) : scala.Boolean = { /* compiled code */ }
def startsWith[B](that : scala.collection.GenSeq[B], offset : scala.Int) : scala.Boolean

描述： 判断序列是否以某个序列开始。 startsWith(that, offset) ：判断序列从指定偏移处是否以某个序列开始)
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = Array(1, 2)
println(a.startsWith(b)) // true

val c = Array(2, 3)
println(a.startsWith(c, 1)) // true

如下图：
在这里插入图片描述

方法名： stringPrefix
源码定义：

def stringPrefix : scala.Predef.String = { /* compiled code */ }

描述： 返回 toString 结果的前缀
返回值：
示例：

val a = Array(1, 2, 3, 4)
println(a.toString()) // [I@16c690dc
println(a.stringPrefix) // [I

如下图：
在这里插入图片描述

方法名： sum
源码定义：

def sum[B >: A](implicit num : scala.Numeric[B]) : B = { /* compiled code */ }

描述： 序列求和，元素需为 Numeric[T] 类型
返回值：
示例：

val a = Array(1, 2, 3, 4, 1)
println(a.sum) // 11

如下图：
在这里插入图片描述

方法名： tail
源码定义：

override def tail : Repr = { /* compiled code */ }

描述： 返回当前序列中不包含第一个元素的序列
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = a.tail
println(b.mkString(",")) // 2,3,4

如下图：
在这里插入图片描述

方法名： tails
源码定义：

def tails : scala.collection.Iterator[Repr] = { /* compiled code */ }

描述： 同 inits，每一步都进行 tail 操作
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = a.tails.toList
for (i <- 0 until b.length) {
  val s = "第 %d 个值: %s"
  println(s.format(i + 1, b(i).mkString(",")))
}
/*
 * 第 1 个值: 1,2,3,4
 * 第 2 个值: 2,3,4
 * 第 3 个值: 3,4
 * 第 4 个值: 4
 * 第 5 个值: 
 */

如下图：
在这里插入图片描述

方法名： take
源码定义：

override def take(n : scala.Int) : Repr = { /* compiled code */ }

描述： 返回当前序列中，前 n 个元素组成的序列
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = a.take(3)
println(b.mkString(",")) // 1,2,3

如下图：
在这里插入图片描述

方法名： takeRight
源码定义：

override def takeRight(n : scala.Int) : Repr = { /* compiled code */ }

描述： 返回当前序列中，从右边开始，后 n 个元素组成的序列
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = a.takeRight(3)
println(b.mkString(",")) // 2,3,4

如下图：
在这里插入图片描述

方法名： takeWhile
源码定义：

override def takeWhile(p : scala.Function1[A, scala.Boolean]) : Repr = { /* compiled code */ }

描述： 返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列
返回值：
示例：

val a = Array(1, 2, 3, 4, 1, 2)
val b = a.takeWhile(x => x < 3)
print(b.mkString(",")) // 1,2

如下图：
在这里插入图片描述

方法名： to
源码定义：

在这里插入代码片

描述：
返回值：
示例：

如下图：

方法名： toArray
源码定义：

在这里插入代码片

描述： 将序列转换成 Array 类型
返回值：
示例：

如下图：

方法名： toBuffer
源码定义：

在这里插入代码片

描述： 将序列转换成 Buffer 类型
返回值：
示例：

如下图：

方法名： toIndexedSeq
源码定义：

在这里插入代码片

描述： 将序列转换成 IndexedSeq 类型
返回值：
示例：

如下图：

方法名： toIterable
源码定义：

在这里插入代码片

描述： 将序列转换成可迭代的类型
返回值：
示例：

如下图：

方法名： toIterator
源码定义：

在这里插入代码片

描述： 将序列转换成迭代器，同 iterator 方法
返回值：
示例：

如下图：

方法名： toList
源码定义：

在这里插入代码片

描述： 将序列转换成 List 类型
返回值：
示例：

如下图：

方法名： toMap
源码定义：

在这里插入代码片

描述： 将序列转转换成 Map 类型，需要被转化序列中包含的元素是 Tuple2 类型
返回值：
示例：

如下图：

方法名： toSeq
源码定义：

在这里插入代码片

描述： 将序列转换成 Seq 类型
返回值：
示例：

如下图：

方法名： toSet
源码定义：

在这里插入代码片

描述： 将序列转换成 Set 类型
返回值：
示例：

如下图：

方法名： toStream
源码定义：

在这里插入代码片

描述： 将序列转换成 Stream 类型
返回值：
示例：

如下图：

方法名： toTraversable
源码定义：

在这里插入代码片

描述：
返回值：
示例：

如下图：

方法名： toVector
源码定义：

在这里插入代码片

描述： 将序列转换成 Vector 类型
返回值：
示例：

如下图：

方法名： transform
源码定义：

在这里插入代码片

描述：
返回值：
示例：

如下图：

方法名： transpose
源码定义：

def transpose[U](implicit asArray : scala.Function1[T, scala.Array[U]]) : scala.Array[scala.Array[U]] = { /* compiled code */ }

描述： 矩阵转置，二维数组行列转换
返回值：
示例：

val a = Array(Array("a", "b"), Array("c", "d"), Array("e", "f"))
val b = a.transpose
b.foreach(x => println((x.mkString(","))))
/*
* a,c,e
* b,d,f
*/

如下图：
在这里插入图片描述

方法名： union
源码定义：

override def union[B >: A, That](that : scala.collection.GenSeq[B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述： 合并两个序列，同操作符 ++
返回值：
示例：

val a = Array(1, 2)
val b = Array(3, 4)
val c = a.union(b)
println(c.mkString(",")) // 1,2,3,4

如下图：
在这里插入图片描述

方法名： unzip
源码定义：

def unzip[T1, T2](implicit asPair : scala.Function1[T, scala.Tuple2[T1, T2]], ct1 : scala.reflect.ClassTag[T1], ct2 : scala.reflect.ClassTag[T2]) : scala.Tuple2[scala.Array[T1], scala.Array[T2]] = { /* compiled code */ }

描述： 将含有两个二元组的数组，每个元组的第一个元素组成一个数组，第二个元素组成一个数组，返回包含这两个数组的元组
返回值：
示例：

val a = Array(("a", "b"), ("c", "d"))
val b = a.unzip
println(b._1.mkString(",")) // a,c
println(b._2.mkString(",")) // b,d

如下图：
在这里插入图片描述

方法名： unzip3
源码定义：

def unzip3[T1, T2, T3](implicit asTriple : scala.Function1[T, scala.Tuple3[T1, T2, T3]], ct1 : scala.reflect.ClassTag[T1], ct2 : scala.reflect.ClassTag[T2], ct3 : scala.reflect.ClassTag[T3]) : scala.Tuple3[scala.Array[T1], scala.Array[T2], scala.Array[T3]] = { /* compiled code */ }

描述： 将含有3个元祖的数组，每个元祖的第一个元素组成一个数组，第二个元素组成一个数组，第三个元素组成一个数组，返回包含这三个数组的元组
返回值：
示例：

val a = Array(("a", "b", "x"), ("c", "d", "y"), ("e", "f", "z"))
val b = a.unzip3
println(b._1.mkString(",")) // a,c,e
println(b._2.mkString(",")) // b,d,f
println(b._3.mkString(",")) // x,y,z

如下图：
在这里插入图片描述

方法名： update
源码定义：

def update(i : scala.Int, x : T) : scala.Unit = { /* compiled code */ }

描述： 将序列中 i 索引处的元素更新为 x (直接在本数组上修改)
返回值：
示例：

val a = Array(1, 2, 3, 4)
a.update(1, 5)
println(a.mkString(",")) //1,5,3,4

如下图：
在这里插入图片描述

方法名： updated
源码定义：

def updated[B >: A, That](index : scala.Int, elem : B)(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述： 将序列中 i 索引处的元素更新为 x，并返回替换后的数组（修改副本）
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = a.updated(1, 5)
println(b.mkString(",")) //1,5,3,4

如下图：
在这里插入图片描述

方法名： view
源码定义：

override def view : scala.AnyRef with scala.collection.mutable.IndexedSeqView[A, Repr] = { /* compiled code */ }
override def view(from : scala.Int, until : scala.Int) : scala.collection.mutable.IndexedSeqView[A, Repr] = { /* compiled code */ }

描述： 返回当前序列中从 from 到 until 之间的序列，不包括 until 处的元素(左闭右开)
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = a.view(1, 3)
println(b.mkString(",")) // 2,3

如下图：
在这里插入图片描述

方法名： withFilter
源码定义：

def withFilter(p : scala.Function1[A, scala.Boolean]) : scala.collection.generic.FilterMonadic[A, Repr] = { /* compiled code */ }

描述： 根据条件 p 过滤元素
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = a.withFilter(x => x > 2).map(x => x)
println(b.mkString(",")) // 3,4

如下图：
在这里插入图片描述

方法名： zip
源码定义：

override def zip[A1 >: A, B, That](that : scala.collection.GenIterable[B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, scala.Tuple2[A1, B], That]) : That = { /* compiled code */ }

描述： 将两个序列对应位置上的元素组成一个元组数组，要求两个序列长度相同
返回值：
示例：

val a = Array(1, 2, 3, 4)
val b = Array(4, 3, 2, 1)
val c = a.zip(b)
println(c.mkString(",")) // (1,4),(2,3),(3,2),(4,1)

如下图：
在这里插入图片描述

方法名： zipAll
源码定义：

def zipAll[B, A1 >: A, That](that : scala.collection.GenIterable[B], thisElem : A1, thatElem : B)(implicit bf : scala.collection.generic.CanBuildFrom[Repr, scala.Tuple2[A1, B], That]) : That = { /* compiled code */ }

描述： 同 zip ，但是允许两个序列长度不同，不足的自动填充，如果当前序列短，不足的元素填充为 thisElem，如果 that 序列短，填充为 thatElem
返回值：
示例：

val a = Array(1, 2, 3, 4, 5, 6, 7)
val b = Array(5, 4, 3, 2, 1)
val c = a.zipAll(b, 8, 9) // (1,5),(2,4),(3,3),(4,2),(5,1),(6,9),(7,9)
println(c.mkString(","))

val x = Array(1, 2, 3, 4)
val y = Array(6, 5, 4, 3, 2, 1)
val z = x.zipAll(y, 8, 9) // (1,6),(2,5),(3,4),(4,3),(8,2),(8,1)
println(z.mkString(","))

如下图：
在这里插入图片描述

方法名： zipWithIndex
源码定义：

override def zipWithIndex[A1 >: A, That](implicit bf : scala.collection.generic.CanBuildFrom[Repr, scala.Tuple2[A1, scala.Int], That]) : That = { /* compiled code */ }

描述： 序列中的每个元素和它的索引组成一个元组数组
返回值：
示例：

val a = Array('a', 'b', 'c', 'd')
val b = a.zipWithIndex
println(b.mkString(",")) // (a,0),(b,1),(c,2),(d,3)

如下图：
在这里插入图片描述

方法名： subSequence
源码定义：

def subSequence(start : scala.Int, end : scala.Int) : java.lang.CharSequence = { /* compiled code */ }

描述： 返回 start 和 end 间的字符序列，不包含 end 处的元素
返回值：
示例：

val a = Array('a', 'b', 'c', 'd')
val b = a.subSequence(1, 3)
println(b.toString) // bc

如下图：
在这里插入图片描述

方法名： substring
源码定义：

def subStringEn(input:String,start:Int,end:Int)={
  // multiple if check for avoiding index out of bound exception
    input.substring(start,end)

描述： 返回给定的索引字符串的子字符串
返回值： string
示例：

scala> val a = "abcdef"
a: String = abcdef

scala> a.substring(1,3)
res0: String = bc

#只入输一个数字表示从当前下标取到结束
scala> a.substring(1)
res1: String = bcdef

scala> a.substring(2)
res2: String = cdef

如下图：
在这里插入图片描述

我玩的很开心
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
【Scala十一】Scala核心五：case模式匹配
bit1129的博客
02-27 233
package spark.examples.scala.grammars.caseclasses object CaseClass_Test00 { def simpleMatch(arg: Any) = arg match { case v: Int =&gt; "This is an Int" case v: (Int, String) =&gt; (...
0018.scala文件的读取写入操作代码
njiang的专栏
11-22 3350
scala文件的读取写入操作代码
Scala集合函数方法（二）
sanjiang521的博客
10-28 454
Scala集合函数方法（二）函数名具体函数方法 函数名 indexOfSlice indexWhere indices init inits intersect isDefinedAt isEmpty isTraversableAgain iterator last lastIndexOf lastIndexOfSlice lastIndexWhere lastOption length lengt
scala-sbt-scala编译工具
06-12
scala 编译工具 sbt 安装包。 Little or no configuration required for simple projects Scala-based build definition that can use the full flexibility of Scala code Accurate incremental recompilation using information extracted from the compiler Continuous compilation and testing with triggered execution Packages and publishes jars Generates documentation with scaladoc Supports mixed Scala/Java projects Supports testing with ScalaCheck, specs, and ScalaTest. JUnit is supported by a plugin. Starts the Scala REPL with project classes and dependencies on the classpath Modularization supported with sub-projects External project support (list a git repository as a dependency!) Parallel task execution, including parallel test execution Library management support: inline declarations, external Ivy or Maven configuration files, or manual management
Scala 编程—第七节：类和对象(二)
harvey的博客
10-16 331
前言： &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 类和对象第二节，主要介绍：单例对象、伴生对象与伴生类、apply方法、抽象类 1.单例对象 Java语言中，如果想直接使用类名点的方式调用方法或属性，直接用static修饰即可。但Scala语言不支持静态成员，而提供了object对象，这个object对象类似于Java的静态类，object对象的成员、方...
scala-bootcamp-homework
03-07
这个作业可能包含了对 Scala 基础语法、类与对象、模式匹配、高阶函数、集合操作、类型系统、并发处理等方面的学习和练习。 1. **基础语法**: Scala 的基础语法包括变量定义（val 和 var）、常量、表达式与语句、...
Scala 编程中文版-前13章
05-10
- **模式匹配**：Scala中的模式匹配是一种强大的工具，可以用于解析复杂的数据结构。 #### 七、Scala与Spark的关系 - **推荐语言**：由于Scala语言的设计特点，它成为了大数据处理框架Spark的首选开发语言之一。 -...
scala习题精选100道附带解析
11-10
### Scala习题精选知识点解析 #### 1. 关于与Scala进行交互的基本方式REPL的说明 - **知识点概述**：REPL（Read-Eval-Print Loop）是一种交互式的编程环境，用户可以在其中输入代码，系统立即执行并显示结果。在...
快学Scala-[中文]
01-07
5. **集合库**：Scala 提供了一个强大的集合库，支持各种操作，如映射、过滤、折叠等，这些操作都是高效且通用的。 6. ** Actors 和 Concurrency**：Scala 支持 Akka 框架，通过 Actors 模型实现并发，这是一种轻量...
Scala-Aprendizaje：Estos programas fueron tomadoas de varias cursos。 SCALA基本程序之子程序
02-15
"Scala-Aprendizaje" 是一个学习资源集合，包含了从不同课程中精选的Scala基础程序，旨在帮助初学者理解并掌握Scala编程的基础概念和技巧。 在Scala中，子程序（或称为方法）是代码复用的基本单元，它们可以被定义...
[scala-spark]2. Scala运行原理与源码查看
沈春旭的博客
09-22 696
运行原理 韩顺平 查看源码 package com.lineshen.chapter1 object lookSourceCode { def main(args: Array[String]): Unit = { val arr = new Array[String](10) for (item <- arr){ println("item ...
Scala基础6-常用算子大全
W1ngman_的博客
07-15 722
常用集合函数++++:/:和:\addString练习apply获取值canEqualcharAtclonecollectcollectFirstcombinationscontainscontainsSlicecopyToArraycopyToBuffercorrespondscountdiffdistinctdropstartWith/endWithexistsfilter/filterNotfindflatMapflattenfoldgroupBy ++ var a1 = Array(1,2,3,4,
Scala 之高阶函数
v3424的博客
04-20 616
前言：常用的高阶函数： map：集合元素处理 foreach：集合元素处理 flatMap：扁平化处理 filter：过滤 groupBy：分组 sortBy：排序 scala的高阶函数mapforeachflatMapgroupByfilter/filterNotsortWith/sortByreducefold练习：基于以下List集合实现词频统计（WordCount） map map函数的语法 final def map[B](f: (A) ⇒ B): List[B] //map函数只有1个参
Spark高级算子
小东升职记
01-10 491
map是对每一个元素操作； mapPartitions是对其中的每个partition操作； mapPartitionsWithIndex:把每个partition中的分区号和对应的值拿出来，看源码： def mapPartitionsWithIndex[U](f : scala.Function2[scala.Int, scala.Iterator[T], scala.Ite...
Scala --- Array方法大全（三）
qq_57151931的博客
03-22 740
Scala --- Array方法大全系列
Scala 集合常用函数
m0_72168501的博客
01-07 660
Scala 常用集合函数
将一个二维数组的行和列互换，存到一个二维数组中
qq_40963437的博客
11-24 234
将一个二维数组的行和列互换，存到一个二维数组中。
Scala 强大的集合数据操作示例
热门推荐
05-23 9万+
Scala是数据挖掘算法领域最有力的编程语言之一，语言本身是面向函数，这也符合了数据挖掘算法的常用场景：在原始数据集上应用一系列的变换，语言本身也对集合操作提供了众多强大的函数，本文将以List类型为例子，介绍常见的集合变换操作。一、常用操作符（操作符其实也是函数）++ ++[B](that: GenTraversableOnce[B]): List[B] 从列表的尾部添加另外一个列表++: ++:
Scala集合常用算子
weixin_43655644的博客
06-27 1633
排序 sorted def sorted[B >: Int](implicit ord: scala.math.Ordering[B]): Array[Int] scala> var array=Array(1,2,4,5,3) array: Array[Int] = Array(1, 2, 4, 5, 3) scala> list.sorted res4: List[Int...
scala往数组添加100-999
最新发布
04-14
的所有奇数，如何实现？ 可以使用Scala中的Array Buffer来实现，代码如下： ```scala var arrayBuffer = scala.collection.mutable.ArrayBuffer[Int]() for (i <- 100 to 999 if i % 2 == 1) { arrayBuffer += i } ``` 这段代码会往Array Buffer中添加所有100-999之间的奇数。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值