第四讲 数组及其相关操作

数组是一种存储了相同类型元素的固定大小顺序集合。

本章要点

• 数组的声明
• 数组的遍历
• 二维数组
• 数组的其他操作

4.1 数组的声明

定长数组

val nums=new Array[Int](10);//10个整数的数组,初始值为0

或

val nums :Array[Int]=new Array[Int](10);//10个整数的数组，初始值为0

或声明时，即赋值

val nums=Array(1,2,3,4);//4个整数的数组,初始值分别为1,2,3,4

** 变长数组**
在java中有ArrayList，scala中有等效的ArrayBuffer，如下：

      val arr=ArrayBuffer[Int]();
      arr+=1 //在尾端添加一个元素
      arr+=(1,2,3,4,5);//在尾端添加多个元素，用括号括起来
      arr++=Array(7,8,9)//在尾端追加集合
      arr.trimEnd(3);//删除最后3各元素
      arr.trimStart(3)//删除前3个元素
      arr.insert(2, 10)//第2个元素，插入10
      arr.insert(2, 10,11,12)//从第2个元素开始，依次插入10,11,12
      arr.remove(2)//移除第二元素
      arr.remove(2,4)//移除第二元素后的四个元素
      arr.toArray// ArrayBuffer转换为Array

4.2 遍历

for循环遍历

    for(a<-arr){
        print(a+" ")
      }

或

  for(i <- 0 until arr.length){
        print(arr(i)+" ")
      }

  for(i <- 0 until (arr.length,2)){//until (arr.length,2) 步长为2，跳跃获取
        print(arr(i)+" ")
      }

       for(i <- (0 until arr.length).reverse){//.reverse倒序
        print(arr(i)+" ")
      }

foreach遍历

    arr.foreach(i=>{
        print(i+" ")
      })

4.3 二维数组

定义一个二维数组：
1）

 val arr3 = new Array[Array[String]](3)

2）

var myMatrix = ofDim[Int](3,3)

赋值

    arr3(0)=Array("1","2","3")
    arr3(1)=Array("4","5","6")
    arr3(2)=Array("7","8","9")

遍历

    for(i <- 0 until arr3.length){
      for(j <- 0 until arr3(i).length){
        print(arr3(i)(j)+"  ")
      }
      println()
    }
    
    var count = 0
    for(arr <- arr3 ;i <- arr){
      if(count%3 == 0){
        println()
      }
      print(i+" ")
      count +=1 
    }
    
    arr3.foreach { arr  => {
      arr.foreach { println }
    }}
    
    
    val arr4 = Array[Array[Int]](Array(1,2,3),Array(4,5,6))
    arr4.foreach { arr => {
      arr.foreach(i => {
        println(i)
      })
    }}
    println("-------")
    for(arr <- arr4;i <- arr){
      println(i)
    }

4.4数组的其他操作

1. def apply( x: T, xs: T* ): Array[T]
   创建指定对象 T 的数组, T 的值可以是 Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean。
2. def concat[T]( xss: Array[T]* ): Array[T]
   合并数组
3. def copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit
   复制一个数组到另一个数组上。相等于 Java's System.arraycopy(src, srcPos, dest, destPos, length)。
4. def empty[T]: Array[T]
   返回长度为 0 的数组
5. def iterate[T]( start: T, len: Int )( f: (T) => T ): Array[T]
   返回指定长度数组，每个数组元素为指定函数的返回值。
   以上实例数组初始值为 0，长度为 3，计算函数为a=>a+1：
   scala> Array.iterate(0,3)(a=>a+1)
   res1: Array[Int] = Array(0, 1, 2)
6. def fill[T]( n: Int )(elem: => T): Array[T]
   返回数组，长度为第一个参数指定，同时每个元素使用第二个参数进行填充。
7. def fill[T]( n1: Int, n2: Int )( elem: => T ): Array[Array[T]]
   返回二数组，长度为第一个参数指定，同时每个元素使用第二个参数进行填充。
8. def ofDim[T]( n1: Int ): Array[T]
   创建指定长度的数组
9. def ofDim[T]( n1: Int, n2: Int ): Array[Array[T]]
   创建二维数组
10. def ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]]
    创建三维数组
11. def range( start: Int, end: Int, step: Int ): Array[Int]
    创建指定区间内的数组，step 为每个元素间的步长
12. def range( start: Int, end: Int ): Array[Int]
    创建指定区间内的数组
13. def tabulate[T]( n: Int )(f: (Int)=> T): Array[T]
    返回指定长度数组，每个数组元素为指定函数的返回值，默认从 0 开始。
    以上实例返回 3 个元素：
    scala> Array.tabulate(3)(a => a + 5)
    res0: Array[Int] = Array(5, 6, 7)
14. def tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]]
    返回指定长度的二维数组，每个数组元素为指定函数的返回值，默认从 0 开始。