scala数据结构之数组

 XML Code 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

package com.lyzx.day06


class T2 {
  /**
   *对数组的操作(一)
   * 数组通过(index)访问元素
   */
  def f1(): Unit ={

    //创建数组的第一种方式使用 new Array[T](length)
    val arr1 = new Array[String](10);
    arr1(0) = "A"
    arr1(2) = "C"
    arr1(3) = "D"

    //遍历数组的第一种方式   foreach
    for(item <- arr1){
      println(item)
    }
    println("============================")

    //创建数组的第二种方式 直接使用Array(item1,item2,....) 自动推断泛型类型
    val arr2 = Array(9,8,7,6,5,4,3,2,1)

    //遍历数组的第二种方式   使用Array的foreach成员方法  函数一个函数(函数式编程把函数当做一个值/变量)
    arr2.foreach(item => {
      println("arr2.foreach遍历数组:"+(item+100))
    })

    println("==================================")
    //遍历数组的第三种方式 可以访问数组的下标
    for(index <- 0 until arr1.length){
      println("数组的第"+(index+1)+"项是"+arr1(index))
    }
  }

  /**
   *对数组的操作(二)
   *创建并访问二维数组
   */
  def f2(): Unit ={

    //创建二维数组的第一种方式
    val arr1 = Array(Array(1,2,3),Array(4,5,6))
    //创建二维数组的第二种方式
    val arr2 = new Array[Array[String]](3)
    arr2(0) = Array[String]("A","B","C")
    arr2(1) = Array[String]("D","E","F")
    arr2(2) = Array[String]("G","H","I")

    //遍历二维数组的第一种方式foreach
    for(itemArr <- arr1) {
      for (item <- itemArr) {
        println("for-each:"+item)
      }
    }
    println("==============================")

    //遍历二维数组的第二种方式
    arr1.foreach(arrItem =>{
      arrItem.foreach(item=>{
        println("arr1.foreach:"+item)
      })
    })

    //遍历二维数组的第三中方式
    println("===============================")
    for(i <- 0 until arr2.length;j <- 0 until arr2(i).length){
        println("for-until:"+arr2(i)(j))
    }
  }

  def f3(): Unit ={
    //返回包含所有序列的数组
    var arr = Array.apply(1,2,3,4)
    arr.foreach(item=>{
      println(item)
    })

    println("================================================================")
    //第一个参数是数组的长度，后面的函数表示生成数组元素的规则,从运行结果可以看出x默认从0开始，每次加1
    val arr2 = Array.tabulate(3)(x=>{print(">>x="+x+"   ");x+4})
    for(index <- 0 until arr2.length){
      println(arr2(index))
    }

    println("=================================================================")
    //Array.tabulate(M,N)((x,y)=>{x+y})  其中M是二维数组的长度  N是该二维数组中每一维的长度，x从0开始每次加1 y是第二维的下标
    val arr3 = Array.tabulate(8,4)((x,y)=>{x+y})
    for(i <- 0 until arr3.length;j <- 0 until arr3(i).length){
      println("00000:arr3("+i+")("+j+")"+arr3(i)(j))
    }

  }
}

object T2{
  def main(args: Array[String]) {
     val t2 = new T2
   // t2.f1()
  //  t2.f2()
    t2.f3()
  }
}

数组所有方法

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 开始。