【使用案例齐全】Scala数组方法大全

Scala数组

作用：存储固定大小的元素
特点：索引从0开始
声明和赋值：

var k = Array(1,2,3);
//或者r
var arr = Array[Int](1,2,3,4,5)

数组方法

1. ++并集

使用范式：def ++[B](that: GenTraversableOnce[B]): Array[B]
作用：求数组并集

k++arr
//或
k.++(arr)
//输出
res46: Array[Int] = Array(1, 2, 3, 1, 2, 3, 4, 5)

2. ++: ，并集：根据冒号右边类型确定返回类型

使用范式：def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Array[T], B, That]): That
使用说明：并集：根据冒号右边类型确定返回类型

val ff = Seq(2,3,4,5);
scala> k++:ff
res50: Seq[Int] = List(1, 2, 3, 2, 3, 4, 5)
//或者
scala> ff++:k
res51: Array[Int] = Array(2, 3, 4, 5, 1, 2, 3)

3. :+ 、 +：

使用范式：def +:(elem: A): Array[A]
作用: 头部追加，尾部追加
说明：加号旁边跟要追加的值，一次一个

val k = Array(1.24,2.24,"a");
scala> k:+"a"
res58: Array[Any] = Array(1.24, 2.24, a, a)

scala> 24+:k
res59: Array[Any] = Array(24, 1.24, 2.24, a)

4. /:从左到右计算 :\从右到左计算

使用范式：def /:[B](z: B)(op: (B, T) ⇒ B): B
使用说明：对数组中所有的元素进行相同的操作 ，foldLeft的简写
说明：/:左数相加 :y+左边的数值
:\右数相加：y+ 右边的数值

val y = Array(1,2,3)
(88 /: y)(_+_)
res60: Int = 94
//或者
(y :\ 88)(_+_)
res60: Int = 94

5. addString：在字符串基础上面追加字符串,类似mkString

使用范式：

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

使用说明：在字符串基础上面追加字符串(需要StringBuilder)，返回StringBuiler

var k = Array(1,2,3,"a")
var g = new StringBuilder(); //创建字符串空间
k.addString(g); //将k数组元素以""连接成字符串,
g
res71: StringBuilder = 123a

k.addString(g,",")//将数组中的元素以逗号分隔连成字符串，追加到g中
g
res202: StringBuilder = 123a1,2,3,a

k.addString(g,"1","&","2") //以1开头，&分割，2结尾,连成字符串,追加到g中
g
res204: StringBuilder = 123a1,2,3,a11&2&3&a2

k.addString(new StringBuilder(),"a",",","b")
res206: StringBuilder = a1,2,3,ab

6. aggregate：偏函数方法

使用范式：aggregate[B](z: => B)(seqop:(B,T)=>B,combop(B,B)=>B):B
使用说明：聚合计算，aggregate是柯里化方法，参数是两个方法，为了方便理解，我们把aggregate的两个参数，分别封装成两个方法，并把计算过程打印出来。

val a = List(1,2,3,4)
def ab(m:Int,n:Int): Int={
println(s"ab:sum=${m}+${n}")
m+n
}
def cd(m:Int,n:Int): Int={
println(s"cd:sum=${m}+${n}")
m+n
}
val c = a.par.aggregate(5)(ab,cd)
//结果：
scala> val c = a.par.aggregate(5)(ab,cd)
ab:sum=5+1
ab:sum=5+4
ab:sum=5+2
ab:sum=5+3
cd:sum=6+7
cd:sum=8+9
cd:sum=13+17
c: Int = 30

7. andThen:返回针对序列的偏函数

使用范式： def andThen[C](k: Any => C): PartialFunction[Int,C]
使用说明：根据k方法生成偏函数，Int为索引，C为k方法执行的结果类型

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

scala> res209(4)
res217: Boolean = true

scala> a.andThen(x=>x*2)
res218: PartialFunction[Int,Int] = <function1>

scala> res218(2)
res219: Int = 6

8. apply：返回对应下标元素

使用范式：def apply(i: Int): Any
使用说明：返回序列对应下标元素,其意义是在于构造scala语句糖

var k = Array(1, 2, 3, a)
k.apply(3) //拿出集合k下标为3的元素
res81: Any = a

9.applyOrElse(index,func)

使用范式：def applyOrElse[A1 <: Int, B1 >: Int](x: A1,default: A1 => B1): B1
使用说明：有则输出该数组该下标的元素，无此下标则输出函数func结果

val a = List(1, 2, 3, 4, 5)
 a.applyOrElse(5,{num:Int=> "sss" })
res67: Any = sss

a.applyOrElse(1,{num:Int=> "sss" })
res67: Any = 2

10. canEqual： 判断两个对象是否可以比较

使用范式：def canEqual(that:Any):Boolean
使用说明：判断两个对象是否可以比较

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

11. charAt

使用范式：def chatAt(index:Int):Char
使用说明：char数组专属方法，从数组中取出下标为index的字符
注：字符数组切片：subsequence(from:Int,end:int):Array[Char]

val a = Array('a','v','d')
a.charAt(2)
res379: Char = d

12.clone:浅拷贝

使用范式：def clone(): Array[Any]
使用说明：返回当前序列的浅拷贝，如果拷贝对象是多维数组，只能影响到外面一层（最外层深拷贝）

var j = k.clone()

注：深拷贝，即完全克隆，创新创建对象并且引用
浅拷贝的意义正好以深拷贝相反，他和被拷贝者共用一个对象，指向同一个内存地址

13. collect

使用范式：collect[B](pf:PartialFunction[A,B]):Array[B]
使用说明：通过执行一个并行计算（偏函数：PartialFunction）得到一个新的数组对象

var a = Array(1,2,3,4)
val func:PartialFunction[Int,Int] = {
case x if x%2==1 => x+2
case x => x+1
}
func: PartialFunction[Int,Int] = <function1>

