Scala中Array的方法详细汇总(顺序介绍)

一、Scala中Array数组

1.定义

定义：数组是一种可变的、可索引的数据集合。

2.语法格式

语法格式：Scala中用Array[T]的形式来表示Java中的数组形式 T[]

val numbers = Array(1, 2, 3, 4) //声明一个数组对象
val first = numbers(0) // 读取第一个元素
numbers(3) = 100 // 替换第四个元素为100
val biggerNumbers = numbers.map(_ * 2) // 所有元素乘2

二、Scala：Array的集合操作

1. ++ ++：

1.1 ++

语法：def ++[B](that: GenTraversableOnce[B]): Array[B]
注解：合并集合，并返回一个新的数组，新数组包含左右两个集合对象的内容。

 val a = Array(1,2)
 val b = Array(3,4)
 val c = a ++ b
 c	//结果：Array[Int] = Array(1, 2, 3, 4)

 val b = Array("c","d")
 val c = a ++ b		//c: Array[Any] = Array(1, 2, c, d)

1.2 ++：

语法：def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Array[T], B, That]): That
注解：合并集合，并返回一个新的数组，新数组包含左右两个集合对象的内容，且右边操作数据的类型决定着返回结果的类型（不是值类型）。
举例**：
下面代码中List和LinkedList结合，返回结果是LinkedList类型

val a = List(1,2)
val b = scala.collection.mutable.LinkedList(3,4)
val c = a ++: b
println(c.getClass().getName())// c的类型是：scala.collection.mutable.LinkedList

2. +： :+

2.1 +:

语法：def +:(elem: A): Array[A]
注解：在数组前面添加一个元素，并返回新的对象
举例**：下面添加一个元素 0

 val a = List(1,2)
 val c = 0 +: a // c中的内容是 （0,1,2）

2.2 :+

语法：def :+(elem: A): Array[A]
注解：在数组末尾添加一个元素，并返回新对象

 val a = List(1,2)
 val c = a :+ 0 // c中的内容是 （1,2,0）

3. /: :\

3.1 /:

语法：def /:[B](z: B)(op: (B, T) ⇒ B): B
注解：对数组中所有的元素进行相同的操作 ，foldLeft的简写（左二叉树）

 val a = List(1,2,3,4)
 val c = (10 /: a)(_+_)   // 1+2+3+4+10
 val d = (10 /: a)(_*_)   // 1*2*3*4*10
 println("c:"+c)   // c:20
 println("d:"+d)   // d:240

3.2 :\

语法：def :[B](z: B)(op: (T, B) ⇒ B): B
注解：对数组中所有的元素进行相同的操作 ，foldRight的简写（右二叉树）

4. addString

4.1 addString(b: StringBuilder)

语法：def addString(b: StringBuilder): StringBuilder
注解：将数组中的元素逐个添加到b中

val a = List(1,2,3,4)
val b = new StringBuilder()
val c = a.addString(b)   // c中的内容是  1234

4.2 addString(b: StringBuilder, sep: String)

语法： def addString(b: StringBuilder, sep: String): StringBuilder
注解：将数组中的元素逐个添加到b中，但每个元素间sep分隔符分开

val a = List(1,2,3,4)
val b = new StringBuilder()
val c = a.addString(b,",") 
println("c:  "+c)  // c:  1,2,3,4

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

语法：def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
注解：将数组中的元素逐个添加到b中，同时在首尾各加一个字符串，并指定sep分隔符

val a = List(1,2,3,4)
val b = new StringBuilder()
val c = a.addString(b,"{",",","}") 
println("c:  "+c)  // c:  {1,2,3,4}

5. aggregate

语法：def aggregate[B](z: ⇒ B)(seqop: (B, T) ⇒ B, combop: (B, B) ⇒ B): B
注解：聚合计算，aggregate是柯里化方法，参数是两个方法。
举例**：为方便理解，我们把aggregate的两个参数，分别封装成两个方法，并把计算过程打印出来。

def seqno(m:Int,n:Int): Int ={
  val s = "seq_exp=%d+%d"
  println(s.format(m,n))
  return m+n
}
def combine(m:Int,n:Int): Int ={
  val s = "com_exp=%d+%d"
  println(s.format(m,n))
  return m+n
}

def main(args: Array[String]) {
  val a = List(1,2,3,4)
  val c = a.par.aggregate(5)(seqno,combine)
  println("c:"+c)
}
/**
  seq_exp=5+3
  seq_exp=5+2
  seq_exp=5+4
  seq_exp=5+1
  com_exp=6+7
  com_exp=8+9
  com_exp=13+17
  c:30
*/

def mapper(m:Int,n:Int): Int ={
  val s = "seq_exp=%d+%d"
  println(s.format(m,n))
  return m+n
}
def reducer(m:Int,n:Int): Int ={
  val s = "com_exp=%d+%d"
  println(s.format(m,n))
  return m+n
}
def main(args: Array[String]) {
  val a = List(1,2,3,4,5)
  val c = a.par.aggregate(5)(seqno,combine)
  println("c:"+c)
}
/**
  第一个方法产生的结果集个数为奇数，会产生轮空。
  seq_exp=5+3
  seq_exp=5+2
  seq_exp=5+5
  seq_exp=5+4
  seq_exp=5+1
  com_exp=6+7
  com_exp=8+9
  com_exp=13+10
  com_exp=23+17
  c:40
*/

