3、scala数组

在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)

scala> a(0) = 1    #scala 用() 访问元素

scala> a
res57: Array[Int] = Array(1,0)

scala> a(1)
res58: Int = 0


######
scala> val a = new Array[String](10)
a: Array[String] = Array(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

在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,5) scala> b ++= Array(6,7,8,9,10) res70: b.type = ArrayBuffer(1,5,6,10) scala> b.trimEnd(5) scala> b res72: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1,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,5) scala> b.insert(5,6) scala> b res75: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1,6) scala> b.insert insert insertAll scala> b.insert(6,10) scala> b res77: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1,10) scala> b.remove(1) res78: Int = 2 scala> b res79: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1,10) scala> b.remove(1,3) scala> b res81: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1,10) scala> var bArray = b.toArray bArray: Array[Int] = Array(1,10) scala> var aArrayBuffer = a.toBuffer aArrayBuffer: scala.collection.mutable.Buffer[Any] = ArrayBuffer(leo,30)

//使用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 scala0 until (b.length,2)) println(b(i)) #指定步长 1 7 9 scala(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

/数组元素求和 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

//对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,5) res1: b.type = ArrayBuffer(1,5) scala> val b2 = for(ele b) yield ele * ele b2: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1,4,16,25) scala> val a3 = for(ele a if ele % 2 0) yield ele * ele #yield a3: Array[Int] = Array(4,0);">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)

/构建数组 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} } } ############