a.collect(func)
res115: Array[Int] = Array(3, 3, 5, 5)

14. collectFirst

使用范式：collectFirst[B](pf:PartialFunction[A,B]):Option[B]
使用说明：在序列中查找第一个符合表达式的值，并且处理返回一个Option对象

val func:PartialFunction[Int,Int] = {
case x if x%2==0 => x*2
}
a.collectFirst(func)
res116: Option[Int] = Some(4)

//针对Some类型属猪，有个方法get可将值取出
a.collectFirst(func).get
res117: Int = 4

15. combinations

使用范式：combinations(n:Int):collection.Iterator[Array[T]]
使用说明：根据集合a元素组合（无重复），返回长度位n的集合的迭代器，和排列permutations联合记忆

a.combinations(2)
res118: Iterator[Array[Int]] = non-empty iterator

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

16. contains

使用范式： def contains[A1 >: Any](elem: A1): Boolean
使用说明：确认某字符串或数组中,是否含有被传参数，若有返回Boolean值true，无则返回false

scala> a
res113: List[Int] = List(1, 2, 3, 4)
scala> a.contains(1)
res115: Boolean = true
 a.contains("a")
res116: Boolean = false

17. containsSlice

使用范式：def containsSlice[B](that: scala.collection.GenSeq[B]): Boolean
使用说明：判断当前序列中是否包含另一序列
注：数组元素顺序得一致，被包含者一定在括号内

val b = Array(1,2,3,Array(4,5,6))
val c = Array(4,5,6)
b.containsSlice(c)
res120: Boolean = false

//次序不能乱
val a = List(1,2,3)
val b = List(2,3)
a.containsSlice(b)
res122: Boolean = true

b.containsSlice(a)
res123: Boolean = false

val b = List(3,2)
a.containsSlice(b)
res124: Boolean = false

18. copyToArray

使用范式：

def copyToArray[U >: Any](xs: Array[U],start: Int,len: Int): Unit
def copyToArray[B >: Any](xs: Array[B]): Unit
def copyToArray[B >: Any](xs: Array[B],start: Int): Unit

使用说明：将列表元素从下标0开始，复制至另一列表，可以指定目标数组开始和复制长度len,无返回值
注：若是给定长度超出数组界限，则默认最后一位

val a = List(1,2,3,4);
val b = List(2,3);
val c = new Array[Int](5)
a.copyToArray(c)
c
res81: Array[Int] = Array(1, 2, 3, 4, 0)
//指定位置
a.copyToArray(c,1)
scala> c
res83: Array[Int] = Array(1, 1, 2, 3, 4)
//指定结束和复制长度
a.copyToArray(c,1,2)
c
res85: Array[Int] = Array(0, 1, 2, 0, 0)

19.copyToBuffer

使用范式：copyToBuffer[B>:A](dest:Buffer[B]):Unit
使用说明：将数组的内容拷贝到目标缓存dest中,无返回值

import scala.collection.mutable.ArrayBuffer
val a = Array('a','b','c')
var b :ArrayBuffer[Char] = ArrayBuffer()
a.copyToBuffer(b)
println(b.mkString(","))
a,b,c

20. corresponds

使用范式：def corresponds[B](that:GenSeq[B])(p: (Int, B) => Boolean): Boolean
使用说明：判断两个序列长度以及对应位置元素是否符合某个条件,联合sameElements记忆

val a = List(1,2,3,4)
val b = List(2,3)
a.corresponds(b)(_<_)
res87: Boolean = false

val c = Array(1,2,3,4)
a.corresponds(c)(_==_)
res89: Boolean = true

21. count

使用范式：def count(p: Char => Boolean): Int
使用说明：统计符合表达式的元素的个数

val a = List(1,2,3,4);
a.count(x=>x%2==0)
res98: Int = 2

//统计a的个数在列表中
val e = Array("hesdf","word","sdf")
e.count(x=>x.contains("o"))
res19: Int = 1

e.count(x=>x.indexOf("o") > 0)
res23: Int = 1

22. diff：求差集

使用范式：def diff(that:collection.Seq[T]):Array[T]
使用说明：计算当前数组和另一个数组的不同。将当前数组没有在另一数组出现的元素返回

a
res117: List[Int] = List(1, 2, 3, 4)
val d = List(1,2,3)
a.diff(d)
res121: List[Int] = List(4)

23. distinct：集合去重

使用范式： def distinct: List[Int]
使用说明：集合去重

val a = List(1,1,2,3)
a.distinct
res122: List[Int] = List(1, 2, 3)

24. drop：删除集合前n个元素

使用范式：override def drop(n: Int): List[Int]
使用说明：删除集合前n个元素

val a = List(1,2,3)
 a.drop(1)
res399: List[Int] = List(2, 3)

25. dropRight:删除尾部n个元素

使用范式：override def dropRight(n: Int): List[Int]
使用说明：删除序列尾部n个元素

val a = List(1,2,3)
 a.dropRight(1)
res123: List[Int] = List(1, 2)

26. dropWhile

使用范式：def dropWhile(p: Int => Boolean): List[Any]
使用说明：删除满足表达式的连续元素
注：只要碰到条件不满足的，直接停止操作

a.dropWhile(x=>x<3)
res128: List[Int] = List(3)

val b = a++Array(3,1,1)
b.dropWhile(x=>x<3)
res132: List[Int] = List(3, 3, 1, 1)

27. endsWith

使用范式：def endsWith[B](that: scala.collection.GenSeq[B]): Boolean
使用说明：判断序列是否以给定序列that结尾

val a = Array(1,2,3)
a.endsWith(Array(4))
res401: Boolean = false

scala> a.endsWith(Array(3))
res402: Boolean = true

scala> a.endsWith(Array(2,3))
res403: Boolean = true

28. startswith

