Scala---Array（集合、序列）

Scala：Array（集合、序列）

​ 数组是一种可变的、可索引的数据集合。在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提供了大量的集合操作：

def ++[B](that: GenTraversableOnce[B]): Array[B]

​ 合并集合，并返回一个新的数组，新数组包含左右两个集合对象的内容。
​

	val a = Array(1,2)
	val b = Array(3,4)
	val c = a ++ b
	//c中的内容是(1,2,3,4)

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

def +:(elem: A): Array[A]

​ 在数组前面添加一个元素，并返回新的对象，下面添加一个元素 0

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

def :+(elem: A): Array[A]

​ 同上面的方法想法，在数组末尾添加一个元素，并返回新对象

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

def :[B](z: B)(op: (T, B) ⇒ B): B

​ foldRight的简写

def addString(b: StringBuilder): StringBuilder

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

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

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

​ 同上，每个元素用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

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

同上，在首尾各加一个字符串，并指定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}

def aggregate[B](z: ⇒ B)(seqop: (B, T) ⇒ B, combop: (B, B) ⇒ B): B

​ 聚合计算，aggregate是柯里化方法，参数是两个方法，为了方便理解，我们把aggregate的两个参数，分别封装成两个方法，并把计算过程打印出来。

  def main(args: Array[String]) {
   
    val a = List(1,2,3,4)
    val c = a.par.aggregate(5)(seqno,combine)
    println("c:"+c)
  }
  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
  }
  /**
    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
  */

上面过程可以简写为

	val c = a.par.aggregate(5)(_+_,_+_)

def apply(i: Int): T

​ 同下面代码，取出指定索引处的元素

	val first = numbers(0) // 读取第一个元素

def canEqual(that: Any): Boolean

​ 判断两个对象是否可以进行比较

def charAt(index: Int): Char

​ 获取index索引处的字符，这个方法会执行一个隐式的转换，将Array[T]转换为ArrayCharSequence，只有当T为char类型时，这个转换才会发生。

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

def clone(): Array[T]

​ 创建一个副本

	val chars = Array('a','b','c')
    println(a.apply(2))
    val newchars = chars.clone()

def collect[B](pf: PartialFunction[A, B]): Array[B]

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

 val chars = Array('a','b','c')
   val newchars = chars.collect(fun)
   println("newchars:"+newchars.mkString(","))
  //我们通过下面的偏函数，把chars数组的小写a转换为大写的A
  val fun:PartialFunction[Char,Char] = {
   
    case 'a' => 'A'
    case x => x
  }
  /**输出结果是 newchars:A,b,c */

def collectFirst[B](pf: PartialFunction[T, B]): Option[B]

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

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

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

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

    val arr = Array("a","b","c")
    val newarr = arr.combinations(2)
    newarr.foreach((item) => println(item.mkString(",")))
    /**
    a,b
    a,c
    b,c
    */

def contains[A1 >: A](elem: A1): Boolean

​ 序列中是否包含指定对象

def containsSlice[B](that: GenSeq[B]): Boolean

​ 判断当前序列中是否包含另一个序列

	val a = List(1,2,3,4)
	val b = List(2,3)
	println(a.containsSlice(b))  //true

def copyToArray(xs: Array[A]): Unit

​ 此方法还有两个类似的方法
​ copyToArray(xs: Array[A], start: Int): Unit
​ copyToArray(xs: Array[A], start: Int, len: Int): Unit

	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]*/

def copyToBuffer[B >: A](dest: Buffer[B]): Unit

​ 将数组中的内容拷贝到Buffer中

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

def corresponds[B](that: GenSeq[B])(p: (T, B) ⇒ Boolean): Boolean

​ 判断两个序列长度以及对应位置元素是否符合某个条件。如果两个序列具有相同的元素数量并且p(x, y)=true，返回结果为true

​ 下面代码检查a和b长度是否相等，并且a中元素是否小于b中对应位置的元素

	val a = Array(1, 2, 3)
	val b = Array(4, 5,6)
	println(a.corresponds(b)(_<_))  //true

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

​ 统计符合条件的元素个数，下面统计大于 2 的元素个数

	val a = Array(1, 2, 3)
	println(a.count({
   x:Int => x > 2}))  // count = 1

def diff(that: collection.Seq[T]): Array[T]

​ 计算当前数组与另一个数组的不同。将当前数组中没有在另一个数组中出现的元素返回

	val a = Array(1, 2, 3,4)
	val b = Array(4, 5,6,7)
	val c = a.diff(b)
	println(c.mkString) //1,2,3

def distinct: Array[T]

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

	val a = Array(1, 2, 3,4,4,5,6,6)
	val c = a.distinct
	println(c.mkString(","))    // 1,2,3,4,5,6

def drop(n: Int): Array[T]

​ 将当前序列中前 n 个元素去除后，作为一个新序列返回

	val a = Array(1, 2, 3,4)
	val c = a.drop(2)
	println(c.mkString(","))    // 3,4

def dropRight(n: Int): Array[T]

​ 功能同 drop，去掉尾部的 n 个元素

def dropWhile(p: (T) ⇒ Boolean): Array[T]

​ 去除当前数组中符合条件的元素，这个需要一个条件，就是从当前数组的第一个元素起