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//匯入可變包，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
//定義一個整型陣列
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 = [[email protected]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相關推薦
2.Scala陣列
package scala object ArrayTest { def main(args: Array[String]): Unit = { //1.定長陣列Array //一種定長陣列定義方式 //複雜物件型別在陣列定義時被初始化為null，數值型被初始化為0
scala陣列操作之Array、ArrayBuffer以及遍歷陣列
Array 在Scala中，Array代表的含義與Java中類似，也是長度不可改變的陣列。此外，由於Scala與Java都是執行在JVM中，雙方可以互相呼叫，因此Scala陣列的底層實際上是Java陣列。例如字串陣列在底層就是Java的String[]，整數陣
Scala 陣列
//1、定義一個長度為3 的整形陣列，初始化值為0 val aa = new Array[Int](3) //新增元素 aa(0) = 12 aa(1) = 8 aa(2) = 2 //2、定義一個長度為3的字串陣列，初始化值為null val str = new Array[Strin
【圖文詳細 】Scala——Scala 陣列 Array
4、Scala 陣列 Array 4.1、定長陣列和變長陣列 1、由於 Array 是不可變（長度不可變）的，初始化之初就有了固定的長度，所以不能直接 地對其元素進行刪除操作，也不能多增加元素，只能修改某個位置的元素的值，要實現刪除 可以通過過濾生成新的 Arra
Scala 陣列(Array)，列表(List)，元組(Tuple)，集(Set)，對映(Map)，迭代器(Iterator)
1. 陣列(Array) 陣列是程式設計中經常用到的資料結構，一般包括定長陣列和變長陣列。本教程旨在快速掌握最基礎和常用的知識，因此，只介紹定長陣列。 定長陣列，就是長度不變的陣列，在Scala中使用Array進行宣告，如下： val intValue
Scala陣列和集合
一、scala陣列 陣列定義1： var arr = new Array[String](3) String:儲存的元素型別 3:儲存3個元素 新增元素： arr(1) = "hello" 陣列定義2： val arr1 = Array[Int](1,2,3,4
Scala-Unit4-Scala陣列/集合
一、Scala陣列 1.陣列的定義： 方法一：val arr = new Array[String](3) String代表資料的元素型別、3表示陣列的長度 方法二：val arr = Array[Int](1,3,5,7) 修改陣列某元素：arr(1) = 18
Scala陣列
陣列 Scala中陣列方法： 以下是重要的方法，可以同時使用陣列。如上所示，則必須使用任何提及的方法之前，要匯入Array._包。有關可用方法的完整列表，請Scala中的官方檔案。 SN 方法及描述 1 def apply( x: T, xs: T* ): Arr
Scala（八）多維陣列、Java資料與Scala陣列的隱式轉換
多維陣列 ：多維陣列元素還是陣列，陣列套陣列，就是多維陣列 構建一個指定行與列的二維陣列 package com.lyz.six object ManyArrayLearn { def ma
Spark學習(6)——scala陣列操作
Array 在scala中，Array代表的含義與Java類似，也是長度不可變的陣列，此外 由於Java和scala都是執行在JVM中，雙方可以互相呼叫，因此scala的底層 實際上是Java陣列，例如字串的陣列在底層實際上就是Java的 String [] 陣列 整
scala陣列、Scala Collection（集合）、Iterator（迭代器）
一、scala陣列 陣列：用來儲存固定大小的同類型元素，通過索引來訪問指定元素，索引index從0開始 宣告陣列 定義陣列--語法格式： var z:Array[String] = new Array[String](3) 或 var z = new Array[St
Scala多維陣列、Java陣列與Scala陣列的隱式轉換
多維陣列：陣列的元素，還是陣列，陣列套陣列，就是多維陣列 構造指定行與列的二維陣列：Array.ofDim方法 val multiDimArr1 = Array.ofDim[Double](3, 4)
Scala陣列——Array/ArrayBuffer
1.定長陣列-Array //方式一 //長度為5的整數陣列，所有元素初始化為0 val ary1=new Array[Int](5) //長度為5的字串陣列，所有元素初始化為null
scala 陣列Array
scala> //-------------array-------------------- scala> val arr=new Array[Int](5) --arr的index不可變，值可以變 arr: Array[Int] = A
Scala 陣列
Scala提供了一種資料結構叫作陣列，陣列是一種儲存了相同型別元素的固定大小順序集合。陣列用於儲存資料集合，但將陣列視為相同型別變數的集合通常更為有用。 可以宣告一個數組變數，例如:numbers，使用numbers[0]，numbers[1]和...，numbers[99
Scala陣列操作
陣列基本操作 （1） val s=Array("Hello","World") s(0)="Goodbye" for(elem <- s)println(elem) 在Scala Worksheet裡面的執行結果： s: Array[Str
Scala-陣列的使用
轉載來源：http://www.cnblogs.com/miqi1992/p/5614024.html 本篇知識點概括 若長度固定則使用Array,若長度可能有 變化則使用ArrayBuffer提供初始值時不要使用new,複雜物件陣列沒有提供初始值時必須提供new用(
scala 陣列ArrayBuffer
scala> import scala.collection.mutable.ArrayBuffer import scala.collection.mutable.ArrayBuffer scala> val arrBuffer=ArrayBuffer[In
Scala陣列，定長陣列和變長陣列，增強for迴圈，until用法，陣列轉換，陣列常用演算法，陣列其它操作
1． 陣列 1.1． 定長陣列和變長陣列 package cn.toto.scala //可變陣列的長度時需要引入這個包 import scala.collection.mutable.A
scala 陣列匹配相同元素
接下來的操作大家都熟知：差集、交集和並集。以下示例能很好地解釋 Euler Diagram 函式：val num1 = Seq(1, 2, 3, 4, 5, 6)val num2 = Seq(4, 5, 6, 7, 8, 9)//List(1, 2, 3)num1.diff(