使用范式：startsWith[B](that: scala.collection.GenSeq[B],offset: Int): Boolean
使用说明：判断从指定位置offset开始的序列是否以给定序列that开头
注：可以不指定开始位置，默认开始索引为0

val a = Array(1,2,3)
a.startsWith(Array(2),1)
res404: Boolean = true

29. exists

使用范式：def exists(p: Int => Boolean): Boolean
使用说明：判断当前数组是否包含符合条件的元素
注：和find,maxBy,minBy,filter,filterNot,takeWhile一起记忆

a.exists(_>2)
res405: Boolean = true

30. filter

注：过滤出满足条件的集合元素，以此返回一个集合
与之相反的方法：filterNot

val a = List(1,2,3)
a.filter(_>2)
res133: List[Int] = List(3)

31. find

使用范式：def find(p: Int => Boolean): Option[Int]
使用说明：查找集合中第一个符合条件的元素,返回该元素，同maxBy

val a = List(1,2,3)
a.find(_>2)
res134: Option[Int] = Some(3)

32. flatten

使用范式： def flatten[B](implicit asTraversable: java.io.Serializable => GenTraversableOnce[B]): List[B]
使用说明：数组降一维
注：二维数组中的数组类型得一致

val aa = List(List(1),List(2))
aa.flatten
res138: List[Int] = List(1, 2)

33. flatMap

使用范式：flatMap[B](f:(A)=>GenTraversableOnce[B]):Array[B]
使用说明：对当前序列的每个元素进行操作，结果放进新序列返回,相对于map是映射降一维

val a = List(1,2,3,4)
val b = a.flatMap(x=>1 to x)
b: List[Int] = List(1, 1, 2, 1, 2, 3, 1, 2, 3, 4)
//map得到是二维数组
a.map(x=>1 to x)
res139: List[scala.collection.immutable.Range.Inclusive] = List(Range(1), Range(1, 2), Range(1, 2, 3), Range(1, 2, 3, 4))

34. fold （foldLeft）相当于 /:

使用范式：def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1
使用说明：对序列中的每个元素进行二元运算，和aggregate有类似的语义，但执行过程有所不同

  def seqno(m:Int,n:Int): Int ={
    val s = "seq_exp=%d+%d"
    println(s.format(m,n))
    return m+n
  }
    val a = Array(1, 2, 3,4)
    val b = a.foldLeft(5)(seqno)
    /** 运算过程
    seq_exp=5+1
    seq_exp=6+2
    seq_exp=8+3
    seq_exp=11+4
    */

35. foldRight 相当于 :\

使用范式：def foldRight[B](z: B)(op: (B, T) ⇒ B): B
使用说明：从右到左计算，简写方式：def :[B](z: B)(op: (T, B) ⇒ B): B

  def seqno(m:Int,n:Int): Int ={
    val s = "seq_exp=%d+%d"
    println(s.format(m,n))
    return m+n
  }
    val a = Array(1, 2, 3,4)
    val b = a.foldRight(5)(seqno)
    /** 运算过程
    seq_exp=4+5
    seq_exp=3+9
    seq_exp=2+12
    seq_exp=1+14
    */

36. forall：检测序列中的元素是否都满足条件p,返回布尔值

使用范式：def forall(p: Any=> Boolean): Boolean
使用说明：检测序列中的元素是否都满足条件p,返回布尔值

val a = List(1,2,3,4,5)
a.forall(x=>x>3)
res47: Boolean = false

a.forall(x=>x<10)
res49: Boolean = true

a.forall(_<10)
res50: Boolean = true

37.foreach

使用范式：def foreach[U](f: Any => U): Unit
使用说明：迭代集合,无返回值

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

38. groupBy:按条件分组

使用范式：def groupBy[K](f: Int => K): scala.collection.immutable.Map[K,Array[Int]]
使用说明：按照条件分组,返回一个不可更改的Map，一般与match连用

val a = List(1,2,3,4)
a.groupBy(x=> x match{
case x if(x<3) => "a"
case _ => "b"
})
res91: scala.collection.immutable.Map[String,List[Int]] = Map(b -> List(3, 4), a -> List(1, 2))

39. grouped:按指定数量分组

使用范式：def grouped(size: Int): Iterator[List[Int]]
使用说明：按照指定数量分组，返回一个可迭代类型的二维数组
注：联合partition、span、splitAt记忆

val a = List(1, 2, 3, 4)
scala> a.grouped(2)
res99: Iterator[List[Int]] = non-empty iterator
scala> res99.toArray
res100: Array[List[Int]] = Array(List(1, 2), List(3, 4))

40. hasDefiniteSize

使用范式：def hasDefiniteSize: Boolean
使用说明：检查序列是否存在有限的长度，有限长度则返回true

val a = Array(1,2,3,4,5,6)
a.hasDefiniteSize
res104: Boolean = true

41. head 返回头元素

使用范式：def head: Any
使用说明：返回集合头元素[Any],集合不能为空

val a = List(1,2,3,4)
a.head

val a = List(Array(1),"",1)
a.head
res105: Any = Array(1)

val a = List(Array(),"",1)
res106: Any = Array()
//集合不能为空
val a = Array()
a.head
<console>:13: error: value headOption is not a member of Array[Nothing]

42. headOption:返回头部对象（类型Option）

使用范式: def headOption: Option[Any]
使用说明：返回头部对象（类型Option集合）
注:集合为空则返回None

val a = List("a","b","c")
a.headOption
res109: Option[String] = Some(a)

val a:Array[Int] = Array()
a.headOption
res7: Option[Int] = None

43. indexOf:对应元素的所在集合下标

使用范式：

def indexOf[B >: String]\(elem: B,from: Int): Int    //	可从位置from向后检索，返回第一个符合条件的Int类型下标,未检索到返回-1
def indexOf[B >: String]\(elem: B): Int		//	默认从头检索，返回Int类型下标，未检索到返回-1

