scala函数

scala函数
++
将2个集合合并成新数组，新数组包含2个集合对象的内容
val
a=Array(1,2)

val b=Array(3,4)

a++b

res0: Array[Int] = Array(1, 2, 3, 4)

++:
同上，但是最后结果类型同：右侧的类型一样
val
a=Array(1,2)

val b=List(3,4,5)

a++:b

res1: List[Int] = List(1, 2, 3, 4, 5)

+:
在数组中添加一个数，24+:k在最前添加，k:+24在最后家
a:+43

res2: Array[Int] = Array(1, 2, 43)



scala> 43+:a

res3: Array[Int] = Array(43, 1, 2)

/:
对所有元素进行相同操作
val a = List(1,2,3,4)

 val c = (10 /: a)(_+_)   //1+2+3+4+10

:+
在数组中天机一个数，24+:k在最前添加，k:+24在最后家
a:+43

res2: Array[Int] = Array(1, 2, 43)



scala> 43+:a

res3: Array[Int] = Array(43, 1, 2)

:
foldRight的简写

addString
addString(b)

定义：def addString(b: StringBuilder): StringBuilder

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

addString(b, sep)

定义：def addString(b: StringBuilder, sep: String): StringBuilder

描述：将数组中的元素逐个添加到 StringBuilder 中，每个元素用 sep 分隔符分开

val
a = List(1,2,3,c)

scala> var g=new StringBuilder()

g: StringBuilder =



scala> a.addString(g)

res27: StringBuilder = 123c



scala>a.addString(g,",")

res28: StringBuilder = 123c1,2,3,c

def
addString(b: StringBuilder, start: String, sep: String, end: String):
StringBuilder

同上，在首尾各加一个字符串，并指定sep分隔符



a.addString(g,"{",",","}")

res17: StringBuilder = 3453,4,53,4,53,4,51,2{1,2}

aggregate
　
　
柯里化

andThen

apply
取出指定索引出的元素
a.apply(1)

res18: Int = 2

applyOrElse

array

canEqual
判断两个对象是否可以进行比较
val
a = List(1, 2, 3, 4)

val b = Array('a', 'b', 'c') 

println(a.canEqual(b)) // true

基本上所有对象都可以进行比较，我不知道这个方法的意义何在

charAt
获取
index 索引处的字符(这个方法会执行一个隐式的转换，

将 Array[T] 转换为 ArrayCharSequence，只有当 T 为 Char 类型时，这个转换才会发生)

val d=Array(‘a’,‘b’,‘c’)

d: Array[Char] = Array(a, b, c)

 d.charAt(0)

res30: Char = a

clone
创建一个副本，浅克隆
val
d=Array(‘a’,‘b’,‘c’)

d.clone()

res33: Array[Char] = Array(a, b, c)

collect
通过执行一个并行计算（偏函数），得到一个新的数组对象
scala>
a

res46: Array[Int] = Array(1, 2)



scala> val func:PartialFunction[Int,Int]={

     | case x if x%2==0 =>

x+2

     | case x => x

     | }

func: PartialFunction[Int,Int] = <function1>



scala> a.collect(func)

res47: Array[Int] = Array(1, 4)

collectFirst
在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算
scala>
val func1:PartialFunction[Int,Int]={

     | case x => x+1

     | }

func1: PartialFunction[Int,Int] = <function1>



scala> a.collectFirst(func1)

res48: Option[Int] = Some(2)

combinations
def
combinations(n: Int): collection.Iterator[Array[T]]

排列组合，这个排列组合会选出所有包含字符不一样的组合，对于 “abc”、“cba”，只选择一个，参数n表示序列长度，就是几个字符为一组

scala>
val d=Array(“A”,“b”,“c”,“d”)

d: Array[String] = Array(A, b, c, d)



scala> d.combinations(2)

res54: Iterator[Array[String]] = non-empty iterator



scala> res54.foreach(x=>println(x.mkString(",")))

A,b

A,c

A,d

b,c

b,d

c,d

companion

compose

contains
判断序列中是否包含指定对象
scala>
d

res59: Array[String] = Array(A, b, c, d)

scala> d.contains("A")

res61: Boolean = true

containsSlice
判断当前序列中是否包含另一个序列（指的是内容）
val a=List(1,2,3,4)

a: List[Int] = List(1, 2, 3, 4)



scala> val b=List(1,2)

