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