Scala函数大全

scala> var  a=Array(1,2,3)
a: Array[Int] = Array(1, 2, 3)

scala> var b=Array('a','b','c')
b: Array[Char] = Array(a, b, c)

scala> a++b
res197: Array[AnyVal] = Array(1, 2, 3, a, b, c)

++：

并数组，结果由冒号右边类型决定

scala> var a=Array(1,2,3)
a: Array[Int] = Array(1, 2, 3)

scala> var b=List(4,5,6)
b: List[Int] = List(4, 5, 6)

scala> a++:b
res5: List[Int] = List(1, 2, 3, 4, 5, 6)

scala> b++:a
res6: Array[Int] = Array(4, 5, 6, 1, 2, 3)

*******************************************************
scala> var  a=Array(1,2,3)
a: Array[Int] = Array(1, 2, 3)
scala> var b=Array('a','b','c')
b: Array[Char] = Array(a, b, c)
scala> a++:b
res198: Array[AnyVal] = Array(1, 2, 3, a, b, c)

scala> b++:a
res199: Array[AnyVal] = Array(a, b, c, 1, 2, 3)

+：/:+

冒号跟着集合，在数组前或后加值

scala> var  a=Array(1,2,3)
a: Array[Int] = Array(1, 2, 3)
scala> a:+4
res201: Array[Int] = Array(1, 2, 3, 4)

scala> 4+:a
res202: Array[Int] = Array(4, 1, 2, 3)

/: :\

左子树加，右子树加

scala> var  a=Array(1,2,3)
scala> (10 /: a)((x,y)=>{println(x,y);x+y})
(10,1)
(11,2)
(13,3)
res218: Int = 16

scala> (a :\ 10)((x,y)=>{println(x,y);x+y})
(3,10)
(2,13)
(1,15)
res219: Int = 16

addString

将数组中的元素逐个添加到StringBuilder中

scala> var  a=Array(1,2,3)
scala> var c=new StringBuilder()
c: StringBuilder =

scala> a.addString(c)
res224: StringBuilder = 123

scala> var d=new StringBuilder()
d: StringBuilder =

scala> a.addString(d,"-")
res225: StringBuilder = 1-2-3

scala> var f=new StringBuilder()
f: StringBuilder =

scala> a.addString(f,"(","-",")")
res226: StringBuilder = (1-2-3)

aggregate

聚合计算，是柯理化方法，参数是两个方法

scala> var a=Array(1,2,3,4,5,6,7,8,9,10,11,12,13,14)
a: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)
不分区计算，串型计算
scala> a.aggregate(1)((x,y)=>x+y,(x,y)=>x+y)
res228: Int = 106
scala> a.aggregate(1)((x,y)=>x+y,(x,y)=>x+y)
res229: Int = 106

并行
scala> a.par.aggregate(10,0)((x,y)=>{if (y>10) (x._1,x._2+1) else x },(x,y)=>(x._1,x._2+y._2))
res236: (Int, Int) = (10,4)

apply

取下标对应的值，必须为Int类型

scala> var a=Array(1,2,3,4,5,6,7,8,9,10,11,12,13,14)
scala> a.apply(1)
res238: Int = 2

scala> a.apply(0)
res239: Int = 1

charAt

charAt(index：Int)和apply功能类似

scala> var b=Array('a','b','c')
b: Array[Char] = Array(a, b, c)

scala> b
res242: Array[Char] = Array(a, b, c)

scala> b.charAt(1)
res243: Char = b

clone

创建一个副本（默认为浅拷贝，即拷贝对象的引用，拷贝中数据改变原值也会改变）

scala> var b=Array('a','b','c')
b: Array[Char] = Array(a, b, c)
scala> var c=b.clone()
c: Array[Char] = Array(a, b, c)
scala> c
res245: Array[Char] = Array(a, b, c)

collect PartialFunction

collect 通过执行一个并行计算（偏函数），得到一个新对象
PartialFunction(入参，出参) 即只处理指定数据

scala> var a=Array(1,2,3,4,5,6)
a: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> def fun:PartialFunction[Int,Int]={
     | case 2=>4
     | case 3=>5
     | case 4=>6
     | case x=>x}
scala> a.collect(fun)
res251: Array[Int] = Array(1, 4, 5, 6, 5, 6)

scala> c
res245: Array[Char] = Array(a, b, c)
scala> c.collect(x=>x match {case 'a' =>"A"  case _=>"demo"})
res249: Array[String] = Array(A, demo, demo)

