scala基础-数组

1、array的定义

1.1 最原始的创建数组的形式

val array = new Array[Int](5)
// 数据索引的下标是从0开始的
for(i <- 1.to(5)) array(i - 1) = i * 11 - 3
for(item <- array) print(item + "\t")

输出：

8   19  30  41  52  

1.2 最常见和经典的创建数组方式
val array2 = Array[Int](1, 3, 5, 7, 9)，直接通过Array类名，并传入参数的方式来创建数组实例,在背后的实现是调用Array的工厂方法模式apply来构建出数组以及数组的内容。

/* 等价于 val array2 = Array.apply(1, 3, 5, 7, 9)，
同时也可以直接写成val array2 = Array(1, 3, 5, 7, 9)(去掉[Int]泛型类型)，
原因是scala有推倒类型的能力，已经传入当前数组array的值，所以可以根据值来推倒类型。*/
val array2 = Array[Int](1, 3, 5, 7, 9)
for(i <- 0.to(array2.length - 1)) println("array2(" + i + ") = "  + array2(i) )

输出：

array2(0) = 1
array2(1) = 3
array2(2) = 5
array2(3) = 7
array2(4) = 9

1.3 Array在底层的实现是借助了jvm平台上的java语言的数组的实现，java中数组是不可变的，所以Scala的Array也是不可变的！

2、可变数组的使用

2.1 定义可变数组ArrayBuffer
需要导入scala.collection.mutable.ArrayBuffer

   // 使用可变数组
   import scala.collection.mutable.ArrayBuffer
   val arrayBuffer = ArrayBuffer[Int]()
   // 使用for进行循环赋值
   for(i <- 2.to(10)) arrayBuffer  += (i * 5 -10)

2.2 ArrayBuffer常用方法

2.2.1 直接单个或者多个元素

// 直接赋值
   arrayBuffer += (33, 44, 55, 66)
// 在数组头增加元素
   arrayBuffer.+=:(99999999)

2.2.2 将数组增加大可变数组中

// 将某个数组添加到arrayBuffer中
   arrayBuffer ++= Array(111, 222, 333)
// 将某个数组添加到arrayBuffer的头部
   arrayBuffer.++=:(Array(66666, 77777))

2.2.3 在指定位置插入数组

// 在指定位置插入元素
   arrayBuffer.insert(3, 999, 9999)

输出数组

for(each_item <- arrayBuffer) print(each_item + "\t")
println()

66666   77777   99999999    999 9999    0   5   10  15  20  25  30  35  40  33  44  55  66  111 222 333

2.2.4 删除元素

 // 删除指定位置元素
   println("删除了下标为2的元素： " + arrayBuffer.remove(2))
// 在指定位置删除指定个数元素
   arrayBuffer.remove(5, 3)
   for(each_item <- arrayBuffer) {print(each_item + "\t")}

输出：

删除了下标为2的元素： 99999999
// arrayBuffer.remove(2)删除元素的同时返回被删除元素的值
66666   77777   999 9999    0   20  25  30  35  40  33  44  55  66  111 222 333

2.2.5 同时可以将可变数组转换为不可变数组赋值给其他数组

// 将ArrayBuffer变为Array不可变数组
val array4 = arrayBuffer.toArray
println(array4.mkString(","))

输出：

66666,77777,999,9999,0,20,25,30,35,40,33,44,55,66,111,222,333

2.2.6 使用下标打印，同时可以指定步长，倒叙打印

// 使用下标打印
for(i <- 0 until arrayBuffer.length) print(arrayBuffer(i) + "  ")
println()
// 同时可以指定步长
for(i <- 0 until (arrayBuffer.length, 2)) print(arrayBuffer(i) + "  ")
println()
// 倒序打印
for(i <- (0 until (arrayBuffer.length, 2)).reverse) print(arrayBuffer(i) + "  ")
println()

输出：

66666  77777  999  9999  0  20  25  30  35  40  33  44  55  66  111  222  333  
66666  999  0  25  35  33  55  111  333  
333  111  55  33  35  25  0  999  66666

2.2.7 数组的最大值、最小值、求和

// 数组元素求和， 最大值， 最小值
   println("sum of arrayBuffer: " + arrayBuffer.sum)
   println("max of arrayBuffer: " + arrayBuffer.max)
   println("min of arrayBuffer: " + arrayBuffer.min)

输出：

sum of arrayBuffer: 156455
max of arrayBuffer: 77777
min of arrayBuffer: 0

2.2.8 排序

 // 排序，但无返回值，会改变原有数组的值
   scala.util.Sorting.quickSort(array)
   // 同时可以是用分隔符打印
   println(array.mkString(","))

输出：

8,19,30,41,52

2.2.9 yield、filter、map在数组中使用

// 使用yield构造一个ArrayBuffer中偶数集合
   val array5 = for(each_item <- arrayBuffer if each_item % 2 == 0) yield each_item
   println(array5.mkString(","))

   // 使用过滤函数过滤出偶数
   println(arrayBuffer.filter(x => x % 2 == 0).mkString("**"))
   println(arrayBuffer.filter{x => x % 2 == 0}.mkString("  "))
   // 同时对每个元素做操作
   println(arrayBuffer.filter{x => x % 2 == 0}.map( x => x + 2).mkString("++"))
   // 对每个元素都有操作，所以可以进行省略，如下：
   println(arrayBuffer.filter{ _ % 2 == 0}.map( _ + 2).mkString("~~"))

输出：

66666,0,20,30,40,44,66,222
66666**0**20**30**40**44**66**222
66666  0  20  30  40  44  66  222
66668++2++22++32++42++46++68++224
66668~~2~~22~~32~~42~~46~~68~~224