函数名
具体函数方法
indexOfSlice
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,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 */ }
返回当前序列索引集合
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 */ }
取两个集合的交集，可以和diff结合来记忆
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 */ }
判断序列中是否存在指定索引
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 在序列中最后一次出现的索引 (后面加一个参数是从指定的这个参数索引开始，向前遍历，找到第一个符合的元素的索引)
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
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)
a.length
Int = 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
def lift: Int => Option[Int]
给序列的索引，返回该索引处的Option类的值
val a = Array(1, 2, 3, 4)
a.lift(1)
Option[Int] = Some(2)
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
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 */ }
判断序列是否不为空
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
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
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，从左向右计算，和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.reduce(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
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
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 */ }
同 scan，从左向右计算，每一步的计算结果放到一个新的集合中返回
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 */ }
返回当前序列中从 from 到 until 之间的序列，不包括 until 处的元素(左闭右开)
val a = Array(1, 2, 3, 4)
val b = a.slice(1, 3)
println(b.mkString(",")) // 2,3
扫一扫
452
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