collectFirst

在序列中查找第一个符号偏函数定义的元素，并执行偏函数计算

scala> def fun:PartialFunction[Any,Int]={case x:Int=>x*10}
fun: PartialFunction[Any,Int]

scala> var a=Array(1,'a',"a")
a: Array[Any] = Array(1, a, a)

scala> a.collectFirst(fun)
res252: Option[Int] = Some(10)

scala> res252.getOrElse(-1)
res253: Int = 10

combinations

排列组合

scala> var a=Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)
scala> a.combinations(2)
res258: Iterator[Array[Int]] = non-empty iterator

scala> res258.foreach(x=>println(x.mkString(",")))
1,2
1,3
1,4
2,3
2,4
3,4

contains

序列中是否包含指定对象

scala> a
res262: Array[Int] = Array(1, 2, 3, 4)

scala> a.contains(1)
res263: Boolean = true

containsSlice

类型，值，顺序都要匹配，不比较长度

scala> a
res264: Array[Int] = Array(1, 2, 3, 4)
scala> var b=Array(1,2)
b: Array[Int] = Array(1, 2)

scala> a.containsSlice(b)
res266: Boolean = true

scala> var b=Array(2,1)
b: Array[Int] = Array(2, 1)

scala> a.containsSlice(b)
res267: Boolean = false

copyToArray 拷贝数组

– copyToArray(xs: Array[A], start: Int): Unit 拷贝数组，加存放拷贝目标的初始位置
– copyToArray(xs: Array[A], start: Int, len: Int): Unit 拷贝数组，加拷贝目标的初始位置，以及拷贝长度

scala> var a=Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> var b=new Array[Int](9)
b: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0)

scala> a.copyToArray(b)

scala> b
res270: Array[Int] = Array(1, 2, 3, 4, 0, 0, 0, 0, 0)

scala> var b=new Array[Int](9)
b: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0)

scala> a.copyToArray(b,4)

scala> b
res274: Array[Int] = Array(0, 0, 0, 0, 1, 2, 3, 4, 0)

scala> var b=new Array[Int](9)
b: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0)

scala> a.copyToArray(b,4,3)

scala> b
res276: Array[Int] = Array(0, 0, 0, 0, 1, 2, 3, 0,0)

copyToBuffer

将数组中的内容拷贝到Buffer中（a拷贝到b中）

scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer

scala> var a=Array('a','b','c')
a: Array[Char] = Array(a, b, c)

scala> var b:ArrayBuffer[Char]=ArrayBuffer()
b: scala.collection.mutable.ArrayBuffer[Char] = ArrayBuffer()

scala> a.copyToBuffer(b)

scala> b
res278: scala.collection.mutable.ArrayBuffer[Char] = ArrayBuffer(a, b, c)

corresponds

判断两个序列长度+对应位置元素是否符合某个条件(两者全部满足，返回true)

cala> var a=Array(1,2,3)
a: Array[Int] = Array(1, 2, 3)

scala> var b=Array(2,4,5,6)
b: Array[Int] = Array(2, 4, 5, 6)

scala> a.corresponds(b)(_<_)
res279: Boolean = false

count

统计符合条件的元素

scala> a
res281: Array[Int] = Array(1, 2, 3)
scala> a.count(_>2)
res282: Int = 1

diff

计算当前数组与另一个数组内容不同的值

scala> a
res283: Array[Int] = Array(1, 2, 3)

scala> var b=Array(1,2,3,4,5)
b: Array[Int] = Array(1, 2, 3, 4, 5)

scala> a.diff(b)
res284: Array[Int] = Array()

scala> b.diff(a)
res285: Array[Int] = Array(4, 5)

distinct

去除当前重复的元素，只保留一个

scala> var b=Array(1,1,2,3,4,4,4,5,6,6,7,7)
b: Array[Int] = Array(1, 1, 2, 3, 4, 4, 4, 5, 6, 6, 7, 7)
scala> b.distinct
res287: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7)

drop

去除当前序列前n个元素

scala> b
res289: Array[Int] = Array(1, 1, 2, 3, 4, 4, 4, 5, 6, 6, 7, 7)

scala> b.drop(2)
res290: Array[Int] = Array(2, 3, 4, 4, 4, 5, 6, 6, 7, 7)

scala> b
res291: Array[Int] = Array(1, 1, 2, 3, 4, 4, 4, 5, 6, 6, 7, 7)

scala> b.drop(5)
res292: Array[Int] = Array(4, 4, 5, 6, 6, 7, 7)