使用说明：返回对应元素的所在集合下标
注:只返回第一个对应的元素下标，其他的不返回

//指定位置开始检索
val a = Array(1,2,3,5,4,5,6)
//未检索到
a.indexOf(2,5)
res115: Int = -1
//检索到
a.indexOf(3,1)
res117: Int = 2
a.indexOf(5)
res118: Int = 3

44. indexOfSlice

使用范式：

def indexOfSlice[B >: Int]\(that: scala.collection.GenSeq[B],from: Int): Int   //从from开始检索
def indexOfSlice[B >: Int]\(that: scala.collection.GenSeq[B]): Int

使用说明：检查当前集合是否包含另一个集合(that)，并返回第一个匹配出现的元素的索引

val a = Array(1,2,3,5,4,5,6)
a.indexOfSlice(Array(1,2,3))
res123: Int = 0

45. indexWhere

使用范式：

def indexWhere(p: Int => Boolean,from: Int): Int
def indexWhere(p: Int => Boolean): Int

使用说明：返回当前集合中第一个满足p条件的下标，可指定开始位置from

val a = Array(1,2,3,5,6,7,8)
a.indexWhere(_>3,2)
res124: Int = 3

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

使用范式： def indices: scala.collection.immutable.Range
使用说明：返回当前序列索引集合（Range）

val a = Array(1,"",3,5,6,7,8)
a.indices
res126: scala.collection.immutable.Range = Range(0, 1, 2, 3, 4, 5, 6)

47. init : 返回一个不包含当前序列（that）中最后元素的序列

使用范式：def init: Array[Any]
使用说明:返回一个不包含当前序列（that）中最后元素的序列，序列属性由当前序列决定

val a = Array(1,"",3,5,6,7,8)
a.init
res127: Array[Any] = Array(1, "", 3, 5, 6, 7)

48. inits

使用范式：def inits: Iterator[Array[Any]]
使用说明：将当前序列进每次init操作的结果都进行init操作，直到结果为空，则顺序返回序列的迭代器

val a = Array("abc",'b','c','d')
a.inits.foreach(x=>println(x.mkString(",")))
abc,b,c,d
abc,b,c
abc,b
abc

49. intersect ： 取两个集合的交集

使用范式：def intersect[B >: Any](that: scala.collection.GenSeq[B]): Array[Any]
使用说明：返回当前集合的与集合B的交集，返回类型取决于当前序列

val a = Array(1,2,3,4,5,6)
val b = List(4,5)
a.intersect(b)
res147: Array[Int] = Array(4, 5)

scala> b.intersect(a)
res148: List[Int] = List(4, 5)

50. isDefinedAt : 判断序列中是否存在指定索引

使用范式：def isDefinedAt(idx: Int): Boolean
使用说明：判断序列中是否存在指定索引idx，返回boolean值

val a = Array(1,2,3,4,5,6)
a.isDefinedAt(2)
res134: Boolean = true
a.isDefinedAt(8)
res135: Boolean = false

51. isEmpty:判断集合是否为空

使用范式：def isEmpty: Boolean
使用说明：判断集合是否为空，返回Boolean值

val a = Array(1,2,3,4,5,6)
a.isEmpty
res136: Boolean = false

52. isTraversableAgain:判断是否非迭代器

使用范式：final def isTraversableAgain: Boolean
使用说明: 判断集合是否非迭代器，返回false则为迭代器

val a = Array(1,2,3,4,5,6)
a.isTraversableAgain
res138: Boolean = true

a.inits.isTraversableAgain
res139: Boolean = false

53.iterator:生成序列的迭代器

使用范式：def iterator: Iterator[Any]
使用说明：生成序列的迭代器,返回可迭代对象

val a = Array(1,2,3,4,5,6)
a.iterator
res140: Iterator[Int] = non-empty iterator
 a.iterator.foreach(println(_))
1
2
3
4
5
6

54. last :取序列中最后一个元素.

使用范式：def last: Any
使用说明：返回序列中的最后一个元素

val a = Array("1",1,2,3,4)
a.last
res142: Any = 4

55. lastIndexOf

使用范式：
def lastIndexOf[B >: Any](elem: B): Int
def lastIndexOf[B >: Any](elem: B,end: Int): Int
使用说明: 返回序列中最后一个等于elem的元素的索引，可以指定结束下标end

val a = Array(1,2,3,4,5,5)
a.lastIndexOf(5,5)
res143: Int = 5

- lastIndexOfSlice

使用范式：lastIndexOfSlice[B >: Any](that: scala.collection.GenSeq[B],end: Int): Int
使用说明：判断当前序列是否存在指定序列，返回该序列最后一次出现的位置的首元素下标，可以指定最后检索的位置，如不指定end，则默认为最后一位

val a = Array(1,2,3,4,1,2)
val b = Array(1,2)
a.lastIndexOfSlice(b)
res0: Int = 4

56. lastOption: 返回集合中最后一个元素对象

使用范式： def lastOption: Option[Any]
使用说明： 返回集合中最后一个元素对象(some)

val a  = Array("c",1,2,3)
a.lastOption
res145: Option[Any] = Some(3)

57. length：返回当前序列的元素个数

使用范式：def length:Int
使用说明： 返回当前序列的元素个数

val a = a.length
a.length
res153: Int = 3

58.lengthCompare:比较序列的长度和参数len

使用范式：def lengthCompare(len: Int): Int
使用说明： 比较序列的长度和参数len，根据两者的关系返回不同的值2
规则：

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

val a = Array(1,2,3,4)
a.lengthCompare(3)
res154: Int = 0

a.lengthCompare(6)
res156: Int = -1

a.lengthCompare(1)
res157: Int = 1

-lift 返回该下标的元素的Option的对象

使用范式：-def lift: Int => Option[Int]
使用说明： 返回该下标的元素的Option的对象

val a = Array(1,2,3,4,5)
a.lift(2)
res39: Option[Int] = Some(3)

