scala-12-数组

定长数组

val arr1 = new ArrayInt

object ArrayDemo01 {
  def main(args: Array[String]): Unit = {
    //说明
    //1. 创建了一个Array对象,
    //2. [Int] 表示泛型，即该数组中，只能存放Int
    //3. [Any] 表示 该数组可以存放任意类型
    //4. 在没有赋值情况下，各个元素的值 0
    //5.  arr01(3) = 10 表示修改 第4个元素的值
    val arr01 = new Array[Int](4) //底层 int[] arr01 = new int[4]
    println(arr01.length) // 4

    println("arr01(0)=" + arr01(0)) // 0
    //数据的遍历

    for (i <- arr01) {
      println(i)
    }
    println("--------------------")
    arr01(3) = 10 //
    for (i <- arr01) {
      println(i)
    }

  }
}

第二种方式定义数组
//使用 apply 方法创建数组对象
val arr1 = Array(1, 2)

object ArrayDemo02 {
def main(args: Array[String]): Unit = {
//说明
//1. 使用的是 object Array 的 apply
//2. 直接初始化数组，这时因为你给了 整数和 "", 这个数组的泛型就 Any
//3. 遍历方式一样
var arr02 = Array(1, 3, "xx") arr02(1) = "xx"
for (i <- arr02) { 
println(i)
}
//可以使用我们传统的方式遍历，使用下标的方式遍历
for (index <- 0 until   arr02.length) {
printf("arr02[%d]=%s", index , arr02(index) + "\t")
}
}
}

变长数组

object ArrayBufferDemo01 {
  def main(args: Array[String]): Unit = {
    //创建ArrayBuffer
    val arr01 = ArrayBuffer[Any](3, 2, 5)

    //访问，查询
    //通过下标访问元素
    println("arr01(1)=" + arr01(1)) // arr01(1) = 2
    //遍历
    for (i <- arr01) {
      println(i)
    }
    println(arr01.length) //3
    println("arr01.hash=" + arr01.hashCode())


    //修改 [修改值，动态增加]
    //使用append 追加数据 ,append支持可变参数
    //可以理解成java的数组的扩容
    arr01.append(90.0,13) // (3,2,5,90.0,13)
    println("arr01.hash=" + arr01.hashCode())
    println("===================")
    arr01(1) = 89 //修改 (3,89,5,90.0,13)
    println("--------------------------")
    for (i <- arr01) {
      println(i)
    }
    //删除...
    //删除,是根据下标来说
    arr01.remove(0)  // (89,5,90.0,13)
    println("--------删除后的元素遍历---------------")
    for (i <- arr01) {
      println(i)
    }
    println("最新的长度=" + arr01.length) // 4
  }
}

1)ArrayBuffer 是变长数组，类似 java 的 ArrayList
2)val arr2 = ArrayBufferInt 也是使用的 apply 方法构建对象
3)def append(elems: A*) { appendAll(elems) } 接收的是可变参数.
4)每 append 一次，arr 在底层会重新分配空间，进行扩容，arr2 的内存地址会发生变化，也就成为新的 ArrayBuffer

在开发中，我们可能使用对定长数组和变长数组，进行转换
arr1.toBuffer //定长数组转可变数组
arr2.toArray //可变数组转定长数组
注意事项：
arr2.toArray 返回结果才是一个定长数组， arr2 本身没有变化
arr1.toBuffer 返回结果才是一个可变数组， arr1 本身没有变化

多维数组

//定义
val arr = Array.ofDim[Double](3,4)
//说明：二维数组中有三个一维数组， 每个一维数组中有四个元素

object MultiplyArray {
  def main(args: Array[String]): Unit = {

    //创建
    val arr = Array.ofDim[Int](3, 4)

    //遍历
    for (item <- arr) { //取出二维数组的各个元素（一维数组）
      for (item2 <- item) { // 元素（一维数组） 遍历
        print(item2 + "\t")
      }
      println()
    }
    //指定取出
    println(arr(1)(1)) // 0

    //修改值
    arr(1)(1) = 100

    //遍历
    println("=====================")
    for (item <- arr) { //取出二维数组的各个元素（一维数组）
      for (item2 <- item) { // 元素（一维数组） 遍历
        print(item2 + "\t")
      }
      println()
    }

    //使用传统的下标的方式来进行遍历
    println("===================")
    for (i <- 0 to arr.length - 1) { //先对
      for (j <- 0 to arr(i).length - 1) {
        printf("arr[%d][%d]=%d\t", i, j, arr(i)(j))
      }
      println()

    }
  }
}

scala数组和java list的互转

object ArrayBuffer2JavaList {
  def main(args: Array[String]): Unit = {
    // Scala集合和Java集合互相转换

    val arr = ArrayBuffer("1", "2", "3")
    /*
    implicit def bufferAsJavaList[A](b : scala.collection.mutable.Buffer[A]) : java.util.List[A] = { /* compiled code } */
    import scala.collection.JavaConversions.bufferAsJavaList
    //对象 ProcessBuilder ， 因为 这里使用到上面的  bufferAsJavaList
    val javaArr = new ProcessBuilder(arr) //为什么可以这样使用?
    // 这里arrList 就是java中的List
    val arrList = javaArr.command()
    println(arrList) //输出 [1, 2, 3]

    //java的List 转成 scala的 ArrayBuffer
    //说明
    //1. asScalaBuffer 是一个隐式函数
    /*
    implicit def asScalaBuffer[A](l : java.util.List[A]) : scala.collection.mutable.Buffer[A] = {  compiled code } 
   */
    import scala.collection.JavaConversions.asScalaBuffer
    import scala.collection.mutable
    // java.util.List ==> Buffer
    val scalaArr: mutable.Buffer[String] = arrList
    scalaArr.append("jack")
    scalaArr.append("tom")
    scalaArr.remove(0)
    println(scalaArr) // (2,3,jack,tom)

  }
}