dropRight

去除尾部n个元素

scala> b
res295: Array[Int] = Array(1, 1, 2, 3, 4, 4, 4, 5, 6, 6, 7, 7)

scala> b.dropRight(5)
res296: Array[Int] = Array(1, 1, 2, 3, 4, 4, 4)

dropWhile

去除当前数组中符合条件的元素（碰到第一个不满足条件的元素结束）

scala> var b=Array(4,5,6,1,2,3,1,2,3)
b: Array[Int] = Array(4, 5, 6, 1, 2, 3, 1, 2, 3)

scala> b.dropWhile(_>3)
res299: Array[Int] = Array(1, 2, 3, 1, 2, 3)

endsWith

判断是否以某个序列结尾（序列）

scala> a
res300: Array[Int] = Array(1, 2, 3)

scala> b
res301: Array[Int] = Array(4, 5, 6, 1, 2, 3, 1, 2, 3)
scala> b.endsWith(a)
res303: Boolean = true

exists

判断当前数组是否包含符合条件的元素

scala> b
res306: Array[Int] = Array(4, 5, 6, 1, 2, 3, 1, 2, 3)
scala> b.exists(_>3)
res308: Boolean = true

filter

取得数组中符合条件的元素

 scala> a
res309: Array[Int] = Array(1, 2, 3)

scala> a.filter(_>2)
res310: Array[Int] = Array(3)

filterNot

与filter相反 filter 取得数组中符合条件的元素

scala> a
res319: Array[Int] = Array(1, 2, 3)

scala> a.filter(_>2)
res320: Array[Int] = Array(3)
scala> a.filterNot(_>2)
res321: Array[Int] = Array(1, 2)

find

查找第一个符合条件的元素

scala> b
res322: Array[Int] = Array(4, 5, 6, 1, 2, 3, 1, 2, 3)

scala> b.find(_>3)
res323: Option[Int] = Some(4)
scala> res323.getOrElse(-1)
res325: Int = 4

flatMap

对当前序列的每一个元素进行操作

scala> a
res326: Array[Int] = Array(1, 2, 3)

scala> a.flatMap(x=>1 to x)
res327: Array[Int] = Array(1, 1, 2, 1, 2, 3)

flatten

降维每运行一次降一个维度

scala> var a=Array(Array(1,2),Array(3,4))
a: Array[Array[Int]] = Array(Array(1, 2), Array(3, 4))

scala> a.flatten
res328: Array[Int] = Array(1, 2, 3, 4)

scala> var a=Array(Array(Array(1,2),Array(3,4)),Array(Array(5,6),Array(7,8)))
a: Array[Array[Array[Int]]] = Array(Array(Array(1, 2), Array(3, 4)), Array(Array(5, 6), Array(7, 8)))

scala> a.flatten
res329: Array[Array[Int]] = Array(Array(1, 2), Array(3, 4), Array(5, 6), Array(7, 8))

scala> res329.flatten
res330: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8)

fold / foldLeft / foldRight

对序列中每个元素进行二元运算（需要一个方法） aggregate有类似的语义，aggregate需要两个方法

scala> val a=Array(1,2,3)
a: Array[Int] = Array(1, 2, 3)
scala> a.fold(1)(_+_)
res334: Int = 7

scala> a.foldRight(1)((x,y)=>{println(x,y);x+y})
(3,1)
(2,4)
(1,6)
res336: Int = 7

scala> a.foldLeft(1)((x,y)=>{println(x,y);x+y})
(1,1)
(2,2)
(4,3)
res337: Int = 7

forall

检测序列中的元素是否都满足条件p，如果序列为空，也返回true

scala> a
res340: Array[Int] = Array(1, 2, 3)
scala> a.forall(_>0)
res342: Boolean = true

groupBy / foreach

foreach 遍历序列中的元素，无返回值
groupBy 按条件分组，同条件放一组

