Scala数组
数组
Scala中数组方法：
以下是重要的方法，可以同时使用数组。如上所示，则必须使用任何提及的方法之前，要导入Array._包。有关可用方法的完整列表，请Scala中的官方文件。
| SN | 方法及描述 |
|---|---|
| 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的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] 返回一个包含一个函数的重复应用到初始值的数组。 |
| 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 iterate[T]( start: T, len: Int)( f: (T) => T ): Array[T] 返回一个包含一个函数的重复应用到初始值的数组。 |
| 9 | def ofDim[T]( n1: Int ): Array[T] 创建数组给出的尺寸。 |
| 10 | def ofDim[T]( n1: Int, n2: Int ): Array[Array[T]] 创建了一个2维数组 |
| 11 | def ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]] 创建3维数组 |
| 12 | def range( start: Int, end: Int, step: Int ): Array[Int] 返回包含一些整数间隔等间隔值的数组。 |
| 13 | def range( start: Int, end: Int ): Array[Int] 返回包含的范围内增加整数序列的数组。 |
| 14 | def tabulate[T]( n: Int )(f: (Int)=> T): Array[T] 返回包含一个给定的函数的值超过从0开始的范围内的整数值的数组。 |
| 15 | def tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]] 返回一个包含给定函数的值超过整数值从0开始范围的二维数组。 |
1、定长数组定义：
//定义一个长度为10的数值数组
scala> val numberArray = new Array[int](10)
numberArray:Array[Int] = Array(0,0,0,0,0,0,0,0,0,0)
//定义一个长度为10的String类数组
scala> val strArray = new Array[String](10)
strArray:Array[String] = Array(null, null, null, null, null, null, null, null, null, null)
//由上可以看出，复杂对象类型在数组定义时呗初始化为null，数值型被初始化为0，并且上面复杂类型定义的时候必须加new，否则会报错
//提供初始值的定义数组
scala> val strArray2 = Array("First", "Second") //这里说明已提供初始值就不需要new
strArray2:Array[String] = Array(First, Second)
scala> strArray2(0) = "Goodbye"
strArray2:Array[String] = Array(Goodbye, Second)Array定长数组，访问数组元素需要通过()
val nums = new Array[Int](10) //长度为10的int数组 初始化为0
val strs = new Array[String](10) //长度为10的String数组 初始化为null
val s = Array("Hello", "World") //初始化数组长度为2，不需要new
s(0) = "GoodBye" //访问数组元素通过()
println(nums(0))
println(strs(0))
println(s(0)+" "+s(1))结果
0 null GoodBye World
2、变长数组定义 对于长度需要变化的数组，Java有ArrayList,C++有vector。Scala中的等效数据结构为ArrayBuffer
//导入可变包，Scala中的可变集合都是放在mutable中，使用时要导入
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer
scala> val arrayBuffer = ArrayBuffer[Int]()
arrayBuffer: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()
//在尾部添加一个值
scala> arrayBuffer += 1
res17: arrayBuffer.type = ArrayBuffer(1)
//在尾部添加多个元素
scala> arrayBuffer += (2, 3, 4, 5)
res19: arrayBuffer.type = ArrayBuffer(1, 2, 3, 4, 5)
//在尾部添加一个集合
scala> arrayBuffer ++= Array(6, 7, 8, 9)
res20: arrayBuffer.type = ArrayBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9)
//移除最后2个元素
scala> arrayBuffer.trimEnd(2)
//在开头移除1一个元素
scala> arrayBuffer.trimStart(2)
scala> arrayBuffer
res23: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(2, 3, 4, 5, 6, 7)
//在任意位置插入或者删除元素
scala> arrayBuffer.insert(2, 6)
//ArrayBuffer(2, 3, 6, 4, 5, 6, 7)
scala> arrayBuffer.insert(1, 2, 3, 4)
//ArrayBuffer(2, 1, 2, 3, 4, 3, 6, 4, 5, 6, 7)
scala> arrayBuffer.remove(2)
//ArrayBuffer(2, 1, 3, 4, 3, 6, 4, 5, 6, 7)
scala> arrayBuffer.remover(1, 8)
//ArrayBuffer(2, 7)- 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
- 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
//变长转换成定长
scala > arrayBuffer.toArray
//Array(2, 7)
//定长转换成变长
scala>res7.toBuffer
//ArrayBuffer(2, 7)- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 1
- 2
- 3
- 4
- 5
- 6
- 7
for(i <- 0 until.arrayBuffer.length)
println(i + ": " + a(i))
- 1
- 2
- 3
- 1
- 2
- 3
0 until.arrayBuffer.length实际上是一个方法调用，返回的是一个区间Range： 0.until(arrayBuffer.length) for(i
//增强for
for(i <- arrayBuffer)
println(i + ": " + a(i))- 1
- 2
- 3
- 1
- 2
- 3
5、数组转换
可以利用原来的数组产生一个新的数组。
scala> val a = Array(2, 3, 5, 7, 11)
a: Array[Int] = Array(2, 3, 5, 7, 11)
//这里产生了一个新的数组，原来的数组也在
scala> val result = for(elem <- a) yield 2 * elem
result: Array[Int] = Array(4, 6, 10, 14, 22)
- 1
- 2
- 3
- 4
- 5
- 6
- 1
- 2
- 3
- 4
- 5
- 6
如果for中使用的是定长数组，则for(…)…yield之后得到的是定长数组;如果使用的是变长数组，则会得到变长数组
- Scala也提供了另外一种做法
scala> a.filter(_ % 2 == 0).map(2 * _)
甚至
scala>a.filter(_ % 2 == 0).map{2 * _}- 1
- 2
- 3
- 4
- 1
- 2
- 3
- 4
例子：
给定一个整数的缓冲数组，我们想要移除第一个负数之外的所有负数。有几种做法
//第一种做法：
var first = true
var n = a.length
var i = 0
while(i < n){
if(a(i) > 0) i += 1
else{
if(first) {first = false; i += 1}
else {a.remove(i); n-= 1}
}
}
//第二种做法：
//首先使用一个新数组用于记录满足条件的数组的下标
val first = true
val indexes = for(i <- 0 until a.length if first || a(i) > 0) yield {
if(a(i) < 0) first = false; i
}
//然后将元素移动到该去的位置，截断尾端
for(j <- o until indexes.length) a(j) = a(indexes(j))
a.trimEnd(a.length-indexes.length)- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
6、常用算法
Scala针对数组提供了一个常用的函数
//定义一个整型数组
scala> val intArr=Array(1,2,3,4,5,6,7,8,9,10)
intArr: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
//求和
scala> intArr.sum
res87: Int = 55
//求最大值
scala> intArr.max
res88: Int = 10
scala> ArrayBuffer("Hello","Hell","Hey","Happy").max
res90: String = Hey
//求最小值
scala> intArr.min
res89: Int = 1
//排序
//sorted方法将数组或数组缓冲排序并返回经过排序的数组或数组缓冲，原始数组被保留
scala>val b = ArrayBuffer(1, 7, 2, 9)
b:ArrayBuffer[Int] = ArrayBuffer(1, 7, 2, 9)
scala>val bSorted = b.sorted(_<_)
bSorted: ArrayBuffer[Int] = ArrayBuffer(1, 2, 7, 9)
//toString()方法
scala> intArr.toString()
res94: String = [I@141aba8
//mkString()方法
scala> intArr.mkString(",")
res96: String = 1,2,3,4,5,6,7,8,9,10
scala> intArr.mkString("<",",",">")
res97: String = <1,2,3,4,5,6,7,8,9,10>- 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
- 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
7、ArrayBuffer Scaladoc解析
初学者在查看sacaladoc时常常会感到困惑，不用担心，随着学习的深入，api文档中的内容将逐渐清晰
下面给出两个示例：
++=方法传入的参数类型是TraversableOnce Trait的子类，它返回的是更新好的ArrayBuffer
dropWhile传入的是一个函数，该函数返回值是布尔类型，dropWhile反回的是操作后的ArrayBuffer
8、多维数组
和Java一样，多维数组是通过数组的数组来实现的。
//第一种构造方式
val metrix = Array.ofDim[Double](3, 4) //3行 4列
//访问其中的元素
metrix(row)(column) =42
//可以创建不规则的数组，每一行的长度不相同
val triangle = new Array[Array[Int]](10)
for(i <- 0 until triangle.length)
trianglr(i) = new Array[Int](i+1)
//在创建的时候赋值
scala> val metrix = Array(Array(1, 2, 3), Array(2.3, 3.4), Array("asdf", "asdfas"))
metrix: Array[Array[_ >: String with Double with Int]] = Array(Array(1, 2, 3), Array(2.3, 3.4), Arra
y(asdf, asdfas))
//打印输出数组
scala> for(i <- metrix) println(i.mkString(" "))
1 2 3
2.3 3.4
asdf asdfas
//输出二维数组的每个值
scala> for(i <- metrix; from = i; j <- from) println(j)
1
2
3
2.3
3.4
asdf
asdfas
声明：该文观点仅代表作者本人，入门客AI创业平台信息发布平台仅提供信息存储空间服务，如有疑问请联系rumenke@qq.com。
- 上一篇： 子数组最大乘积
- 下一篇：没有了