b: List[Int] = List(1, 2)



scala> a.containsSlice(b)

res62: Boolean = true

copyToArray
将当前数组元素复制到另一个数组中(值适用于Array)

copyToArray(xs: Array[A], start: Int): Unit 

copyToArray(xs: Array[A], start: Int, len: Int): Unit

scala>
val a=Array(1,2,3,4,5)

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

scala> val b: Array[Int] = new Array(5)

b: Array[Int] = Array(0, 0, 0, 0, 0)



scala> a.copyToArray(b)



scala> 

println(b.mkString(","))

1,2,3,4,5



scala> b

res70: Array[Int] = Array(1, 2, 3, 4, 5)

val
a = Array(‘a’, ‘b’, ‘c’)

val b : Array[Char] = new Array(5)

a.copyToArray(b)    /**b中元素

[‘a’,‘b’,‘c’,0,0]*/

a.copyToArray(b,1)  /**b中元素

[0,‘a’,0,0,0]*/

a.copyToArray(b,1,2)    /**b中元素

[0,‘a’,‘b’,0,0]*/

copyToBuffer
注意：用之前得先导包import scala.collection.mutable.ArrayBuffer

将数组中的元素复制到 Buffer 中

scala>
import scala.collection.mutable.ArrayBuffer

import scala.collection.mutable.ArrayBuffer



scala>  val bb: ArrayBuffer[Int] =

ArrayBuffer()

bb: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()



scala> a.copyToBuffer(bb)



scala> bb

res77: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4,

corresponds
判断两个序列的长度以及对应位置元素是否符合某个条件。如果两个序列具有相同的元素数量并且
p(x, y)=true，则返回 true
res83:
Array[Int] = Array(1, 2, 3, 4, 5)

scala> val aaa=Array(1,2,3,4,5)

aaa: Array[Int] = Array(1, 2, 3, 4, 5)



scala> a.corresponds(aaa)(_==_)

res85: Boolean = true



scala> c

res86: List[Int] = List(1, 2, 3, 4, 5)



scala> a.corresponds(c)(_==_)

res87: Boolean = true

ArrayList底层是数组

count
统计符合条件的元素个数
scala>
a

res88: Array[Int] = Array(1, 2, 3, 4, 5)

scala> a.count(x => x>2)

res90: Int = 3

deep

diff
计算当前数组与另一个数组的差集，即将当前数组中没有在另一个数组中出现的元素返回
scala>
a

res95: Array[Int] = Array(1, 2, 3, 4, 5)



scala> val b=Array(4,5,6,7,8)

b: Array[Int] = Array(4, 5, 6, 7, 8)



scala> a.diff(b)

res96: Array[Int] = Array(1, 2, 3)

distinct
去除当前集合中重复的元素，只保留一个
scala>
val e=Array(1,1,2,23,3,3)

e: Array[Int] = Array(1, 1, 2, 23, 3, 3)



scala> e.distinct

res102: Array[Int] = Array(1, 2, 23, 3)

drop
将当前数组中前 n
个元素去除，返回一个新数组
scala>
a

res103: Array[Int] = Array(1, 2, 3, 4, 5)



scala> a.drop(3)

res104: Array[Int] = Array(4, 5)

dropRight
功能同 drop，去掉尾部的 n 个元素
scala>
a

res105: Array[Int] = Array(1, 2, 3, 4, 5)



scala> a.dropRight(2)

res106: Array[Int] = Array(1, 2, 3)

dropWhile
去除当前数组中符合条件的元素，返回剩余的数组，这个需要

一个条件，就是从当前数组的第一个元素起，就要满足条件，直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），否则返回整个数组

scala>
a

res103: Array[Int] = Array(1, 2, 3, 4, 5)



scala> a.dropWhile(x => x<3)

res108: Array[Int] = Array(3, 4, 5)



scala> a.dropWhile(x => x>3)

res109: Array[Int] = Array(1, 2, 3, 4, 5)

elemManifest

elemTag

endsWith
判断当前序列是否以某个序列结尾
scala> val a = Array(1, 2, 3, 4)

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



scala> val b = Array(3, 4)

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



scala> a.endsWith(b)

res113: Boolean = true

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

res114: Array[Int] = Array(1, 2, 3, 4)



scala> a.exists(x => x==2)

res115: Boolean = true

filter
取得当前数组中符合条件的元素，组成新的数组返回
scala>
a