scala> a.groupBy(x=>x match{ case x if x==2 =>"Two" case x if x==3 =>"Three" case _=>"
one"})
res0: scala.collection.immutable.Map[String,Array[Int]] = Map(one -> Array(1, 4), Two -> Array(2), Three -> Array(3))

scala> res0.foreach(x=>println(x._1,x._2.toList))
(one,List(1, 4))
(Two,List(2))
(Three,List(3))

scala> a.groupBy(_>2).toList.apply(1)
res136: (Boolean, Array[Int]) = (true,Array(3, 4))

scala> a.groupBy(_>2).toList.apply(1)._2
res137: Array[Int] = Array(3, 4)

scala> a.groupBy(_>2).toList.apply(1)._2(1)
res138: Int = 4

grouped

按指定数分组区别：combinations 排列组合量

scala> a
res6: Array[Int] = Array(1, 2, 3, 4)
scala> a.grouped(2).foreach(x=>println(x.mkString(",")))
1,2
3,4

scala> a.combinations(2).foreach(x=>println(x.mkString(",")))
1,2
1,3
1,4
2,3
2,4
3,4

hasDefiniteSize/hashCode

hasDefiniteSize 检测序列长度是否有限
hashCode hash值

scala> a
res18: Array[Int] = Array(1, 2, 3, 4)
scala> a.hasDefiniteSize
res20: Boolean = true

scala> a.hashCode
res22: Int = 1364415236

head

返回序列的第一个元素

scala> a
res24: Array[Int] = Array(1, 2, 3, 4)
scala> a.head
res23: Int = 1

headOption

返回Option类型对象（none/some）

scala> a
res24: Array[Int] = Array(1, 2, 3, 4)
scala> a.headOption
res26: Option[Int] = Some(1)

scala> var b:Array[Int]=Array()
b: Array[Int] = Array()

scala> b.headOption
res31: Option[Int] = None

indexOf

返回元素的索引值

scala> a
res33: Array[Int] = Array(1, 2, 3, 4)

scala> a.indexOf(1)
res34: Int = 0

scala> a.indexOf(2)
res35: Int = 1

indexOfSlice

检测当前序列是否包含另一个序列，并返回第一个匹配出现的元素的索引

scala> a
res36: Array[Int] = Array(1, 2, 3, 4)

scala> var b=Array(1,2)
b: Array[Int] = Array(1, 2)

scala> a.indexOfSlice(b)
res37: Int = 0

scala> var a=Array(1,2,3,4,5,1,2,3)
a: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)

scala> a.indexOfSlice(b)
res38: Int = 0

scala> a.indexOfSlice(b,2)
res39: Int = 5

indexWhere

返回当前序列中第一个满足条件的元素的索引

scala> a
res40: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)

scala> a.indexWhere(_>2)
res41: Int = 2

scala> a.indexWhere(_>2,4)
res42: Int = 4

scala> a.indexWhere(_>2,6)
res43: Int = 7

indices

返回当前序列索引集合

scala> a
res40: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3
scala> a.indices
res44: scala.collection.immutable.Range = Range(0, 1, 2, 3, 4, 5, 6, 7)

init

返回当前序列中不包含最后一个元素的序列

scala> a
res45: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)

scala> a.init
res46: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2)

scala> a.init.mkString("-")
res47: String = 1-2-3-4-5-1-2

inits

对集合中元素进行init操作，逐层减一，直至为空

scala> a
res45: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)
 scala> a.inits.foreach(x=>println(x.mkString(",")))
1,2,3,4,5,1,2,3
1,2,3,4,5,1,2
1,2,3,4,5,1
1,2,3,4,5
1,2,3,4
1,2,3
1,2
1
  --前面有值，为空

intersect

去两个集合的交集

 scala> a
res50: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)

scala> b
res51: Array[Int] = Array(1, 2)

scala> a.intersect(b)
res52: Array[Int] = Array(1, 2)

isDefinedAt

判断序列中是否存在指定索引

scala> a
res53: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)

scala> a.isDefinedAt(2)
res54: Boolean = true

scala> a.isDefinedAt(8)
res55: Boolean = false

isEmpty

判断当前序列是否为空

 scala> a
res56: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)

scala> a.isEmpty
res57: Boolean = false

isTraversableAgain

判断序列是否可以反复遍历 iterators返回false

 scala> a
res56: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)
scala> a.isTraversableAgain
res60: Boolean = true

scala> a.iterator.isTraversableAgain
res61: Boolean = false

iterator

对序列中每一个元素产生一个iterator

 scala> a
res56: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)
scala> a.iterator
res63: Iterator[Int] = non-empty iterator

last

返回序列中最后一个元素

scala> a
res65: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)

scala> a.last
res66: Int = 3

lastIndexOf

取得序列中最后一个等于 elem 的元素的位置，指定在 end 之前（包括）

 scala> a
res65: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)

scala> a.last
res66: Int = 3

scala> a.lastIndexOf(3,5)
res67: Int = 2

scala> a.lastIndexOf(3,9)
res68: Int = 7

lastIndexOfSlice