59. map

使用范式：def map[B](f: Any=> B): scala.collection.TraversableOnce[B]
使用说明： 对集合中的元素进行f操作，返回一个与原序列相同类型的序列

val a = Array(1,2,3)
a.map(_*2)
res158: List[Int] = List(2, 4, 6)

60. max: 返回序列中最大元素

使用范式： def max[B >: Any](implicit cmp: Ordering[B]): Any
使用说明： 返回序列中最大元素，返回类型由元素本身决定

val a = Array(1,2,3)
 a.max
res159: Int = 3

61. maxBy: 返回序列中第一个符合条件的元素（类似find）

使用范式：def maxBy[B](f: AnyVal => B): AnyVal
使用说明： 返回序列中第一个符合条件的元素（类似find）
注：数组中元素类型最好一致，不然受限于类型，不能直接做大小比较，如没有满足条件的元素，则返回第一个元素

val a = Array(1,2,3,4,5,6)
a.maxBy(_>4)
res161: Int = 5
 a.maxBy(_>10)
res174: Int = 1		//不满足返回第一个元素
val b = Array("a","c",1,2)
b: Array[Any] = Array(a, c, 1, 2)

scala> b.maxBy(_>4)
<console>:17: error: value > is not a member of Any
       b.maxBy(_>4)
 
b.maxBy(_==2)
res171: Any = 2

scala> b.maxBy(_==5)
res172: Any = a

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

使用范式：def minBy[B](f: Any => B)(implicit cmp: Ordering[B]): Any
使用说明： 返回序列中第一个不符合条件的元素,若都符合则返回第一个元素

val a = Array(1,2,3,4,5,6)
val b = Array("a","c",1,2)
a.minBy(_<3)
res175: Int = 3
a.minBy(_>3)
res176: Int = 1
a.minBy(_<10)
res178: Int = 1  

b.minBy(_<1)
<console>:17: error: value < is not a member of Any
       b.minBy(_<1)

63. mkString:将序列元素组合成字符串

使用范式：def mkString(start: String,sep: String,end: String): String
使用说明： 将所有元素组合成一个字符串，以 start 开头，以 sep 作为元素间的分隔符，以 end 结尾

val a = Array("Hello","Scala")
a.mkString("输出",",","!")
res180: String = 输出Hello,Scala!

64. nonEmpty:判断序列是否不为空

使用范式：def nonEmpty:Boolean
使用说明：判断序列是否不为空,返回布尔值

val a = Array(1,2,3)
a.nonEmpty
res182: Boolean = true

65. padTo:追加补齐序列

使用范式：def padTo(len: Int, elem: Any): Array[Any]
使用说明： 在序列尾部追加len-this.length个elem

 b
res186: Array[Any] = Array(a, c, 1, 2)

scala> b.padTo(10,"111")
res187: Array[Any] = Array(a, c, 1, 2, 111, 111, 111, 111, 111, 111)

66. par :返回一个并行实现，产生的并行序列

使用范式：def par:ParArray[T]
使用说明： 返回一个并行实现，产生的并行序列，不能被修改,顺序不定

val a = Array(1,2,3,4,5)
a.par.foreach(println(_))
5
4
1
2
3

67. partition:拆分序列

使用范式：def partition(p:Any => Boolean): (Array(Any),Array(Any))
使用说明： 按条件p拆分序列，将满足条件的元素放入一个数组，不满足放入另一个，将这两个序列放进元组，返回此元组

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

68. patch: 批量替换元素

使用范式：def patch(from: Int, that: GenSeq[A], replaced: Int): Array[A]
使用说明： 将当前序列中从from开始的replaced个元素替换成给定的序列GenSeq中元素,返回替换后的序列

val a = Array(1,2,3)
a.patch(1,Array(1,2,3),2)
res225: Array[Int] = Array(1, 1, 2, 3)

a.patch(1,Array(1),2)
res226: Array[Int] = Array(1, 1)

a.patch(1,Array(1,2),2)

69. permutations ：排列

使用范式：def permutations: Iterator[Array[Any]]
使用说明： 将当前序列的所有的排列可能结果组成作为一个迭代器（二维）返回

val a = Array(1,2,3)
a.permutations.toList
res229: 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))

70. prefixLength: 返回满足给定条件元素个数

使用范式：def prefixLength(p: Int => Boolean): Int
使用说明：从头开始计数满足条件p的元素，碰到第一个不满足的则停止计数，返回计数值（Int）

val a = Array(11,2,31)
a.prefixLength(_>2)
res239: Int = 1

71. product：元素乘积

使用范式：def product[B >: Int](implicit num: Numeric[B]): B
使用说明：元素乘积,返回对应数值类型B

val a = Array(2,3,4)
a.product
res242: Int = 24

72. reduce

使用范式：def reduce[A1 >: Int](op: (A1, A1) => A1): A1
使用说明：聚合计算，同fold,无需初始值,返回计算结果

val a = Array(2,3,4)
a.reduce(_+_)

73. reduceLeft

使用范式：def reduceLeft[B >: Int](op: (B, Int) => B): B
使用说明： 聚合计算（从左到右），同reduce、fold

a.reduceLeft(_+_)
res250: Int = 9

74. reduceRight

使用范式：def reduceRight[B >: Int](op: (Int, B) => B): B
使用说明： 聚合计算（从右到左），同foldRight

a.reduceRight(_+_)
res250: Int = 9

75. reduceLeftOption

使用范式：def reduceLeftOption[B >: Int](op: (B, Int) => B): Option[B]
使用说明：聚合计算（从左到右），同reduce\reduceLeft\fold,唯一区别是允许当前序列为空,返回类型是Option

a.reduceLeftOption(_+_)
res253: Option[Int] = Some(9)

76. reduceRightOption