res116: Array[Int] = Array(1, 2, 3, 4)



scala> a.filter(x => x>2)

res117: Array[Int] = Array(3, 4)

filterNot
取得当前数组中不符合条件的元素，组成新的数组返回
scala>
a.filterNot(x => x>2)

res118: Array[Int] = Array(1, 2)

find
查找第一个符合条件的元素，返回 Option
scala>
a

res119: Array[Int] = Array(1, 2, 3, 4)



scala> a.find(x => x>2)

res120: Option[Int] = Some(3)

flatMap
先映射再展开

flatten
将二维数组的所有元素联合在一起，形成一个一维数组返回

降维

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

cc: Array[Array[Int]] = Array(Array(1, 2), Array(3, 4))

cc.flatten

res1: Array[Int] = Array(1, 2, 3, 4)

fold
对序列中的每个元素进行二元运算，和aggregate有类似的语义，但执行过程有所不同，我们来对比一下他们的执行过程。

因为aggregate需要两个处理方法，所以我们定义一个combine方法

a.fold(5)(+)

res4: Int = 20

类似于： seq_exp=5+1

    seq_exp=5+1

    seq_exp=7+2

    seq_exp=9+3

    seq_exp=12+4

foldLeft
从左到右计算，简写方式：def
/:[B](z: B)(op: (B, T) ⇒ B): B
a.fold(5)(+)

res4: Int = 20

类似于： seq_exp=5+1

    seq_exp=5+4

    seq_exp=9+3

    seq_exp=12+2

    seq_exp=14+1

foldRight
从右到左计算
a.fold(5)(+)

res4: Int = 20

类似于： seq_exp=5+1

    seq_exp=5+1

    seq_exp=7+2

    seq_exp=9+3

    seq_exp=12+4

forall
检测序列中的元素是否都满足条件
p，如果序列为空，返回true
scala>
val a=Array(1,2,3,4)

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



scala> a.forall(x => x>0)

res0: Boolean = true



scala> a.forall(x => x>2)

res1: Boolean = false

foreach
遍历序列中的元素
a.foreach(x=>println(x))

1

2

3

4

genericBuilder

groupBy
按条件分组，条件由
f 匹配，返回值是Map类型，每个key对应一个序

列，下面代码实现的是，把小于3的数字放到一组，大于3的放到一组，返回Map[String,Array[Int]]

a.groupBy(x
=> x match{

     | case x if (x%2==0) =>

“ou”

     | case x =>

“ji”

     | });

res7: scala.collection.immutable.Map[String,Array[Int]] = Map(ou ->

Array(2, 4), ji -> Array(1, 3))

grouped
按指定数量分组，每组有 size
数量个元素，返回一个集合
a.grouped(2).toList

res10: List[Array[Int]] = List(Array(1, 2), Array(3, 4))

hasDefiniteSize
检测序列是否存在有限的长度，对应Stream这样的流数据，返回false

可以判定是否为流

a.hasDefiniteSize

res13: Boolean = true

head
返回序列的第一个元素，如果序列为空，将引发错误
scala>
a.head

res14: Int = 1

headOption
返回Option类型对象，就是scala.Some
或者 None，如果序列

是空，返回None

a.headOption

res15: Option[Int] = Some(1)

scala> val a:Array[Int]=Array()

a: Array[Int] = Array()



scala> a.headOption

res13: Option[Int] = None

indexOf
def
indexOf(elem: T): Int

返回elem在序列中的索引，找到第一个就返回

def indexOf(elem: T, from: Int): Int 

返回elem在序列中的索引，可以指定从某个索引处（from）开始查找，找到第一个就返回

a.indexOf(3)

res17: Int = 2

a.indexOf(3,2)

res20: Int = 2

indexOfSlice
def
indexOfSlice[B >: A](that: GenSeq[B]): Int

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

def indexOfSlice[B >: A](that: GenSeq[B], from: Int): Int 

检测当前序列中是否包含另一个序列（that），并返回第一个匹配出现的元素的索引，指定从 from 索引处开始

scala>
a.indexOfSlice(Array(1,2))

res21: Int = 0



scala> a.indexOfSlice(Array(2,3))

res22: Int = 1



scala> a.indexOfSlice(Array(3,4),2)

res25: Int = 2

indexWhere
返回当前序列中第一个满足
p 条件的元素的索引，可以指定从 from

索引处开始