判断当前序列中是否包含序列 that，并返回最后一次出现该序列的位置处的索引

scala> a
res69: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)

scala> b
res70: Array[Int] = Array(1, 2)

scala> a.lastIndexOfSlice(b)
res71: Int = 5

scala> a.lastIndexOfSlice(b,4)
res72: Int = 0

lastIndexWhere

返回当前序列最后一个满足条件的元素的索引,可以指定在 end 之前（包括）的元素中查找

scala> a
res69: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)
scala> a.lastIndexWhere(_<3)
res75: Int = 6

scala> a.lastIndexWhere(_<3,4)
res76: Int = 1

lastOption

返回当前序列中最后一个对象

scala> a
res69: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)
scala> a.lastOption
res78: Option[Int] = Some(3)

length

返回当前序列中元素个数 size

scala> a
res80: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)

scala> a.length
res81: Int = 8

lengthCompare

比较序列真实长度和参数len

scala> a
res82: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)

scala> a.lengthCompare(3)
res83: Int = 5

map

对序列中元素进行f操作

scala> a
res84: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)

scala> a.map(_+10)
res85: Array[Int] = Array(11, 12, 13, 14, 15, 11, 12, 13)

max

返回序列中最大的元素

scala> a
res86: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)

scala> a.max
res87: Int = 5

maxBy / minBy

maxBy 返回序列中第一个符合条件的元素
minBy 返回序列中第一个不符合条件的元素

scala> a
res86: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)

scala> a.max
res87: Int = 5

scala> a.maxBy(_>5)
res88: Int = 1

scala> a.minBy(_>4)
res89: Int = 1

scala> a.maxBy(_>4)
res90: Int = 5

mkString

将所有元素组成一个字符串

scala> a
res93: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)

scala> a.mkString("(","-",")")
res94: String = (1-2-3-4-5-1-2-3)

nonEmpty

判断序列不是空

scala> a
res93: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)
scala> a.nonEmpty
res96: Boolean = true

padTo

后补齐，如果当前序列长度小于len，则用elem元素补齐至len长度

scala> a
res93: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)
scala> a.padTo(8,-1)
res97: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)

scala> a.padTo(10,-1)
res98: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3, -1, -1)

par

返回一个并行实现，产生的并行序列，不能被修改

scala> a
res93: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)
scala> a.par
res99: scala.collection.parallel.mutable.ParArray[Int] = ParArray(1, 2, 3, 4, 5, 1, 2, 3)

partition

按条件将序列拆成两个新的序列，满足条件的放到第一个序列中，
– 其余的放到第二个序列，下面以序列元素是否是 2 的倍数来拆分

scala> a
res102: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)

scala> a.partition(_%2==0)
res103: (Array[Int], Array[Int]) = (Array(2, 4, 2),Array(1, 3, 5, 1, 3))

scala> a.partition(_>=2)
res113: (Array[Int], Array[Int]) = (Array(2, 3, 4, 5, 2, 3),Array(1, 1))

patch

批量替换，从from开始，+替换内容+ 替换replaced个元素
把从一个值开始一定长度的内容，替换成你所需要的内容

scala> a
res118: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)

scala> a.patch(1,Array(-1,-1),2)
res119: Array[Int] = Array(1, -1, -1, 4, 5, 1, 2, 3)

scala> a.patch(1,Array(-1,-1),3)
res120: Array[Int] = Array(1, -1, -1, 5, 1, 2, 3)

scala> a.patch(1,Array(-1,-1),4)
res121: Array[Int] = Array(1, -1, -1, 1, 2, 3)

scala> a.patch(1,Array(-1,-1),5)
res122: Array[Int] = Array(1, -1, -1, 2, 3)

permutations

排列组合（combinations），combinations相当有个去重，相同元素的数组认作同一个

scala> var b=Array(1,2,3)
b: Array[Int] = Array(1, 2, 3)
scala> b.combinations(2)
res127: Iterator[Array[Int]] = non-empty iterator

scala> b.combinations(2).foreach(x=>println(x.mkString(",")))
1,2
1,3
2,3

scala> b.permutations.foreach(x=>println(x.mkString(",")))
1,2,3
1,3,2
2,1,3
2,3,1
3,1,2
3,2,1

prefixLength

给定一个条件，返回满足条件的长度
遇到不满足条件退出

scala> a
res84: Array[Int] = Array(1, 2, 7, 4)

scala> a.prefixLength(_>0)
res85: Int = 4

scala> a.prefixLength(_>1)
res86: Int = 0

