一、Array 、Array Buffer
1、Array
在Scala中，Array代表的含义与Java中类似，也是长度不可改变的数组。
此外，由于Scala与Java都是运行在JVM中，双方可以互相调用，因此Scala数组的底层实际上是Java数组。例如字符串数组在底层就是Java的String[]，
整数数组在底层就是JaVa的Int[]。
数组初始化后，长度就固定下来了，而且元素全部根据其类型初始化：
val a=new Array[Int]（10）
val a=new Array[String]（10）
可以直接使用Array（）创建数组，元素类型自动推断：
val a=Array（"hello"，"world"）
a（0）= "hi"
######
scala> val a = new Array[Int](10)
a: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
scala> a(0) = 1 #scala 用() 访问元素
scala> a
res57: Array[Int] = Array(1, 0, 0, 0, 0, 0, 0, 0, 0, 0)
scala> a(1)
res58: Int = 0
######
scala> val a = new Array[String](10)
a: Array[String] = Array(null, null, null, null, null, null, null, null, null, null)
scala> a(1)
res60: String = null
scala> a(1) = "leo"
scala> a(1)
res62: String = leo
######
scala> val a = Array("hello", "word")
a: Array[String] = Array(hello, word)
scala> a
res63: Array[String] = Array(hello, word)
scala> a(0) = "Hi"
scala> a
res66: Array[String] = Array(Hi, word)
######
scala> val a = Array("leo", 30)
a: Array[Any] = Array(leo, 30) #自动类型推断
scala> a.length
res67: Int = 2
2、Array Buffer
在Scala中，如果需要类似于Java中的ArrayList这种长度可变的集合类，则可以使用ArrayBuffer。 //如果不想每次都使用全限定名，则可以预先导入ArrayBuffer类 import scala.collection.mutable.ArrayBuffer //使用ArrayBufer（）的方式可以创建一个空的ArrayBuffer val b=ArrayBuffertlnty（） //使用+=操作符，可以添加一个元素，或者多个元素 b += 1 b +=（2，3，4，5） /使用++=操作符，可以添加其他集合中的所有元素 b ++= Array（6，7，8，9，10） //使用trimEnd（）函数，可以从尾部截断指定个数的元素 b.trimEnd（5） ###### scala> import scala.collection.mutable.ArrayBuffer import scala.collection.mutable.ArrayBuffer scala> val b = ArrayBuffer[Int]() b: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer() scala> b += 1 #scala特有语法，往数组中加元素 res68: b.type = ArrayBuffer(1) scala> b += (2,3,4,5) res69: b.type = ArrayBuffer(1, 2, 3, 4, 5) scala> b ++= Array(6,7,8,9,10) res70: b.type = ArrayBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) scala> b.trimEnd(5) scala> b res72: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 5) ###### /使用insert（）函数可以在指定位置插入元素； /但是这种操作效率很低，因为需要移动指定位置后的所有元素 b.insert（5，6） b.insert（6，7，8，9，10） /使用remove（）函数可以移除指定位置的元素 b.remove（1） b.remove（1，3） //Array与ArrayBuffer可以互相进行转换 b.toArray a.toBuffer ###### scala> b res73: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 5) scala> b.insert(5,6) scala> b res75: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 5, 6) scala> b.insert insert insertAll scala> b.insert(6,7,8,9,10) scala> b res77: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) scala> b.remove(1) res78: Int = 2 scala> b res79: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 3, 4, 5, 6, 7, 8, 9, 10) scala> b.remove(1,3) scala> b res81: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 6, 7, 8, 9, 10) scala> var bArray = b.toArray bArray: Array[Int] = Array(1, 6, 7, 8, 9, 10) scala> var aArrayBuffer = a.toBuffer aArrayBuffer: scala.collection.mutable.Buffer[Any] = ArrayBuffer(leo, 30)
3、遍历Array ArrayBuffer
//使用for循环和until遍历Array/ArrayBufer
/使until是Richlnt提供的函数
for（i<-0 until b.length）
printin（b（i））
//跳跃遍历Array/ArrayBuffer
for（i <- 0 until（b.length，2））
printin（b（i）
//从尾部遍历Array/ArrayBuffer
for（i<-（0 until b.length）.reverse）
printin(bi))
/使用“增强for循环”遍历Array/ArrayBuffer
for（e <- b）
printin（e）
######
scala> for (i <- 0 until b.length) println(b(i))
1
6
7
8
9
10
scala> for (i <- 0 until (b.length, 2)) println(b(i)) #指定步长
1
7
9
scala> for (i <- (0 until b.length).reverse) println(b(i)) #反转
10
9
8
7
6
1
scala> for(e <- b) println(e) #增强for
1
6
7
8
9
10
4、数组常见操作
/数组元素求和 val a=Array（1，2，3，4，5） val sum=a.sum /获取数组最大值 val max=a.max /对数组进行排序 scala.util.Sorting.quickSort（a） /获取数组中所有元素内容 a.mkString a.mkString（"，"） #指定分隔符 a.mkString（"<"，"，"，">"） //toString函数 a.toString b.toString
二、数组转换
1、使用yield和函数式编程转换数组
//对Array进行转换，获取的还是Array
val a=Array（1，2，3，4，5）
val a2=for（ele <- a）yield ele * ele
//对ArayBuffer进行转换，获取的还是ArrayBuffer
val b=ArrayBuffer[In]（）
b +=（1，2，3，4，5）
val b2=for（ele <-b）yield ele * ele
/结合if守卫，仅转换需要的元素
val a3 = for（ele <- if ele % 2 == 0）yield ele * ele
/使用函数式编程转换数组（通常使用第一种方式）
a.filter (_%2 == 0).map（2 * _）
a.filter {_ % 2 == 0}map{2 * _}
##scala yield
对于for循环的每次迭代，yield都会生成一个将被记住的值。就像有一个你看不见的缓冲区，for循环的每一次迭代都会将另一个新的值添加到该缓冲区。
当for循环结束运行时，它将返回所有已赋值的集合。返回的集合的类型与迭代产生的类型相同，因此Map会生成Map，List将生成List，等等。
另外请注意，最初的集合没有改变。for / yield构造根据您指定的算法创建一个新的集合。
######
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer
scala> val b = ArrayBuffer[Int]()
b: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()
scala> b += (1,2,3,4,5)
res1: b.type = ArrayBuffer(1, 2, 3, 4, 5)
scala> val b2 = for(ele <- b) yield ele * ele
b2: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 4, 9, 16, 25)
scala> val a3 = for(ele <- a if ele % 2 == 0) yield ele * ele #yield
a3: Array[Int] = Array(4, 16)
scala> a.filter(_ % 2 == 0).map(_ * 2) #
res2: Array[Int] = Array(4, 8)
scala> a.filter { _ % 2 == 0} map{ _ * 2}
res3: Array[Int] = Array(4, 8)
2、算法案例
移除第一个负数之后的所有负数；
/构建数组
val a = ArrayBuffer[inty（）
a +=（1，2，3，4，5，-1，-3，-5，-9）
/每发现一个第一个负数之后的负数，就进行移除，性能较差，多次移动数组
var foundFirstNegative = false
var arrayLength = a.length
var index = 0
while（index < arrayLength）{
if（a（index）>= 0）{
index += 1
}else{
if（！foundFirstNegative）{foundFirstNegative = true；index += 1}
else{a.remove（index）；arrayLength -= 1}
}
}
############