Scala陣列函式總結以及案例
阿新 • • 發佈：2020-12-19
函式大全
- 一、元素操作
- 二、元素取頭尾
- 三、陣列中的計算
- 四、字串相關操作
- 五、方法操作
- 六、指定條件判斷
- 七、下標索引操作
- 八、陣列拆分排序
- 九、陣列長度
- 十、兩陣列操作
- 十一、陣列克隆和複製
- 十二、陣列反轉
- 十三、陣列的行列操作
- 十四、型別轉換
一、元素操作
1、+:
- 定義：def +:(elem: A): Array[A]
- 描述：在陣列前面新增一個元素，並返回新的陣列物件，冒號的方向指向陣列
示例：
var a1=Array.range(1,5)
a1.foreach(x=>print(x+"\t"))
println()
(12 +: a1).foreach(x=>print(x+"\t"))
2、:+
- 定義：def :+(elem: A): Array[A]
- 描述：在陣列後面新增一個元素，並返回新的陣列物件，冒號的方向指向陣列
示例：
var a2 = Array("a","b","c")
a2.foreach(x=>print(x+"\t"))
println()
(a2 :+ 13).foreach(x=>print(x+"\t"))
3、combinations
- 定義：def combinations(n: Int): collection.Iterator[Array[T]]
- 描述：選出n個元素進行排列組合，不考慮順序，並去重
示例：
var a1=Array.range(1,5)
a1.foreach(x=>print(x+"\t"))
println()
a1.combinations(3).foreach(x=>println(x.mkString("-")))
4、distinct
- 定義：def distinct: Array[T]
- 描述：去除當前集合中重複的元素
示例：
var a2 = Array(1,1,2)
a2.foreach(x=>print(x+"\t"))
println()
a2.distinct.foreach(x=>print(x+"\t"))
5、drop
- 定義：def drop(n: Int): Array[T]
- 描述：刪掉前n個元素，返回一個新陣列
示例：
刪除前n個元素
var a2 = Array(1,1,2)
a2.foreach(x=>print(x+"\t"))
println()
a2.drop(2).foreach(println)
6、dropRight
- 定義：def dropRight(n: Int): Array[T]
- 描述：刪掉後n個元素，返回一個新陣列
示例：
刪除後n個元素
var a1=Array.range(1,5)
a1.foreach(x=>print(x+"\t"))
println()
a1.dropRight(3).foreach(x=>print(x+"\t"))
7、dropWhile
- 定義：
- 描述：從第一個符合的元素開始刪除滿足條件的元素，若第一個元素就不符合條件則不做任何刪除操作
示例：
var a1=Array.range(1,5)
a1.foreach(x=>print(x+"\t"))
println()
a1.dropWhile(x=>x<3&&x>1).foreach(x=>print(x+"\t"))
println()
a1.dropWhile(x=>x<3&&x>=1).foreach(x=>print(x+"\t"))
8、
- 定義：
- 描述：
示例：
9、
- 定義：
- 描述：
示例：
10、
- 定義：
- 描述：
示例：
11、
- 定義：
- 描述：
示例：
12、
- 定義：
- 描述：
示例：
13、
- 定義：
- 描述：
示例：
14、
- 定義：
- 描述：
示例：
15、
- 定義：
- 描述：
示例：
16、
- 定義：
- 描述：
示例：
17、
- 定義：
- 描述：
示例：
18、
- 定義：
- 描述：
示例：
二、元素取頭尾
1、
- 定義：
- 描述：
示例：
2、
- 定義：
- 描述：
示例：
3、
- 定義：
- 描述：
示例：
4、
- 定義：
- 描述：
示例：
5、
- 定義：
- 描述：
示例：
6、
- 定義：
- 描述：
示例：
7、
- 定義：
- 描述：
示例：
8、
- 定義：
- 描述：
示例：
9、
- 定義：
- 描述：
示例：
10、
- 定義：
- 描述：
示例：
11、
- 定義：
- 描述：
示例：
三、陣列中的計算
1、/:、:\
- 定義：def /:[B](z: B)(op: (B, T) ⇒ B): B ， def :[B](z: B)(op: (T, B) ⇒ B): B
- 描述：對陣列中所有的元素從左向右、從右向左遍歷，進行相同的迭代操作，分別為foldLeft 和foldRight 的簡寫
示例：
var a2 = Array(1,1,2)
a2.foreach(x=>print(x+"\t"))
println()
val add = (x:Int,y:Int)=>{
var z=x+y
println(s"$x+$y=$z")
z
}
println(a2./:(0)(add))
println(a2.:\(0)(add))
2、fold
- 定義：def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1ClassTag[U]): Array[U]
- 描述：對序列中的每個元素進行二元運算，和 aggregate 有類似的語義，但執行過程有所不同
示例：
aggregate的簡化版
var a2 = Array(1,1,2)
a2.foreach(x=>print(x+"\t"))
println()
val add = (x:Int,y:Int)=>{
var z=x+y
println(s"$x+$y=$z")
z
}
println(a2.fold(0)(add))
3、foldRight
- 定義：foldRight[B](z: B)(op: (B, T) ⇒ B): B
- 描述：從右到左計算
示例：
var a2 = Array(1,1,2)
a2.foreach(x=>print(x+"\t"))
println()
val add = (x:Int,y:Int)=>{
var z=x+y
println(s"$x+$y=$z")
z
}
println(a2.foldRight(0)(add))
4、foldLeft
- 定義：def foldLeft[B](z: B)(op: (B, T) ⇒ B): BClassTag[U]): Array[U]
- 描述：從左到右計算
示例：
var a2 = Array(1,1,2)
a2.foreach(x=>print(x+"\t"))
println()
val add = (x:Int,y:Int)=>{
var z=x+y
println(s"$x+$y=$z")
z
}
println("我是fold")
println(a2.fold(0)(add))
println("我是foldRight")
println(a2.foldRight(0)(add))
println("我是foldLeft")
println(a2.foldLeft(0)(add))
5、
- 定義：
- 描述：
示例：
6、
- 定義：
- 描述：
示例：
7、
- 定義：
- 描述：
示例：
8、
- 定義：
- 描述：
示例：
9、
- 定義：
- 描述：
示例：
10、
- 定義：
- 描述：
示例：
11、
- 定義：
- 描述：
示例：
12、
- 定義：
- 描述：
示例：
13、
- 定義：
- 描述：
示例：
14、
- 定義：
- 描述：
示例：
15、
- 定義：
- 描述：
示例：
16、
- 定義：
- 描述：
示例：
四、字串相關操作
1、addString
- 定義：def addString(b: StringBuilder): StringBuilder | def addString(b: StringBuilder, sep: String): StringBuilder | def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
- 描述：將陣列中的元素逐個新增到 StringBuilder 中 | 每個元素用 sep 分隔符分開 | 在首尾各加一個字串，並指定sep分隔符
示例：
var a2 = Array(1,1,2)
a2.foreach(x=>print(x+"\t"))
println()
var a1=Array.range(1,5)
a1.foreach(x=>print(x+"\t"))
println()
var builder = new StringBuilder
a2.addString(builder," - ")
println(builder)
a1.addString(builder,"[",",","]")
println(builder)
var builder2 = new StringBuilder
println(a1.addString(builder2, "^"): StringBuilder)
2、mkString
- 定義：def mkString(start: String, sep: String, end: String): String
- 描述：將序列中所有元素拼接成一個字串，以 start 開頭，以 sep 作為元素間的分隔符，以 end 結尾
示例：
var a2 = Array(1,1,2)
a2.foreach(x=>print(x+"\t"))
println()
var a1=Array.range(1,5)
a1.foreach(x=>print(x+"\t"))
println()
println(a1.mkString("[", "-", "]"))
var lst = new ArrayBuffer[Int]
for (elem <- 1 to 5) {
lst.append(Random.nextInt(100))
}
println(lst.mkString(")"))
3、
五、方法操作
1、aggregate
- 定義：def aggregate[B](z : => B)(seqop : scala.Function2[B, A, B], combop : scala.Function2[B, B, B]) : B = { /* compiled code */ }
- 描述：aggregate是柯里化方法（將原來接受兩個引數的函式變成新的接受一個引數的函式的過程。新的函式返回一個以原有第二個引數為引數的函式）， aggregate 方法是一個聚合函式，接受多個輸入，並按照一定的規則運算以後輸出一個結果值
示例：
聚合
val add = (x:Int,y:Int)=>{
var z=x+y
println(s"$x+$y=$z")
z
}
var lst = new ArrayBuffer[Int]
for (elem <- 1 to 5) {
lst.append(Random.nextInt(100))
}
println(lst.par.aggregate(0)(add, add))
2、andThen
- 定義：override def andThen[C](k : scala.Function1[B, C]) : scala.PartialFunction[A, C] = { /* compiled code */ }
- 描述：表示方法的連續呼叫，相當於巢狀函式 a(b(x)(需要滿足第一個函式的返回值型別為第二個函式的輸入值型別)，與 compose 相反
示例：
返回的結果是個偏函式，
var a1=Array.range(1,5)
a1.foreach(x=>print(x+"\t"))
println()
println(a1.andThen(x => {
if (x % 3 == 0) {
"match"
}
})(1))
println(a1.andThen(x => {
if (x % 3 == 0) Some(x)
else None
})(2))
def add(x:Int):Int=x*2
def mul(x:Int):Int=2+x
def rst1 = add _ andThen (mul)
def rst2 = add _ andThen mul _
println(rst1(3))
println(rst2(3))
3、compose
- 定義：def compose[A](g : scala.Function1[A, T1]) : scala.Function1[A, R] = { /* compiled code */ }
- 描述：表示方法的連續呼叫，與 andThen 相反
示例：
def add(x:Int):Int=x*2
def mul(x:Int):Int=2+x
def rst1 = add _ compose(mul)
def rst2 = add _ compose mul _
println(rst1(3))
println(rst2(3))
4、applyOrElse
- 定義：def applyOrElse[A1 <: A, B1 >: B](x : A1, default : scala.Function1[A1, B1]) : B1 = { /* compiled code */ }
- 描述：如果第一個呼叫的引數能匹配，返回匹配的值，否則呼叫引數二的回撥函式。
示例：
var a1=Array.range(1,5)
a1.foreach(x=>print(x+"\t"))
println()
println(a1.applyOrElse(10, { i: Int => 200 }))
println(a1.applyOrElse(3, { i: Int => 200 }))
5、collect
- 定義：def collect[B](pf: PartialFunction[A, B]): Array[B]
- 描述：通過執行一個平行計算（偏函式），得到一個新的陣列物件
示例：
var a1=Array.range(1,5)
a1.foreach(x=>print(x+"\t"))
println()
a1.collect({ case i if i % 2 == 0 => i }).foreach(x=>{print(x+"\t")})
6、collectFirst
- 定義：def collectFirst[B](pf: PartialFunction[T, B]): Option[B]
- 描述：查詢第一個符合偏函式定義的元素，並執行偏函式計算，返回值是元組
示例：
var a1=Array.range(1,5)
a1.foreach(x=>print(x+"\t"))
println()
println(a1.collectFirst({ case i if i % 2 == 0 => i }))
7、foreach
- 定義：def foreach(f: (A) ⇒ Unit): Unit
- 描述：遍歷序列中的元素，進行f的操作
示例：
其他案例的輸出基本上都是foreach
8、
- 定義：
- 描述：
示例：
9、
- 定義：
- 描述：
示例：
10、
- 定義：
- 描述：
示例：
六、指定條件判斷
1、contains
- 定義：def contains[A1 >: A](elem: A1): Boolean
- 描述：判斷序列中是否包含指定物件
示例：
var a1=Array.range(1,5)
a1.foreach(x=>print(x+"\t"))
println()
println(a1.contains(5))
println(a1.contains(3))
2、containsSlice
- 定義：def containsSlice[B](that: GenSeq[B]): Boolean
- 描述：判斷當前序列中是否包含另一個序列(數量和順序相等)，是否包含子序列
示例：
var a1=Array.range(1,5)
a1.foreach(x=>print(x+"\t"))
println()
println(a1.containsSlice(Array(1,2)))
println(a1.containsSlice(Array(1,3)))
3、count
- 定義：def count(p: (T) ⇒ Boolean): Int
- 描述：統計符合條件的元素個數
示例：
var a1=Array.range(1,5)
a1.foreach(x=>print(x+"\t"))
println()
println(a1.count(_ !=0))
println(a1.count(_ > 1))
println(a1.count(x => x > 3 && x < 9))
4、charAt
- 定義：def charAt(index: Int): Char
- 描述：獲取 index 索引處的字元，這個方法會執行一個隱式的轉換，將 Array[T] 轉換為 ArrayCharSequence，只有當 T 為 Char 型別時，這個轉換才會發生
示例：
var a3 = Array('a','b','c','d')
a3.foreach(x=>print(x+"\t"))
println()
println(a3.charAt(2))
println(a3.charAt(3))
5、
- 定義：
- 描述：
示例：
6、
- 定義：
- 描述：
示例：
7、
- 定義：
- 描述：
示例：
8、
- 定義：
- 描述：
示例：
9、
- 定義：
- 描述：
示例：
10、
- 定義：
- 描述：
示例：
11、
- 定義：
- 描述：
示例：
12、
- 定義：
- 描述：
示例：
13、
- 定義：
- 描述：
示例：
14、
- 定義：
- 描述：
示例：
15、
- 定義：
- 描述：
示例：
16、
- 定義：
- 描述：
示例：
七、下標索引操作
1、apply
- 定義：def apply(i: Int): T
- 描述：獲取指定索引處的元素
示例：
var a1=Array.range(1,5)
a1.foreach(x=>print(x+"\t"))
println()
println(a1.apply(0))
println(a1.apply(1))
println(a1.apply(3))
2、
- 定義：
- 描述：
示例：
3、
- 定義：
- 描述：
示例：
4、
- 定義：
- 描述：
示例：
5、
- 定義：
- 描述：
示例：
6、
- 定義：
- 描述：
示例：
7、
- 定義：
- 描述：
示例：
8、
- 定義：
- 描述：
示例：
9、
- 定義：
- 描述：
示例：
10、
- 定義：
- 描述：
示例：
11、
- 定義：
- 描述：
示例：
12、
- 定義：
- 描述：
示例：
八、陣列拆分排序
1、
- 定義：
- 描述：
示例：
2、
- 定義：
- 描述：
示例：
3、par
- 定義：def par: ParArray[T]
- 描述：返回一個並行實現，產生的並行序列不能被修改，其作用相當於hashcode進行分割槽
示例：
var lst = new ArrayBuffer[Int]
for (elem <- 1 to 5) {
lst.append(Random.nextInt(100))
}
lst.foreach(x=>print(x+"\t"))
println()
println(lst.par)
4、
- 定義：
- 描述：
示例：
5、
- 定義：
- 描述：
示例：
6、
- 定義：
- 描述：
示例：
7、
- 定義：
- 描述：
示例：
8、
- 定義：
- 描述：
示例：
9、
- 定義：
- 描述：
示例：
10、
- 定義：
- 描述：
示例：
九、陣列長度
1、
- 定義：
- 描述：
示例：
2、
- 定義：
- 描述：
示例：
3、
- 定義：
- 描述：
示例：
4、
- 定義：
- 描述：
示例：
十、兩陣列操作
1、++
- 定義：def ++[B](that: GenTraversableOnce[B]): Array[B]
- 描述：合併兩個集合，新陣列包含左右兩個集合的內容，如果兩個陣列型別不同，合同之後的型別為Array[Any]，類似Java裡的Object型別
示例：
var a1=Array.range(1,5)
var a2 = Array("a","b","c")
a1.foreach(x=>print(x+"\t"))
println()
a2.foreach(x=>print(x+"\t"))
println()
println("----++---------------")
//++合併
(a1++a2).foreach(x=>print(x+"\t"))
2、++:
- 定義：def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Array[T], B, That]): That
- 描述：也是兩個陣列組合起來，冒號旁邊的型別決定生成新陣列的資料型別
示例：
var a1=Array.range(1,5)
var a2 = Array(1.0,1,2)
a1.foreach(x=>print(x+"\t"))
println()
a2.foreach(x=>print(x+"\t"))
println()
(a1++:a2).foreach(x=>print(x+"\t"))//x為double型別
3、canEqual
- 定義：def canEqual(that: Any): Boolean
- 描述：判斷兩個物件陣列是否可以進行比較，基本上都可以比較，應該不常用
示例：
var a1=Array.range(1,5)
a1.foreach(x=>print(x+"\t"))
println()
var a2 = Array("a","b","c")
a2.foreach(x=>print(x+"\t"))
println()
println(a2.canEqual(a1))
4、
- 定義：
- 描述：
示例：
5、
- 定義：
- 描述：
示例：
6、diff
- 定義：def diff(that: collection.Seq[T]): Array[T]
- 描述：計算當前陣列與另一個數組的差集，即將當前陣列中沒有在另一個數組中出現的元素返回
示例：
var a2 = Array(1,1,2)
a2.foreach(x=>print(x+"\t"))
println()
var a1=Array.range(1,5)
a1.foreach(x=>print(x+"\t"))
println()
println("-----diff--------")
//取差集
a1.diff(a2).foreach(println)
println("-----intersect--------")
//取交集
a1.intersect(a2).foreach(println)
7、intersect
- 定義：def intersect(that: collection.Seq[T]): Array[T]
- 描述：返回兩個集合的交集
示例：
var a2 = Array(1,1,2)
a2.foreach(x=>print(x+"\t"))
println()
var a1=Array.range(1,5)
a1.foreach(x=>print(x+"\t"))
println()
println("-----diff--------")
//取差集
a1.diff(a2).foreach(println)
println("-----intersect--------")
//取交集
a1.intersect(a2).foreach(println)
8、sameElements
- 定義：def sameElements(that: GenIterable[A]): Boolean
- 描述：判斷兩個序列是否順序和對應位置上的元素都一樣，值比較
示例：
var a1=Array.range(1,5)
a1.foreach(x=>print(x+"\t"))
println()
var a3 = a1.clone()
println(a1 == a3)
//重寫same方法，比較值
def same(a1:Array[Int],a2:Array[Int]):Boolean={
var same:Boolean=true
if (a1.size!=a2.size) {
same = false
}else{
breakable{
for (elem <- 0 until a1.size) {
if (a1(elem)!=a2(elem)) {
same=false
break()
}
}
}
}
same
}
println(same(a1, a3))
println(a1.sameElements(a3))
十一、陣列克隆和複製
1、clone
- 定義：def clone(): Array[T]
- 描述：建立一個數組的副本，複製陣列的值,但不會引用地址；就是說是淺克隆，不是深克隆。
示例：
var a1=Array.range(1,5)
a1.foreach(x=>print(x+"\t"))
println()
var a3 = a1.clone()
println(a1 == a3)
println(a1.sameElements(a3))
2、copyToArray
- 定義：def copyToArray(xs: Array[A]): Unit | def copyToArray(xs: Array[A], start: Int): Unit | def copyToArray(xs: Array[A], start: Int, len: Int): Unit
- 描述：將當前陣列元素複製到另一個數組中，2-3的引數是待複製的陣列的起始位置和長度
示例：
var lst2= new ArrayBuffer[Int]
for (elem <- 1 to 6) {
lst2.append(Random.nextInt(100))
}
var arr1 = Array(0,0,0,0)
var arr2 = Array(0,0,0,0)
var arr3 = Array(0,0,0,0)
var arr4 = Array(0,0,0,0)
lst2.foreach(x=>print(x+"\t"))
println()
lst2.copyToArray(arr1)
lst2.copyToArray(arr2,2)
lst2.copyToArray(arr3,0,2)
lst2.copyToArray(arr4,1,2)
arr1.foreach(x=>print(x+"\t"))
println()
arr2.foreach(x=>print(x+"\t"))
println()
arr3.foreach(x=>print(x+"\t"))
println()
arr4.foreach(x=>print(x+"\t"))
3、copyToBuffer
- 定義：def copyToBuffer[B >: A](dest: Buffer[B]): Unit
- 描述：將陣列中的元素複製到 Buffer 中
示例：
var lst2= new ArrayBuffer[Int]
for (elem <- 1 to 6) {
lst2.append(Random.nextInt(100))
}
lst2.foreach(x=>print(x+"\t"))
println()
var buff = new ArrayBuffer[Int]
println(buff.size)
lst2.copyToBuffer(buff)
println(buff.size)
buff.foreach(x=>print(x+"\t"))
4、
- 定義：
- 描述：
示例：
十二、陣列反轉
1、
- 定義：
- 描述：
示例：
2、
- 定義：
- 描述：
示例：
3、
- 定義：
- 描述：
示例：
十三、陣列的行列操作
1、
- 定義：
- 描述：
示例：
2、
- 定義：
- 描述：
示例：
3、
- 定義：
- 描述：
示例：
4、
- 定義：
- 描述：
示例：
5、
- 定義：
- 描述：
示例：
6、
- 定義：
- 描述：
示例：
7、
- 定義：
- 描述：
示例：
8、
- 定義：
- 描述：
示例：
十四、型別轉換
1、
- 定義：
- 描述：
示例：
2、
- 定義：
- 描述：
示例：
3、
- 定義：
- 描述：
示例：
4、
- 定義：
- 描述：
示例：
5、
- 定義：
- 描述：
示例：
6、
- 定義：
- 描述：
示例：
7、
- 定義：
- 描述：
示例：
8、
- 定義：
- 描述：
示例：
9、
- 定義：
- 描述：
示例：
10、
- 定義：
- 描述：
示例：
11、
- 定義：
- 描述：
示例：