product

返回所有元素的乘积

scala> b
res159: Array[Int] = Array(1, 2, 3)

scala> b.product
res160: Int = 6

reduce

和fold类似，但不需要初始值
reduceLeft/reduceRight
reduceLeftOption/reduceRightOption

scala> b
res159: Array[Int] = Array(1, 2, 3)
scala> b.reduce(_+_)
res162: Int = 6

reverse

反转序列

scala> b
res163: Array[Int] = Array(1, 2, 3)

scala> b.reverse
res164: Array[Int] = Array(3, 2, 1)

reverseIterator

反向生成迭代

scala> b
res167: Array[Int] = Array(1, 2, 3)

scala> b.reverseIterator.foreach(x=>println(x))
3
2
1

reverseMap

同Map方法向反

scala> b
res167: Array[Int] = Array(1, 2, 3)
scala> b.reverseMap(_+10)
res170: Array[Int] = Array(13, 12, 11)

scala> b.reverseMap(_+10).mkString(",")
res171: String = 13,12,11

sameElements

判断两个序列是否顺序和对应位置上的元素都一样

scala> a
res175: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)

scala> b
res176: Array[Int] = Array(1, 2, 3)
scala> a.containsSlice(b)
res173: Boolean = true

scala> a.sameElements(b)
res174: Boolean = false

scan

同fold，但scan会把每一步的计算结果放到一个新的集合中返回，而 fold 返回的是单一的值
scanLeft
scanRight

scala> a
res175: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)
scala> a.scan(1)((x,y)=>x+y)
res177: Array[Int] = Array(1, 2, 4, 7, 11, 16, 17, 19, 22)

scala> a.fold(1)((x,y)=>x+y)
res178: Int = 22

segmentLength

从序列的 from 处开始向后查找，所有满足 p 的连续元素的长度
当遇到不满足条件时则停止查找

 
scala> a
res179: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)
 scala> a.segmentLength(_>1,1)
res184: Int = 4

seq

产生一个引用当前序列的 sequential 视图

scala> a
res179: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)

scala> a.seq
res186: scala.collection.mutable.IndexedSeq[Int] = WrappedArray(1, 2, 3, 4, 5, 1, 2, 3)

size

序列元素个数 length
slice 取出当前序列中，from到util之间的片段（前包后不包）

scala> a
res179: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)

scala> a.size
res187: Int = 8

scala> a.slice(1,4)
res188: Array[Int] = Array(2, 3, 4)

sliding

从第一个元素开始，每size个元素组成一个数组，当剩余元素不够时，停止
sliding(m,n)表示从第一个开始以m个长度组成数组，n表示第二个数组从第n+个开始

scala> a
res179: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3)
scala> a.sliding(4).foreach(x=>println(x.mkString(",")))
1,2,3,4
2,3,4,5
3,4,5,1
4,5,1,2
5,1,2,3

scala> a.sliding(4,2).foreach(x=>println(x.mkString(",")))
1,2,3,4
3,4,5,1
5,1,2,3

scala> a.sliding(4,3).foreach(x=>println(x.mkString(",")))
1,2,3,4
4,5,1,2
2,3

scala> a.sliding(4,4).foreach(x=>println(x.mkString(",")))
1,2,3,4
5,1,2,3

sortBy

按指定的排序规则排序

scala> a
res12: Array[Int] = Array(1, 2, 3, 4, 5)

scala> a.sortBy(x=>x)
res13: Array[Int] = Array(1, 2, 3, 4, 5)

scala> a.sortBy(x=>(-x))
res14: Array[Int] = Array(5, 4, 3, 2, 1)

scala> a.sortBy(x=>x%2==0)
res15: Array[Int] = Array(1, 3, 5, 2, 4)

scala> a.sortBy(x=>x>5)
res16: Array[Int] = Array(1, 2, 3, 4, 5)

scala> a.sortBy(x=>x<5)
res17: Array[Int] = Array(5, 1, 2, 3, 4)

scala> a.sortBy(x=>x<3)
res18: Array[Int] = Array(3, 4, 5, 1, 2)

scala> a.sortBy(x=>x<2)
res19: Array[Int] = Array(2, 3, 4, 5, 1)

sorted

使用默认的排序规则对序列排序

scala> a
res20: Array[Int] = Array(1, 2, 3, 4, 5)

scala> a.sorted
res21: Array[Int] = Array(1, 2, 3, 4, 5)

