Step into Scala - 08 - 数组

目录

摘要

创建数组，创建空数组，访问元素，创建数组缓冲，修改数组缓冲（高效/非高效方式），数组和数组缓冲的转换，遍历，指定步长，反向遍历，sortWith，mkString，distinct，多维数组

数组

定长数组

创建

指定长度

val a = new Array[Int](10)

指定内容

val s = Array("Hello", "World")

Array 在 jvm 中实际是以 int[]，String[] 等形式进行保存的。

访问元素

使用 () 而不是 []

s(0) = "Good bye"

变长数组 : 数组缓冲 （ArrayBuffer）

创建

使用 apply

val b = ArrayBuffer[Int]()

或

val c = new ArrayBuffer[Int]

修改元素

b += 1
b +=(2, 3, 4)
b.trimEnd(2)        //删除最后2个元素
b ++= Array(4, 5, 6)
println(b)          //ArrayBuffer(1, 2, 4, 5, 6)

在数组缓存尾端添加和删除元素是高效的，也可以在任意位置进行修改，但是效率就不那么高效了。

b.insert(2, 6)
b.insert(2, 6, 7, 8)
b.remove(3)
b.remove(3, 4)

数组和数组缓冲的转换

数组缓冲到数组

b.toArray

数组到数组缓冲

a.toBuffer

遍历

正向遍历

for (i <- 0 until c.length)

until 实际是 RichInt 的方法，返回小于上限的数字。

或者

for (ele <- c)

指定步长

for (i <- Range(0, c.length, 2))

反向遍历

for (i <- 0 until c.length reverse)

数组转换

概念

数组转换即修改行为本身会产生新的数组，而不是修改原来的数组

for 推导式

val result = for (ele <- c) yield {
  ele * 2
}

filter

var filter = c.filter(_ % 2 == 0)

filter + map

filter = c.filter(_ % 2 == 0).map(2 * _)

或

filter = c.filter {
  _ % 2 == 0
}.map {
  2 * _
}

常用方法

var arr = Array(1, 3, 2, 2)
assert(8 == arr.sum)
assert(3 == arr.max)
assert(1 == arr.min)

不影响原数组

println(arr.sorted.toList) //List(1, 2, 2, 3)
println(arr.sortWith(_ < _).toList) //List(1, 2, 2, 3)
println(Array("abc", "cb", "defg").sortBy(_.size).toList) //List(cb, abc, defg)
println(arr.distinct.toList) //List(1, 3, 2)

println(arr.mkString("-")) //1-3-2-2
println(arr.mkString("<", ",", ">")) //<1,3,2,2>

影响原数组

Sorting.quickSort(arr)
println(arr.toList) //List(1, 2, 2, 3)

quickSort(a) 只能对数组排序，不能对数组缓冲排序。

多维数组

Array.ofDim[Double](3, 4)   //三行四列
new Array[Array[Int]](10)   //不规则数组，可以指定每一行的长度