Scala中的数组介绍与使用

た入场券 2023-05-29 11:56 11阅读 0赞

### 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