scala> var b=Array("hello","how","are","you")
b: Array[String] = Array(hello, how, are, you)

scala> b.sorted
res22: Array[String] = Array(are, hello, how, you)

span

分割序列为两个集合，从第一个元素开始，直到找到第一个不满足条件的元素止

scala> a
res23: Array[Int] = Array(1, 2, 3, 4, 5)
scala> a.span(_<3)
res25: (Array[Int], Array[Int]) = (Array(1, 2),Array(3, 4, 5))

scala> var a=Array(1,1,1,11,2,2,2,6,7,14)
a: Array[Int] = Array(1, 1, 1, 11, 2, 2, 2, 6, 7, 14)
scala> a.span(_<10)
res28: (Array[Int], Array[Int]) = (Array(1, 1, 1),Array(11, 2, 2, 2, 6, 7, 14))

splitAt

从指定位置开始，把序列拆成两个集合

scala> a
res33: Array[Int] = Array(1, 1, 1, 11, 2, 2, 2, 6, 7, 14)

scala> a.splitAt(2)
res34: (Array[Int], Array[Int]) = (Array(1, 1),Array(1, 11, 2, 2, 2, 6, 7, 14))

scala> a.splitAt(4)
res35: (Array[Int], Array[Int]) = (Array(1, 1, 1, 11),Array(2, 2, 2, 6, 7, 14))

startsWith

从指定偏移处，是否以某个序列开始

 scala> a
res38: Array[Int] = Array(1, 1, 1, 11, 2, 2, 2, 6, 7, 14)

scala> var b =Array(1,1,1)
b: Array[Int] = Array(1, 1, 1)
 scala> a.startsWith(b)
res40: Boolean = true

scala> var b=Array(2,2,2)
b: Array[Int] = Array(2, 2, 2)

scala> a.startsWith(b,4)
res41: Boolean = true

stringPrefix

返回toString结果的前缀

scala> var a=Array(1,1,11,2,2,6,7,8,14)
a: Array[Int] = Array(1, 1, 11, 2, 2, 6, 7, 8, 14)

scala> a.stringPrefix
res0: String = [I

subSequence

返回start和end间的字符序列 (左包含右不包含)

scala> val aa=Array('a','b','c','d','e','f','d')
aa: Array[Char] = Array(a, b, c, d, e, f, d)

scala> aa.subSequence(3,5)
res2: CharSequence = de

sum

序列求和

scala> a
res3: Array[Int] = Array(1, 1, 11, 2, 2, 6, 7, 8, 14)

scala> a.sum
res4: Int = 52

tail

返回当前序列除了第一个元素的其他元素组成的序列

scala> a
res6: Array[Int] = Array(1, 1, 11, 2, 2, 6, 7, 8, 14)

scala> a.tail
res7: Array[Int] = Array(1, 11, 2, 2, 6, 7, 8, 14)

take

返回序列中前n个元素组成的序列

scala> a
res9: Array[Int] = Array(1, 1, 11, 2, 2, 6, 7, 8, 14)

scala> a.take(4)
res10: Array[Int] = Array(1, 1, 11, 2)

scala> a.take(5)
res11: Array[Int] = Array(1, 1, 11, 2, 2)

takeRight

返回当前序列中从右边开始，前n个元素组成的序列

scala> a
res12: Array[Int] = Array(1, 1, 11, 2, 2, 6, 7, 8, 14)

scala> a.takeRight(3)
res13: Array[Int] = Array(7, 8, 14)

scala> a.takeRight(5)
res14: Array[Int] = Array(2, 6, 7, 8, 14)

takeWhile

返回当前序列，从第一个元素开始，满足条件的连续元素组成的序列
遇到不满足条件的退出

scala> a
res15: Array[Int] = Array(1, 1, 11, 2, 2, 6, 7, 8, 14)

scala> a.takeWhile(_>0)
res16: Array[Int] = Array(1, 1, 11, 2, 2, 6, 7, 8, 14)

scala> a.takeWhile(x=>x%2==1)
res17: Array[Int] = Array(1, 1, 11)

toArray

转换成Array类型

 scala> var bb=List(1,2,3,4,5)
bb: List[Int] = List(1, 2, 3, 4, 5)

scala> bb.toArray
res18: Array[Int] = Array(1, 2, 3, 4, 5)

toBufffer

转换成Buffer类型

 scala> var bb=List(1,2,3,4,5)
bb: List[Int] = List(1, 2, 3, 4, 5)
scala> bb.toBuffer
res19: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3, 4, 5)