上面过程可以简写为

val a = List(1,2,3,4,5)
val c = a.par.aggregate(5)(_+_,_+_)	//c:Int = 40
println(c)	//40

6. andThen compose

6.1 andThen

语法：def andThen[A](g: R => A): T1 => A = { x => g(apply(x)) }
注解：Composes two instances of Function1 in a new Function1, with this function applied first.
@tparam A the result type of function g
@param g a function R => A
@return a new function f such that f(x) == g(apply(x))
andThen是实现一个新的函数f(x) ==g(apply(x))，本质是构建一个新的函数先运行g再运行f
例：

def f(a:Int) = {
 println("2*"+a)
 2*a
}
def g(b:Int) = {
 println("3*"+b)
 3*b
}
def result  = f _ andThen g _
//andThen：先运行第一个函数，第一个函数的运行结果，作为第二个函数的参数参与运算

println(result(1))
/*结果展示
2*1
3*2
6
*/

6.2 compose

语法：def compose[A](g: A => T1): A => R = { x => apply(g(x)) }
注解：Composes two instances of Function1 in a new Function1, with this function applied last.
@tparam A the type to which function g can be applied
@param g a function A => T1
@return a new function f such that `f(x) == apply(g(x))``
compose是实现一个新的函数f(x) == apply(g(x))，本质是构建一个新的函数先运行f再运行g
例：

def f(a:Int) = {
 println("2*"+a)
 2*a
}
def g(b:Int) = {
 println("3*"+b)
 3*b
}
def result  = f _ compose g _
//compose：先运行第二个函数，第二个函数的运行结果，作为第一个函数的参数参与运算

println(result(1))
/*结果展示
3*1
2*3
6
*/

对比测试

/** * 传入Int,结果翻倍 */
val doubleNum :Int => Int  = {num =>
  val numDouble = num * 2
  println(s"double Num ($num * 2 = $numDouble)")
  numDouble
}
// doubleNum: Int => Int = <function1>

/** *传入Int,结果加一 */
val addOne:Int => Int = {num=>
  val sumNum = num + 1
  println(s"add One ($num + 1 = $sumNum)")
  sumNum
}
addOne: Int => Int = <function1>

def myAndThen[A, B, C](g: A => B, f: B => C): A => C = x => f(g(x))
// myAndThen: [A, B, C](g: A => B, f: B => C)A => C
def myCompose[A, B, C](g: A => B, f: C => A): C => B = x => g(f(x))
// myCompose: [A, B, C](g: A => B, f: C => A)C => B

andThen：
期待一个A类型转化成一个C类型，x是一个A类型，将x传给g，作为g的参数得到一个一个B类型，再将结果作为参数传给f，f在是将B类型转化为一个C类型，最终实现A类型的x转化为C类型。
compose：
期待一个C类型转化为B类型，也就是是说compose则是将先执行靠里面的函数，再将结果传给外层函数，所以先执行f将C类型的x转化为一个A类型，再作为参数传给g，得到一个B类型。

val myComposeTest = myCompose[Int, Int, Int](addOne, doubleNum)	//myComposeTest: Int => Int = <function1>
myComposeTest(2)
val composeDoubleNumInAddOne = addOne compose doubleNum
val composeAddOneInDoubleNum = doubleNum compose addOne
composeDoubleNumInAddOne(2)
composeAddOneInDoubleNum(2)
assert(myComposeTest(2)==composeDoubleNumInAddOne(2))

val myAndThenTest = myAndThen[Int,Int,Int](addOne,doubleNum)
myAndThenTest(2)
val addOneAndThenDoubleNum = addOne andThen doubleNum
val doubleNumAndThenAddOne = doubleNum andThen addOne
addOneAndThenDoubleNum(2)
doubleNumAndThenAddOne(2)
assert(myAndThenTest(2)==addOneAndThenDoubleNum(2))

7. apply

7.1 apply

语法: def apply(i: Int): T
注解：取出指定索引i处的元素
例：

val a = Array(1,3,4,6)
val b = a.apply(2)
println("b=" + b)    // 结果：b=4
// 等同于
val b = numbers(2) 
println("b=" + b)    // 结果：b=4

7.2 applyOrElse

语法：def applyOrElse[A1 <: Int, B1 >: Int](x: A1,default: A1 => B1): B1
注释： 取出指定索引x处的元素，如果不存在索引x，则提供一个函数，指定默认值
例：

val a = Array(1,3,6,2,4,8)
val b = a.applyOrElse(1,{x:Int => 9})	// b: Int = 3
val b = a.applyOrElse(6,{x:Int => 9})	// b: Int = 9

val b = a.applyOrElse(6,{x:String => "a"'})	// error: type mismatch;

8. array

语法：
注释：创建数组方法
例：

9. canEqual

语法：def canEqual(that: Any): Boolean
注释：判断两个对象是否可以进行比较
注意：这个方法基本不用，因为一般都能比较

10. charAt

语法: def charAt(index: Int): Char
注释：获取index索引处的字符，这个方法会执行一个隐式的转换，将Array[T]转换为 ArrayCharSequence，只有当T为char类型时，这个转换才会发生。
例：

val chars = Array('a','b','c')
println("c:"+chars.charAt(0))   //结果 a

val a = Array(1,3,4,6)
val d = a.charAt(0)	// 报错

11. clone（浅克隆）

语法： def clone(): Array[T]
注解：基于当前对象，创建一个副本
例：

 val chars = Array('a','b','c')  // (a,b,c)
 val newchars = chars.clone()
newchars  // (a,b,c)

12. collect collectFirst

12.1 collect

语法：def collect[B](pf: PartialFunction[A, B]): Array[B]
注释：通过执行一个并行计算（偏函数），得到一个新的数组对象
例：

val a = Array(1,2,3,4)
val func:PartialFunction[Int,Int]={
case x if x%2==0 => x+2
case x => x+1
}
a.collect(func)	// 结果：Array：Int = Array(2,4,4,6)
a.collectFirst(func)	//结果：Option[Int] = Some(4)

// fun偏函数的case变式
val func:PartialFunction[Int,Int]={
case x if x%2==0 => x+2
case _ => 1
}
a.collect(func)	//结果：Array：Int = Array(1,4,1,6)

# fun偏函数的case变式
val func:PartialFunction[Int,Int]={
case x if x%2==0 => x+2
}
a.collect(func)	//结果：Array：Int = Array(4,6)

12.2 collectFirst

语法：def collectFirst[B](pf: PartialFunction[T, B]): Option[B]
注解：在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算
例：

val arr = Array(1,'a',"b")
//定义一个偏函数，要求当被执行对象为Int类型时，进行乘100的操作（对于对象arr来说，只有第一个元素符合要求）
val func:PartialFunction[Any,Int] = {
  case x:Int => x*100
}
//计算
val v= arr.collectFirst(func)
println("value:"+v)	//结果：value:Some(100)
//另一种写法
val v = arr.collectFirst({case x:Int => x*100})
println("value:"+v)	//结果：value:Some(100)

13. combinations

语法： def combinations(n: Int): collection.Iterator[Array[T]]
注解：排列组合，这个排列组合会选出所有包含字符不一样的组合，（对于 “abc”、“cba”，只选择一个），参数n表示序列长度，即几个元素为一个组合
例：

val arr = Array("a","b","c")
val newarr = arr.combinations(2)
newwarr.foreach(println)	//结果：3个地址值
newarr.foreach((item) => println(item.mkString(",")))
/**
结果：
a,b
a,c
b,c
*/

14. companion（伴生对象）

语法：override def companion: scala.collection.generic.GenericCompanion[scala.collection.mutable.IndexedSeq]
注解：
例：

val d = Array（1,3,3,2,4）
val f = d.companion		//f:scala.collection.generic.GenericCompanion[scala.collection.mutable.IndexedSeq] = scala.collection.mutable.IndexedSeq$@3bf7c70e
println(f)		// scala.collection.mutable.IndexedSeq$@3bf7c70e

15. contains containsSlice

15.1 contains

语法： def contains[A1 >: A](elem: A1): Boolean
注解：判断序列中是否包含指定对象（次序一致）

15.2 containsSlice

语法：def containsSlice[B](that: GenSeq[B]): Boolean
注解： [slaɪs]判断当前序列中是否包含另一个序列

val b = Array(1,2,3,Array(4,5))
val c = Array(4,5,6)
b.containsSlice(c)	// 结果：Boolean = false

val c = Array(4,5)
b.containsSlice(c)	// 结果：Boolean = false
val b = Array(1,2,3,4,5)
b.containsSlice(c)	// 结果：Boolean = true

16. copy

16.1 copyToArray

语法1**：def copyToArray(xs: Array[A]): Unit
注解1**：将元数组中的元素拷贝到新数组，默认拷贝元数组所有元素

语法2**：def copyToArray(xs: Array[A], start: Int): Unit
注解2**：将元数组中的元素拷贝到新数组，从新数组索引为start的地方开始写入，默认拷贝元数组所有元素

语法3**：def copyToArray(xs: Array[A], start: Int, len: Int): Unit
注解3**：将元数组中的元素拷贝到新数组，从新数组索引为start的地方开始写入，拷贝元数组元素长度为len

val a = Array('a', 'b', 'c')
val b : Array[Char] = new Array(5)	//结果：b: Array[Char] = Array(?, ?, ?, ?, ?)
a.copyToArray(b)    
b // 结果：res34: Array[Char] = Array(a, b, c, ?, ?)

val b : Array[Char] = new Array(5)
a.copyToArray(b,1)
b // 结果：res38: Array[Char] = Array(?, a, b, c, ?)

val b : Array[Char] = new Array(5)
a.copyToArray(b,1,2)
b // 结果：res43: Array[Char] = Array(?, a, b, ?, ?)