a.indexWhere(x
=> x>3)

res26: Int = 3

indices
返回当前序列索引集合
a.indices

res27: scala.collection.immutable.Range = Range(0, 1, 2, 3)

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

res28: Array[Int] = Array(1, 2, 3)

inits
对集合中的元素进行
init

操作，该操作的返回值中，

第一个值是当前序列的副本，包含当前序列所有的元素，最后一个值是空的，对头尾之间的值进行init操作，上一步的结果作为下一步的操作对象
scala>
a.inits

res29: Iterator[Array[Int]] = non-empty iterator



scala> a.inits.foreach(x=>println(x))

[I@2cc5c89

[I@53a1fe02

[I@33e8247d

[I@27992ec3

[I@47d116ad



scala> a.inits.foreach(x=>println(x.mkString(",")))

1,2,3,4

1,2,3

1,2

1

intersect
取两个集合的交集
scala>
val b=Array(4,5,6,7)

b: Array[Int] = Array(4, 5, 6, 7)



scala> a.intersect(b)

res32: Array[Int] = Array(4)

isDefinedAt
判断序列中是否存在指定索引
scala>
a.isDefinedAt(3)

res33: Boolean = true



scala> a.isDefinedAt(11)

res34: Boolean = false

isEmpty
判断当前序列是否为空
a.isEmpty

res35: Boolean = false

isTraversableAgain
判断序列是否可以反复遍

历，该方法是GenTraversableOnce中的方法，对于 Traversables 一般返回true，对于 Iterators 返回

false，除非被复写
scala>
a.inits

res36: Iterator[Array[Int]] = non-empty iterator



scala> a.inits.isTraversableAgain

res37: Boolean = false



scala> a.isTraversableAgain

res38: Boolean = true

iterator
对序列中的每个元素产生一个
iterator，没有返回值
val a = Array(1, 2, 3, 4, 5)

a.inits

res36: Iterator[Array[Int]] = non-empty iterator

last
取得序列中最后一个元素
a.last

res43: Int = 4

lastIndexOf
def
lastIndexOf(elem: T): Int

取得序列中最后一个等于 elem 的元素的位置

def lastIndexOf(elem: T, end: Int): Int 

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

scala>
a.lastIndexOf(3)

res44: Int = 2



scala> a

res45: Array[Int] = Array(1, 2, 3, 4)

scala> a.lastIndexOf(3,2)

res46: Int = 2



scala> a.lastIndexOf(3,3)

res47: Int = 2

lastIndexOfSlice
def
lastIndexOfSlice[B >: A](that: GenSeq[B]): Int

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

def lastIndexOfSlice[B >: A](that: GenSeq[B], end: Int): Int 

判断当前序列中是否包含序列 that，并返回最后一次出现该序列的位置处的索引，可以指定在 end 之前（包括）的元素中查找

val
b=Array(1,1,2,3,5,1,2)

b: Array[Int] = Array(1, 1, 2, 3, 5, 1, 2)

 b.lastIndexOfSlice(Array(1,2))

res49: Int = 5

lastIndexWhere
def
lastIndexWhere(p: (T) ⇒
Boolean): Int

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

def lastIndexWhere(p: (T) ⇒ Boolean, end: Int): Int 

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

b.lastIndexWhere(x => x>3)

res53: Int = 4



scala> b.lastIndexWhere((x => x>3),3)

res54: Int = -1



scala> b.lastIndexWhere((x => x>3),5)

res55: Int = 4

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

res56: Option[Int] = Some(2)

length
返回当前序列中元素个数
b.length

res58: Int = 7

lengthCompare
比较序列的长度和参数
len，根据二者的关系返回不同的值，比较规则是

x <  0       if this.length <  len

x == 0       if this.length ==

len

x >  0       if this.length >  len

b.lengthCompare(3)

res59: Int = 4



scala> b.lengthCompare(31)

res60: Int = -24



scala> b.lengthCompare(1)

res61: Int = 6

lift

map
对序列中的元素进行 f 操作
b.map(x=>x+1)

res63: Array[Int] = Array(2, 2, 3, 4, 6, 2, 3)

max
返回序列中最大的元素
b.max

res64: Int = 5

maxBy
返回序列中第一个符合条件的最大的元素
b.maxBy(x
=> x>2)

res65: Int = 3

min
返回序列中最小的元素
b.min

res66: Int = 1

minBy
返回序列中第一个符合条件的最小的元素
b.minBy(x
=> x>3)

res67: Int = 1



b.minBy(x => x<3)

res69: Int = 3

mkString
def
mkString: String

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

def mkString(sep: String): String 

将所有元素组合成一个字符串，以 sep 作为元素间的分隔符

def mkString(start: String, sep: String, end: String): String 

将所有元素组合成一个字符串，以 start 开头，以 sep 作为元素间的分隔符，以 end 结尾

b.mkString

res70: String = 1123512



scala> b.mkString(",")

res71: String = 1,1,2,3,5,1,2



scala> b.mkString("{",",","}")

res72: String = {1,1,2,3,5,1,2}

nonEmpty
判断序列不是空
b.nonEmpty

res73: Boolean = true

orElse

padTo
后补齐序列，如果当前序列长度小

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

scala>
b.padTo(7,3)

res75: Array[Int] = Array(1, 1, 2, 3, 5, 1, 2)



scala> b.padTo(8,3)

res76: Array[Int] = Array(1, 1, 2, 3, 5, 1, 2, 3)

par

partition
按条件将序列拆分成两个新的序列，满足条件的放到第一个

序列中，其余的放到第二个序列，下面以序列元素是否是 2 的倍数来拆分

b.partition(x
=> x>4)

res77: (Array[Int], Array[Int]) = (Array(5),Array(1, 1, 2, 3, 1, 2))

patch
批量替换，从原序列的
from 处开始，后面的 replaced 数量个元素，将被替换成序列 that

b

res81: Array[Int] = Array(1, 1, 2, 3, 5, 1, 2)

 b.patch(2,Array(88,2,3),2)

res80: Array[Int] = Array(1, 1, 88, 2, 3, 5, 1, 2)

permutations
排列组合，他与combinations不同的是，组合中的内容可以

相同，但是顺序不能相同，combinations不允许包含的内容相同，即使顺序不一样

scala>
a.permutations.foreach(x=>println(x.mkString(",")))

1,2,3,4

1,2,4,3

1,3,2,4

1,3,4,2

1,4,2,3

1,4,3,2

2,1,3,4

2,1,4,3

2,3,1,4

2,3,4,1

2,4,1,3

2,4,3,1

3,1,2,4

3,1,4,2

3,2,1,4

3,2,4,1

3,4,1,2

3,4,2,1

4,1,2,3

4,1,3,2

4,2,1,3

4,2,3,1

4,3,1,2

4,3,2,1

prefixLength
给定一个条件
p，返回一个前置数列的长度，这个数列中的元素都满足 p
b.prefixLength(x => x<3)

res94: Int = 3

product
返回所有元素乘积的值
b.product

res95: Int = 60

reduce
同fold，但是不需要外加值
a.reduce(+)

res6: Int = 15



    seq_exp=1+2

    seq_exp=3+3

    seq_exp=6+4

    seq_exp=10+5

reduceLeft
从左向右计算
a.reduceLeft(+)

res6: Int = 15



    seq_exp=1+2

    seq_exp=3+3

    seq_exp=6+4

    seq_exp=10+5

reduceRight
从右向左计算
a.reduceRight(+)

res6: Int = 15



    seq_exp=5+4

    seq_exp=9+3

    seq_exp=12+2

    seq_exp=14+1

reduceLeftOption
同reduceLeft，只不过可以多一个可以判断是否为空，如果为空，返回Some,

如果不为空，同reduceLeft操作

reduceOption
同reduce，只不过可以多一个可以判断是否为空，如果为空，返回Some,

如果不为空，同reduce操作

reduceRightOption
同reduceRight，只不过可以多一个可以判断是否为空，如果为空，返回Some,

如果不为空，同reduceRight操作

repr

reverse
反转序列
b.reverse

res96: Array[Int] = Array(2, 1, 5, 3, 2, 1, 1)

reverseIterator
反向生成迭代

reverseMap
反向，对每个值进行操作
a.reverseMap(_*10)

res7: Array[Int] = Array(50, 40, 30, 20, 10)

runWith

sameElements
判断两个序列是否顺序和对应位置上的元素都一样
val a = Array(1,2,3,4,5)

    val b = Array(1,2,3,4,5)

    println(a.sameElements(b))  // true

 

    val c = Array(1,2,3,5,4)

    println(a.sameElements(c))  // false

scan
用法同
fold，scan会把每一步的计算结果放到一个新的集合中返回，而 fold

返回的是单一的值

a.scan(3)(+)

res10: Array[Int] = Array(3, 4, 6, 9, 13, 18)

scanLeft
从左向右计算

scanRight
从右向左计算

segmentLength
从序列的 from
处开始向后查找，所有满足 p 的连续元素的长度
val
a = Array(1,2,3,1,1,1,1,1,4,5)

scala> a.segmentLength(_>1,1)

res12: Int = 2

scala> a.segmentLength(_<4,0)

res14: Int = 8

seq
产生一个引用当前序列的
sequential 视图
scala>
a.seq

res15: scala.collection.mutable.IndexedSeq[Int] = WrappedArray(1, 2, 3, 1,

1, 1, 1, 1, 4, 5)

size
序列元素个数，同 length

slice
取出当前序列中，from
到 until 之间的片段，def slice(from: Int, until: Int): Array[T]

指的是下标（左包括，右不包括）

scala>
val e=Array(1,2,3,4,5)

e: Array[Int] = Array(1, 2, 3, 4, 5)



scala> e.slice(1,4)

res18: Array[Int] = Array(2, 3, 4)

sliding
从第一个元素开始，每个元素和它后面的
size - 1 个元素组

成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止

scala>
e.sliding(3).toList

res22: List[Array[Int]] = List(Array(1, 2, 3), Array(2, 3, 4), Array(3, 4,

5))

sortBy
按指定的排序规则排序
scala>
a.sortBy(x=> x)

res29: Array[Int] = Array(1, 1, 1, 1, 1, 1, 2, 3, 4, 5)

sortWith
自定义排序方法 lt
scala>
a.sortWith(.compareTo()>0)

res30: Array[Int] = Array(5, 4, 3, 2, 1, 1, 1, 1, 1, 1)



scala> a.sortWith(_.compareTo(_)<0)

res31: Array[Int] = Array(1, 1, 1, 1, 1, 1, 2, 3, 4, 5)

sorted
使用默认的排序规则对序列排序
a.sorted

res32: Array[Int] = Array(1, 1, 1, 1, 1, 1, 2, 3, 4, 5)

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

件的元素止，之前的元素放到第一个集合，其它的放到第二个集合

scala>
a.sortWith(.compareTo()>0)

res30: Array[Int] = Array(5, 4, 3, 2, 1, 1, 1, 1, 1, 1)



scala> a.sortWith(_.compareTo(_)<0)

res31: Array[Int] = Array(1, 1, 1, 1, 1, 1, 2, 3, 4, 5)

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

指的是位置，不是下标

scala>
a.splitAt(2)

res34: (Array[Int], Array[Int]) = (Array(1, 2),Array(3, 1, 1, 1, 1, 1, 4,

5))

startsWith
从指定偏移处，是否以某个序列开始
scala>
a.startsWith(Array(3,1),1)

res40: Boolean = false



scala> a.startsWith(Array(3,1),2)

res41: Boolean = true

stringPrefix
返回 toString 结果的前缀
scala>
a.stringPrefix

res42: String = [I



scala> a.toString

res43: String = [I@29bbb270

subSequence
返回
start 和 end 间的字符序列

不是下标

scala>
val b=Array(‘a’,‘b’,‘c’,‘d’)

b: Array[Char] = Array(a, b, c, d)



scala> b.subSequence(2,4)

res46: CharSequence = cd

sum
序列求和

tail
返回除了当前序列第一个元素的其它元素组成的序列
scala>
a.tail

res47: Array[Int] = Array(2, 3, 1, 1, 1, 1, 1, 4, 5)

tails
　
scala>
a.tails.toList

res49: List[Array[Int]] = List(Array(1, 2, 3, 1, 1, 1, 1, 1, 4, 5),

Array(2, 3, 1, 1, 1, 1, 1, 4, 5),

 Array(3, 1, 1, 1, 1, 1, 4, 5),

 Array(1, 1, 1, 1, 1, 4, 5), 

Array(1, 1, 1, 1, 4, 5), 

Array(1, 1, 1, 4, 5), 

Array(1, 1, 4, 5),

 Array(1, 4, 5),

 Array(4, 5), 

Array(5),

 Array())

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

不是指下标

scala>
a.take(3)

res50: Array[Int] = Array(1, 2, 3)



scala> a

res51: Array[Int] = Array(1, 2, 3, 1, 1, 1, 1, 1, 4, 5)

takeRight
返回当前序列中，从右边开始，选择 n
个元素组成的序列
scala>
a

res51: Array[Int] = Array(1, 2, 3, 1, 1, 1, 1, 1, 4, 5)



scala> a.takeRight(3)

res52: Array[Int] = Array(1, 4, 5)

takeWhile
返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列
scala>
a.takeWhile(_<4)

res54: Array[Int] = Array(1, 2, 3, 1, 1, 1, 1, 1)

to

toArray
转换成 Array 类型

toBuffer
转换成 Buffer 类型

toIndexedSeq
转换成 IndexedSeq 类型

toIterable
转换成可迭代的类型

toIterator
对序列中的每个元素产生一个
iterator，没有返回值

toList
转换成 List类型

toMap
同
Map 类型，需要被转化序列中包含的元素时 Tuple2 类型数据

变成键值对

scala>
val chars =
Array((“a”,“b”),(“c”,“d”),(“e”,“f”))

chars: Array[(String, String)] = Array((a,b), (c,d), (e,f))



scala> chars.toMap

res60: scala.collection.immutable.Map[String,String] = Map(a -> b, c

-> d, e -> f)

toSeq
同 Seq 类型

toSet
同 Set 类型

toStream
同 Stream 类型

toTraversable
同Traversable类型

toVector
同 Vector 类型

transform

transpose
矩阵转换，二维数组行列转换
scala> val chars =
Array(Array(“a”,“b”),Array(“c”,“d”),Array(“e”,“f”))

chars: Array[Array[String]] = Array(Array(a, b), Array(c, d), Array(e, f))

scala> chars.transpose

res61: Array[Array[String]] = Array(Array(a, c, e), Array(b, d, f))

union
联合两个序列，同操作符 ++

unzip
将含有两个元素的数组，第一个元素取出组成一个序列，第二个元素组成一个序列
scala>
val chars =
Array((“a”,“b”),(“c”,“d”))

chars: Array[(String, String)] = Array((a,b), (c,d))



scala> chars.unzip

res62: (Array[String], Array[String]) = (Array(a, c),Array(b, d))

unzip3
将含有三个元素的三个数组，第一个元素取出组成一个序列，第二个元素组成一个

序列，第三个元素组成一个序列

update
将序列中 i 索引处的元素更新为 x
res63:
Array[Int] = Array(1, 2, 3, 1, 1, 1, 1, 1, 4, 5)

scala> a.update(1,33)



scala> a

res65: Array[Int] = Array(1, 33, 3, 1, 1, 1, 1, 1, 4, 5)

updated
将序列中 i 索引处的元素更新为 x
,并返回替换后的数组
scala>
a.updated(1,44)

res66: Array[Int] = Array(1, 44, 3, 1, 1, 1, 1, 1, 4, 5)

view
返回 from 到 until
间的序列，不包括 until 处的元素
scala>
a.view(1,4).toList

res69: List[Int] = List(33, 3, 1)

withFilter
根据条件 p 过滤元素
scala>
a.withFilter(x => x<3).foreach(println)

1

1

1

1

1

1

zip
将两个序列对应位置上的元素组成一个pair序列
scala>
val a=Array(1,2,3)

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



scala> val b=Array(4,5,6)

b: Array[Int] = Array(4, 5, 6)



scala> a.zip(b)

res80: Array[(Int, Int)] = Array((1,4), (2,5), (3,6))

zipAll
同
zip ，但是允许两个序列长度不一样，不足的自动填充，如果当前序列

端，空出的填充为 thisElem，如果 that 短，填充为 thatElem

scala>
val c=Array(1,2,3,4,5)

c: Array[Int] = Array(1, 2, 3, 4, 5)



scala> a.zipAll(c,3,3)

res81: Array[(Int, Int)] = Array((1,1), (2,2), (3,3), (3,4), (3,5))



scala> a.zipAll(c,3,7)

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



scala> val c=Array(1,2)

c: Array[Int] = Array(1, 2)



scala> a.zipAll(c,3,7)

res83: Array[(Int, Int)] = Array((1,1), (2,2), (3,7))

zipWithIndex
列中的每个元素和它的索引组成一个序列
scala>
a.zipWithIndex

res85: Array[(Int, Int)] = Array((1,0), (2,1), (3,2))