toIndexedSeq

转换成IndexedSeq类型

scala> var bb=List(1,2,3,4,5)
bb: List[Int] = List(1, 2, 3, 4, 5)
 
scala> bb.toIndexedSeq
res20: scala.collection.immutable.IndexedSeq[Int] = Vector(1, 2, 3, 4, 5)

tolterable

转换成可迭代的类型

 scala> a
res21: Array[Int] = Array(1, 1, 11, 2, 2, 6, 7, 8, 14)

scala> a.iterator
res22: Iterator[Int] = non-empty iterator

scala> res22.toIterable
res23: Iterable[Int] = Stream(1, ?)

toIterator 同iterator方法
toList 同List类型
toMap 同Map类型
toSeq 同Seq类型
toSet 同Set类型
toStream 同Stream类型
toVector 同Vector类型

transpose

矩阵转换，二维数组列转换

scala> a
res33: Array[Array[String]] = Array(Array(a, b), Array(c, d))

scala> a
res34: Array[Array[String]] = Array(Array(a, b), Array(c, d))

scala> a.transpose
res35: Array[Array[String]] = Array(Array(a, c), Array(b, d))

scala> a.transpose.flatten
res36: Array[String] = Array(a, c, b, d)

union

联合两个序列，同++

scala> a
res38: Array[Array[String]] = Array(Array(a, b), Array(c, d))
scala> var b=Array(1,1,1)
b: Array[Int] = Array(1, 1, 1)

scala> a.union(b)
res40: Array[Any] = Array(Array(a, b), Array(c, d), 1, 1, 1)

unzip

将含有两个元素的数组，转置

scala> val a=Array(("a","b"),("c","d"))
a: Array[(String, String)] = Array((a,b), (c,d))

scala> a.unzip
res42: (Array[String], Array[String]) = (Array(a, c),Array(b, d))

unzip3

将含有两个元素的数组，转置

scala> val a=Array(("a","b","x"),("c","d","y"))
a: Array[(String, String, String)] = Array((a,b,x), (c,d,y))

scala> a.unzip3
res44: (Array[String], Array[String], Array[String]) = (Array(a, c),Array(b, d),Array(x, y))

update

将序列中i索引出的元素更新为x

scala> val a=Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> a.update(2,7)

scala> a
res47: Array[Int] = Array(1, 2, 7, 4)

scala> a.updated(1,10)
res48: Array[Int] = Array(1, 10, 7, 4)

scala> a
res49: Array[Int] = Array(1, 2, 7, 4)

view

返回from到until间的序列，不包括until处的元素

scala> a
res49: Array[Int] = Array(1, 2, 7, 4)

scala> a.view(0,3)
res50: scala.collection.mutable.IndexedSeqView[Int,Array[Int]] = SeqViewS(...)

scala> a.view(0,2).toList
res51: List[Int] = List(1, 2)

scala> a.view(0,3).toList
res52: List[Int] = List(1, 2, 7)

withFilter

根据条件p过滤元素

scala> a
res63: Array[Int] = Array(1, 2, 7, 4)

scala> a.withFilter(_<5)
res64: scala.collection.generic.FilterMonadic[Int,Array[Int]] = scala.collection.TraversableLike$WithFilter@79aec8c0

scala> a.withFilter(_<5).foreach(println(_))
1
2
4

zip

将两个序列对应位置上的元素组成一个pair序列

scala> a
res69: Array[Int] = Array(1, 2, 7, 4)

scala> val b=Array(3,4,5,6)
b: Array[Int] = Array(3, 4, 5, 6)

scala> a.zip(b)
res70: Array[(Int, Int)] = Array((1,3), (2,4), (7,5), (4,6))

zipAll

同zip，但是允许两个序列长度不同
a.zipAll(b,this,that)this替代a不足的位置，that 替代b不足的位置

scala> a
res75: Array[Int] = Array(1, 2, 7, 4)

scala> b
res76: Array[Int] = Array(3, 4)

scala> a.zipAll(b,10,20)
res77: Array[(Int, Int)] = Array((1,3), (2,4), (7,20), (4,20))

scala> b.zipAll(a,10,20)
res78: Array[(Int, Int)] = Array((3,1), (4,2), (10,7), (10,4))

zipWithIndex

序列中的每个元素和它的索引组成一个序列

scala> a
res79: Array[Int] = Array(1, 2, 7, 4)

scala> a.zipWithIndex
res80: Array[(Int, Int)] = Array((1,0), (2,1), (7,2), (4,3))