使用范式：def reduceRightOption[B >: Int](op: (B, Int) => B): Option[B]
使用说明： 聚合计算（从右到左），同reduceRight\foldRight,唯一区别是允许当前序列为空,返回类型是Option

a.reduceRightOption(_+_)
res254: Option[Int] = Some(9)

77. reverse: 反转序列

使用范式：def reverse: Array[T]
使用说明： 反转序列

val a = Array("b","a","c")
a.reverse
res257: Array[String] = Array(c, a, b)

78. reverseIterator: 根据当前序列反向生成迭代器

使用范式： def reverseIterator: Iterator[String]
使用说明： 根据当前序列反向生成迭代器

val a = Array(1,2,3)
a.reverseIterator.toList
res259: List[Int] = List(3, 2, 1)

79. reverseMap: 同map作用，方向与map相反

使用范式：reverseMap[B](f:(A)=>B):Array[B]
使用说明：同map作用，返回序列的方向与map相反

val a = Array(1,2,3)
a.reverseMap(_*2)
res261: Array[Int] = Array(6, 4, 2)

a.map(_*2)
res262: Array[Int] = Array(2, 4, 6)

- runWith:执行偏函数pf带上后面的函数执行，当参数不在定义域内时，返回false，否则返回true，并执行action

使用范式：def runWith[U](action: Int => U): Int => Boolean
使用说明：执行偏函数，当参数不在定义域内时，返回false，否则返回true，并执行action

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

pf.runWith(println)(2)
res38: Boolean = false

80. sameElements: 判断两个序列中元素排列和值是否一致

使用范式：def sameElements[B >: Any](that:GenIterable[B]): Boolean
使用说明：判断两个序列中元素排列和值是否一致，可以实现类似功能的有corresponds（根据条件比较数组）

val a = Array(1,2,3)
val b = a:+"a"
val c = Array(1,2,3)
a.sameElements(b)
res264: Boolean = false

scala> a.sameElements(c)
res265: Boolean = true

81. scan / scanLeft :类似fold 也有：scanRight

使用范式：scan[B >: Int, That](z: B)(op: (B, B) => B)(implicit cbf: WrappedArray[T],B,That]): That
使用说明：功能类似于fold，不过此方法将每一个的返回结果放到一个新的集合中返回，而fold值返回最终结果

val a = Array(1,2,3)
a.scan(5)(_+_)
res270: Array[Int] = Array(5, 6, 8, 11)

82. segmentLength: 返回满足条件的连续元素个数

使用范式：def segmentLength(p: Int => Boolean,from: Int): Int
使用说明： 同prefixLength,不同的是可以指定开始下标

val a = Array(11,2,31)
a.segmentLength(_>2)
res239: Int = 1

val a = Array(11,2,31,3)
a.segmentLength(_>2,2)
res276: Int = 2

83. seq :产生当前序列的seq视图

使用范式：def seq: mutable.IndexedSeq[T]
使用说明： 产生一个引用当前序列的 sequential 视图

val a = Array(1,2,3)
a.seq
res292: scala.collection.mutable.IndexedSeq[Int] = WrappedArray(1, 2, 3)

84. size: 同length

使用范式：def size:Int
使用说明：作用等同于length

val a = Array(1,2,3)
a.size
res278: Int = 3

85. slice: 数组切片

使用范式：def slice(from: Int,until: Int): Array[Any]
使用说明：数组切片：从from到util(前包含，后不包含),类似的功能方法有：init(返回去除最后一个元素的序列)

val a = Array(1,2,3)
a.padTo(4,"a").slice(1,3)
res284: Array[Any] = Array(2, 3)

a.padTo(4,"a").slice(1,5)
res287: Array[Any] = Array(2, 3, a)

86. sliding: 滑动切分

使用范式：

def sliding(size: Any,step: Any): Iterator[Array[Any]]    //可设置步长
def sliding(size: Any): Iterator[Array[Any]]		

使用说明： 按照步长（不写默认1）滑动切分数组(数组中size个元素)，返回一个数组的可迭代集合

val a = Array(1,2,3,4,5)
a.sliding(3).toList
res93: List[Array[Int]] = List(Array(1, 2, 3), Array(2, 3, 4), Array(3, 4, 5))

#设置步长2
a.sliding(3,2).toList
res94: List[Array[Int]] = List(Array(1, 2, 3), Array(3, 4, 5))

a.sliding(3,3).toList
res291: List[Array[Int]] = List(Array(1, 2, 3), Array(4, 5))

87. sorted:按照默认顺序排序

使用范式：def sorted[B >: Int](implicit ord: scala.math.Ordering[B]): Array[Int]
使用说明： 默认顺序排序

val a = Array(2,4,67,7,2,6,7,8)
a.sorted
res305: Array[Int] = Array(2, 2, 4, 6, 7, 7, 8, 67)

88. sortBy: 排序

使用范式：def sortBy[B](f: Int => B)(implicit ord: scala.math.Ordering[B]): Array[Int]
使用说明： 返回按照给定好的条件排序的序列

val a = Array(2,4,67,7,2,6,7,8)
a.sortBy(x=>x)
res97: Array[Int] = Array(2, 2, 4, 6, 7, 7, 8, 67)

a.sortBy(x => -x)
res98: Array[Int] = Array(67, 8, 7, 7, 6, 4, 2, 2)

#练习，排序
val ff = Array(("aa",90),("bb",50),("cc",70))
ff.sortBy(_._2)
res104: Array[(String, Int)] = Array((bb,50), (cc,70), (aa,90))

89. sortWith:

使用范式： def sortWith(lt: (Int, Int) => Boolean): Array[Int]
使用说明： 按照自定义排序方法It排序

val a = Array(2,4,67,7,2,6,7,8)
a.sortWith(_.compareTo(_)>1)
res100: Array[Int] = Array(2, 2, 4, 6, 7, 7, 8, 67)

a.sortWith(_.compareTo(_)>0)
res101: Array[Int] = Array(67, 8, 7, 7, 6, 4, 2, 2)

