Scala中的数组介绍与使用

1 定长数组

定义一个长度不变的数组，可以使用Scala中的Array

//定义一个Int类型的数组，元素的初始值为0
scala> var nums = new Array[Int](10)
nums: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

//定义一个String类型的数组，元素的初始值为null
scala> var a = new Array[String](10)
a: Array[String] = Array(null, null, null, null, null, null, null, null, null, null)

//长度为2的字符串数组，类型为Array[String]是推导出来的
scala> val s = Array("Hello","world")
s: Array[String] = Array(Hello, world)

//使用()访问元素
scala> s(0)="bye bye"

scala> s
res2: Array[String] = Array(bye bye, world)

• 在 Scala 中使用 (index) 而不是 [index] 来访问数组中的元素，因为访问元素，对于 Scala 来说是方法调用，(index) 相当于执行了 .apply(index) 方法。
• Scala 中的数组与 Java 中的是等价的，Array[Int]() 在虚拟机层面就等价于 Java 的 int[]。

2 变长数组

在 scala 中通过 ArrayBuffer 实现变长数组 (又称缓冲数组)。在构建 ArrayBuffer 时必须给出类型参数，但不必指定长度，因为 ArrayBuffer 会在需要的时候自动扩容和缩容。

//或new ArrayBuffer[Int]
scala> val b = ArrayBuffer[Int]()
b: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

scala> b += 1
res0: b.type = ArrayBuffer(1)

scala> b += (1,2,4,5)
res1: b.type = ArrayBuffer(1, 1, 2, 4, 5)

scala> b ++= Array(9,7,6)
res2: b.type = ArrayBuffer(1, 1, 2, 4, 5, 9, 7, 6)
//移除最后三个元素
scala> b.trimEnd(3)

scala> b
res4: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 1, 2, 4, 5)
//在下标2之前插入
scala> b.insert(2,1)

scala> b
res6: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 1, 1, 2, 4, 5)

scala> b.remove(3)
res7: Int = 2

scala> b
res8: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 1, 1, 4, 5)

//下标2的位置移除三个元素
scala> b.remove(2,3)

scala> b
res10: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 1)

//先构建数组缓冲，再转数组
scala> val a = b.toArray
a: Array[Int] = Array(1, 1)

//将数组转为数组缓冲
scala> a.toBuffer
res12: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 1)

3 遍历数组

val arr = Array(2,3,4,5,5)

  for (a <- arr)
    println(a)

  /**
    * 方式二
    */
  for (i <- 0 until arr.length)
    println("序号为" + i + "的元素是" + arr(i))

  /**
    *
    */
  for (i <- (0 until arr.length).reverse)
    println("序号为" + i + "的元素是" + arr(i))

输出结果为

2
3
4
5
5
序号为0的元素是2
序号为1的元素是3
序号为2的元素是4
序号为3的元素是5
序号为4的元素是5

序号为4的元素是5
序号为3的元素是5
序号为2的元素是4
序号为1的元素是3
序号为0的元素是2

4 数组转换

4.1 将一个数组中的每个元素转换为之前的两倍

 val a = Array(1,2,3,4,5)
  val result = for (ele <- a) yield 2 * ele
  result.foreach(println)

输出结果 2，4，6，8，10

for(...) yield创建了一个与原始集合相同的新的集合，从数组出发得到的是一个新数组，从数组缓冲出发，得到的也是一个新的数组缓冲。

4.2 将一个数组中的元素为偶数的值乘以二并返回一个新的数组

//方式一，通过守卫，for中的if实现
  val b = Array(2,4,5,6)
  val reu = for (ele <- b if ele % 2 ==0) yield 2 * ele
  reu.foreach(println)
//方式二，通过函数式编程
  private val array: Array[Int] = b.filter(_%2 == 0).map(_*2)
  array.foreach(println)

5 多维数组

 //多维数组通过数组的数组实现,构造一个二维数组可以用ofDim方法
   val arrays: Array[Array[Double]] = Array.ofDim[Double](3,4)

  //长度
    println(arrays.length)

   val array = Array(Array(1,2,3,4,5),Array(2,3,4,5,6))
    //随机访问
    println(array(1)(3))
  /**
    * 循环遍历
    */
    for (elem <- array) {

      for (elem <- elem) {
        print(elem + ",")
      }
      println()
  }

输出结果

3
5
1,2,3,4,5,
2,3,4,5,6,

6 与java互操作

6.1 Scala中ArrayBuffer与Java中ArrayList的转换

例如，java.lang.ProcessBuilder类中有一个以List<String>为参数的构造器，在scala中的调用方法如下：

import scala.collection.JavaConversions.bufferAsJavaList
import scala.collection.mutable.ArrayBuffer
val command = ArrayBuffer("ls", "-al", "/home/cay")
val pb = new ProcessBuilder(command)  //scala 到 Java 的转换

import scala.collection.JavaConversions.asScalaBuffer
import scala.collection.mutable.Buffer
val cmd: Buffer[String] = pb.command()  //java转scala

ProcessBuilder构造需要java.util.List对象，我们通过导入隐式转换，ArrayBuffer对象会自动转换为java.util.List对象，反之pb.command()返回的是java.util.List对象，通过隐式转换，自动转换为Buffer对象。

6.2 Scala中Int 与 Java中Integer 的转换

val arrInt = Array(1, 2, 3)
val arrInteger = arrInt.map{(x:Int) : java.lang.Integer}

若还需要将scala的List 转化为 Java List

import scala.collection.JavaConverters._

val listJava = arrInteger.toList.asJava