Scala数组函数(isDefinetAt~segmentLength)

isDefinedAt
判断序列中指定索引是否存在数据。

var a= Array(1, 2, 3, 4, 5)

scala> a.isDefinedAt(1)
res10: Boolean = true

scala> a.isDefinedAt(6)
res11: Boolean = false

isEmpty
判断当前序列是否为空

scala> a.isEmpty
res12: Boolean = false

isTraversableAgain
判断序列是否可以反复遍历，对于Iterators会返回false。

var b=a.grouped(2)
b: Iterator[Array[Int]] = non-empty iterator
scala> b.isTraversableAgain
res16: Boolean = false

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

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

scala> b.foreach(println)
1
2
3
4
5

last
取得序列中最后一个等于指定元素的位置。

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

scala> a.last
 Int = 5

lastIndexOf
取得序列中最后一个等于指定元素的位置。

scala> a.lastIndexOf(2)
 Int = 1

可以指定在某截止位置前查找

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

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

scala> arr.lastIndexOf(1)
 Int = 6

scala> arr.lastIndexOf(1,4)
 Int = 2

lastIndexOfSlice
判断当前序列中是否包含指定的序列

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

scala> var b=Array(1,2,3)
b: Array[Int] = Array(1, 2, 3)
//最后一次出现的初始位置
scala> a.lastIndexOfSlice(b)
 Int = 6

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

scala> a.lastIndexOfSlice(b)
 Int = 0

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

var a=Array(1, 2, 3, 2, 4, 5, 1, 2, 5)
a.lastIndexWhere(_<3)
//结果
Int = 7

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

可以指定在end之前（包括end）的元素中查找。

a.lastIndexWhere(_<3,5)
//结果，到索引为5的元素为止
Int = 3

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

a.lastOption
//Option[Int] = Some(5)

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

a.length
Int = 9

lengthCompare

-def lengthCompare(len: Int): Int

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

x < 0 if this.length < len
x == 0 if this.length == len
x > 0 if this.length > len

scala> a.lengthCompare(9)
res48: Int = 0

scala> a.lengthCompare(10)
res49: Int = -1

scala> a.lengthCompare(8)
res50: Int = 1

map
对序列中的元素进行相应的操作。

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

scala> var b=a.map(_*2)
b: Array[Int] = Array(2, 4, 6, 4, 8, 10, 2, 4, 10)

max
查找序列中最大的元素

a.max
Int = 5

minBy
查找序列中第一个符合条件的最大元素，如果未找到，则返回第一个元素

a.minBy(_>3)
Int = 1

mkString

-def mkString(sep: String): String

将元素组成一个字符串，可以以seq作为元素分隔符

a.mkString
String = 123245125

a.mkString("|")
String = 1|2|3|2|4|5|1|2|5

nonEmpty
判断序列不为空，如果为空返回false，否则返回true。
padTo

def padTo(len: Int, elem: A): Array[A]

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

scala> var a=Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)
//指定位数3小于a的位数，所以不用补
scala> a.padTo(3,2)
res73: Array[Int] = Array(1, 2, 3, 4)
//指定5位，缺少的补上5
scala> a.padTo(5,5)
res74: Array[Int] = Array(1, 2, 3, 4, 5)

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

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

a.par
scala.collection.parallel.mutable.ParArray[Int] = ParArray(1, 2, 3, 4)

partition
将序列拆分成两个新的序列，满足条件的放在第一个，其余的放在第二个

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

 a.partition(x=>x%2==0)
 (Array[Int], Array[Int]) = (Array(2, 4),Array(1, 3))

patch

-def patch(from: Int, that: GenSeq[A], replaced: Int): Array[A]

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

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

scala> var b=Array(11,12,13)
b: Array[Int] = Array(11, 12, 13)
//设置替换1个，把a中的4替换成了b数组
scala> a.patch(3,b,1)
res80: Array[Int] = Array(1, 2, 3, 11, 12, 13, 5, 6, 7, 8)
scala> a.patch(3,b,2)
res81: Array[Int] = Array(1, 2, 3, 11, 12, 13, 6, 7, 8)
//从第三个开始，把后面5个元素替换成b的元素
a.patch(3,b,5)
res82: Array[Int] = Array(1, 2, 3, 11, 12, 13)

permutations
排序组合，组合中的内容可以相同但顺序不能相同。和combinations不同处在于，combinations不允许包含相同的内容。

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

scala> var b=a.permutations.toList
b: List[Array[Int]] = List(Array(1, 2, 3), Array(1, 3, 2), Array(2, 1, 3), Array(2, 3, 1), Array(3, 1, 2), Array(3, 2, 1))

scala> var c=a.combinations(3).toList
c: List[Array[Int]] = List(Array(1, 2, 3))

prefixLength
指前几个连续元素满足一定条件，返回满足条件的元素的数量。

var a=Array(1,2,3)
scala> a.prefixLength(_<2)
res85: Int = 1

scala> a.prefixLength(_<3)
res86: Int = 2

scala> a.prefixLength(_<4)
res87: Int = 3

scala> a.prefixLength(_>2)
res88: Int = 0

product
所有元素的乘积

a.product
Int = 6

reduce
和fold，但是不需要初始值

a.reduce(_+_)
Int = 6

reduceLeft
同reduce，从左向右计算
reduceRight
从右向左计算

scala> a.reduceRight((x,y)=>{println(x,y);x+y})
(2,3)
(1,5)
res95: Int = 6

reduceLeftOption
计算Option,得到一个Option结果

a.reduceLeftOption(_+_)
Option[Int] = Some(6)

reduceRightOption
用法同上，从右开始计算

reverse
反转序列

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

reverseIterator
反向生成迭代

a.reverseIterator
Iterator[Int] = non-empty iterator

a.reverseIterator.toList
 List[Int] = List(3, 2, 1)

reverseMap
同map的方向相反

a.reverseMap(_*10)
 Array[Int] = Array(30, 20, 10)

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

var a=Array(1,2,3)
var b=Array(1,2,3)
a.sameElements(b)
 Boolean = true

scan
用法同fold，不过scan会把返回的结果全放到一个新的序列中去，fold值返回一个值。’

//定义一个初始值4
scala> a.scan(4)((x,y)=>{println(x,y);x+y})
(4,1)
(5,2)
(7,3)
res105: Array[Int] = Array(4, 5, 7, 10)

scala> a.scan(4)(_+_)
res106: Array[Int] = Array(4, 5, 7, 10)

scanLeft
从左向右计算
scanRight
从右向左计算
segmentLength

def segmentLength(p: (T) ⇒ Boolean, from: Int): Int

从序列的 from 处开始向后查找，所有满足 p 的连续元素的长度

var a=Array(2,3,1,3,4,6,3,7,4)
//小于4的，从第1个元素开始查找，不包括第一个
a.segmentLength(_<4,1)
Int=3