90.span: 类似于partition

使用范式：def span(p: Any => Boolean): (Array[Any], Array[Any])
使用说明：找到第一个满足条件元素，开始分割序列为两个集合,碰到第一个不满足则停止分区，返回一个元组,该元组第一个元素为符合条件的序列，第二个为不符合的序列

val a = Array(10,2,3,1,5)
//span分组,可能分组不完全
a.span(_>2)
res306: (Array[Int], Array[Int]) = (Array(10),Array(2, 3, 1, 5)
n
//partition分组，完全分组
a.partition(_>2)
res307: (Array[Int], Array[Int]) = (Array(10, 3, 5),Array(2, 1))

91. splitAt:序列根据个数n拆分

使用范式：def splitAt(n: Int): (Array[Any], Array[Any])
使用说明：返回元组，第一个是包含当前序列前n个元素的序列，第二个是其余元素的序列

val a = Array(10,6,3,1,5)
a.splitAt(2)
res316: (Array[Int], Array[Int]) = (Array(10, 6),Array(3, 1, 5))

92. stringPrefix: 返回toString结果内存地址的前缀

使用范式：def stringPrefix: String
使用说明：

val a = Array(0,1,2,3,4,5)
println(a.toString())       //[I@3daa57fb
val b = a.stringPrefix
println(b)      //[I

93. subSequence: 字符数组专用方法，返回给定下标之间的字符

使用范式：def subSequence(start: Int,end: Int): CharSequence
使用说明： 字符数组专用方法，返回给定下标之间的字符,前包含，后不包含

val chars = Array('a','b','c','d')
chars.subSequence(1,3)
res318: CharSequence = bc

94. sum : 序列元素求和

使用范式：def sum[B >: Int]: B
使用说明：序列元素求和

val a = Array(1,2,3)
a.sum
res319: Int = 6

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

使用范式：def tail: Array[Any]
使用说明：返回除了当前序列第一个元素的其他元素组成的序列，可联合init记忆

val a = Array(1,2,3)
a.tail
res320: Array[Int] = Array(2, 3)

96. tails

使用范式：def tails: Iterator[Array[Int]]
使用说明：对当前序列进行反复的tail操作，直到tail返回的结果为空，联合inits记忆

val a = Array(1,2,3)
a.tails
res321: Iterator[Array[Int]] = non-empty iterator

scala> a.tails.toList
res322: List[Array[Int]] = List(Array(1, 2, 3), Array(2, 3), Array(3), Array())

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

使用范式： def take(n: Int): Array[Any]
使用说明： 返回当前序列中前n个元素组成的序列

val a = Array(1,2,3)
a.take(2)
res329: Array[Int] = Array(1, 2)

98. takeRight: 从尾元素开始，返回n个元素的序列

使用范式： def takeRight(n: Int): Array[Any]
使用说明： 从尾元素开始，返回n个元素的序列

val a = Array(1,2,3)
a.takeRight(2)
res331: Array[Int] = Array(2, 3)
#取中间的值
val a: Array[Int] = Array(2, 4, 67, 7, 2, 6, 7, 8)
a.takeRight(a.length-1)
res116: Array[Int] = Array(4, 67, 7, 2, 6, 7, 8)
                                       a.length-2
scala> a.takeRight(a.length-1).take(res116.length-1)
res117: Array[Int] = Array(4, 67, 7, 2, 6, 7)

99. takeWhile:返回序列中满足条件的连续元素的序列

使用范式：def takeWhile(p: Int => Boolean): Array[Any]
使用说明：从第一个元素开始,返回序列中满足条件的连续元素的序列,可联系find、maxBy、minBy记忆，这三者都是返回元素

val a = Array(3,2,3)
a.takeWhile(_>2)
a.takeWhile(_>2)
res333: Array[Int] = Array(3)

100. toArray: 装换为Array类型

使用范式：def toArray: Array[A]
使用说明：返回当前序列转换为Array类型

val a = List(1,2)
a.toArray
res334: Array[Int] = Array(1, 2)

101. toBuffer:转换为Buffer类型

使用范式：def toBuffer[A1 >: A]: Buffer[A1]
使用说明：返回当前序列转换为Buffer类型

val a = List(1,2)
a.toBuffer
res335: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2)

102. toIndexedSeq:转换成immutable.IndexedSeq对象

使用范式：def toIndexedSeq: collection.immutable.IndexedSeq[T]
使用说明： 转换成immutable.IndexedSeq对象

val a = List(1,2)
a.toIndexedSeq
res336: scala.collection.immutable.IndexedSeq[Int] = Vector(1, 2)

103. toIterable：转换成可迭代类型

使用范式：def toIterable: collection.Iterable[T]
使用说明：转换成可迭代类型

val a = List(1,2)
a.toIterable
res337: Iterable[Int] = List(1, 2)

104. toIterator:同iterator方法

使用范式：def toIterator: collection. Iterator[T]
使用说明： 转换成iterator类型

val a = List(1,2)
a.toIterator
res338: Iterator[Int] = non-empty iterator

105. toList： 将当前序列转换成List类型序列，并返回

使用范式：def toList:List[Any]
使用说明： 将当前序列转换成List类型序列，并返回

val a = Array(1,2,3)
a.toList
res231: List[Int] = List(1, 2, 3)

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

使用范式：def toMap[T, U]: immutable.Map[T, U]
使用说明：同Map 类型，需要被转化序列中包含的元素时 Tuple2 类型数据

val chars = Array(("a","b"),("c","d"),("e","f"))
chars.toMap
res340: scala.collection.immutable.Map[String,String] = Map(a -> b, c -> d, e -> f)

107. toSeq

使用范式: def toSeq: scala.collection.immutable.Seq[Any]
使用说明：转换成Seq类型

val a = Array(1,2)
a.toSeq
res341: scala.collection.immutable.Seq[Int] = List(1, 2)

108. toSet

使用范式：def toSet[B >: Int]: scala.collection.immutable.Set[B]
使用说明：转换成Set类型

val a = Array(1,2)
a.toSet
res342: scala.collection.immutable.Set[Int] = Set(1, 2)

109. toStream

使用范式：def toStream: collection.immutable.Stream[T]
使用说明： 同Stream（流）类型

a.toStream
res343: scala.collection.immutable.Stream[Int] = Stream(1, ?)

110. toVector: 转化为向量集

使用范式：def toVector: Vector[T]
使用说明： 转化为向量集Vector 类型

a.toVector
res344: Vector[Int] = Vector(1, 2)

111. transpose: 矩阵转换

使用范式：def transpose[U](implicit asArray: (T) ⇒ Array[U]): Array[Array[U]]
使用说明：矩阵转换，二维数组行列转换

val k = Array(Array(1,2),Array(3,4),Array(5,6))
k.transpose
res345: Array[Array[Int]] = Array(Array(1, 3, 5), Array(2, 4, 6))

val k = Array(Array(1,2),Array(3,4),Array(5))
res346: Array[Array[Int]] = Array(Array(1, 3, 5), Array(2, 4))

k.transpose.transpose
res347: Array[Array[Int]] = Array(Array(1, 2), Array(3, 4), Array(5))

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

使用范式：def union(that: collection.Seq[T]): Array[T]
使用说明：联合两个序列，同操作符++

val a = Array(1,2,3)
val b = List(4,5,6)
 a.union(b)
res348: Array[Int] = Array(1, 2, 3, 4, 5, 6)

b.union(a)
res349: List[Int] = List(4, 5, 6, 1, 2, 3)

113. unzip: 将含有元组的数组中元组的第一个元素组成一个序列，第二个元素组成一个序列

使用范式：def unzip(implicit asPair: (T) ⇒ (T1, T2), ct1: ClassTag[T1], ct2: ClassTag[T2]): (Array[T1], Array[T2])
使用说明： 将含有元组的数组中元组的第一个元素组成一个序列，第二个元素组成一个序列
注：元组有且只能由两个元素

val k = Array((1,2),(3,4))
k.upzip
res352: (Array[Int], Array[Int]) = (Array(1, 3),Array(2, 4))

114. unzip3

使用范式：def unzip3( implicit asTriple: (T) ⇒ (T1, T2, T3),ct1: ClassTag[T1], ct2: ClassTag[T2], ct3: ClassTag[T3]): (Array[T1], Array[T2], Array[T3])
使用说明： 将含有三个元素的三个数组，第一个元素取出组成一个序列，第二个元素组成一个序列，第三个元素组成一个序列
注：元组有且只能由三个元素

val k = Array((1,2,3),(4,5,6))
k.unzip3
res353: (Array[Int], Array[Int], Array[Int]) = (Array(1, 4),Array(2, 5),Array(3, 6))

val k = Array((1,2,3),(4,5))
k.unzip3
<console>:17: error: No implicit view available from Product with Serializable => (T1, T2, T3).
       k.unzip3
         ^

115. update:更新数组

使用范式：def update(i: Int, x: T): Unit
使用说明： 将序列中 i 索引处的元素更新为 x,无返回值
注：无返回值，不能用变量去接

val a = Array(1,2,3)
a.update(1,5)

scala> a
res356: Array[Int] = Array(1, 5, 3)

116. updated:更新数组,返回更新后的数组

使用范式：def updated(index: Int, elem: A): Array[A]
使用说明： 更新数组,返回更新后的数组

val a = Array(1,2,3)
a.updated(1,5)
res361: Array[Int] = Array(1, 5, 3)

117. view

使用范式：def view(from: Int, until: Int): IndexedSeqView[T, Array[T]]
使用说明： 返回from到until间的元素，前包后不包，有点类似于切片slice，可联合记忆

val a = Array(1,2,3,4)
a.view(0,3).toList
res25: List[Int] = List(1, 2, 3)

a.view(1,3).toList
res26: List[Int] = List(2, 3)

118. withFilter:

使用范式：def withFilter(p: (T) ⇒ Boolean): FilterMonadic[T, Array[T]]
使用说明：根据条件过滤元素，类似于filter,不过需要用map取出才能有一样的效果

val a = Array(1,2,3,4)
 a.withFilter(_>3).map(x=>x)
res369: Array[Int] = Array(4)

a.filter(_>3)
res363: Array[Int] = Array(4)

119. zip:将两个序列对应位置上的元素组成一个元组序列

使用范式：def zip[B](that: GenIterable[B]): Array[(A, B)]
使用说明：upzip的反方向转换，将两个序列对应位置上的元素组成一个元组序列,不会自动补充

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

120. zipAll:将两个序列对应位置上的元素组成一个pair序列,可以设置自动补充

使用范式：def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): Array[(A, B)]
使用说明：同zip，但是允许两个序列长度不一样，不足的自动补充
注：如果当前序列that相对长，空出的填充为 thisElem，如果 that 短，填充为 thatElem

val a = Array(1,2,3,4,5)
val b = Array(5,4,3,2)
a.zipAll(b,9,8)
res30: Array[(Int, Int)] = Array((1,5), (2,4), (3,3), (4,2), (5,8))

val b = Array(1,2,3,4,5)
val a = Array(5,4,3,2)
a.zipAll(b,9,8)
res31: Array[(Int, Int)] = Array((5,1), (4,2), (3,3), (2,4), (9,5))

121. zipWithIndex :序列中的每个元素和它的索引组成一个元组序列

使用范式：def zipWithIndex: Array[(A, Int)]
使用说明：序列中的每个元素和它的索引组成一个元组序列

val a = Array(10,20,30,40)
a.zipWithIndex
res371: Array[(Int, Int)] = Array((10,0), (20,1), (30,2), (40,3))