函数大全
- 一、元素操作
- 二、元素取头尾
- 三、数组中的计算
- 四、字符串相关操作
- 五、方法操作
- 六、指定条件判断
- 七、下标索引操作
- 1、apply
- 2、charAt
- 3、indexOf(elem)、indexOf(elem, from)
- 5、indexOfSlice(that)、indexOfSlice(that, from)
- 7、indexWhere(p)、indexWhere(p, from)
- 9、lastIndexOf(elem: T)、lastIndexOf(elem: T, end: Int)
- 11、lastIndexOfSlice(that)、lastIndexOfSlice(that, end)
- 14、lastIndexWhere(p)、lastIndexWhere(p, end)
- 15、indices
- 16、slice
- 17、subSequence
- 18、view
- 八、数组拆分排序
- 九、数组长度
- 十、两数组操作
- 十一、数组克隆和复制
- 十二、数组反转
- 十三、数组的行列操作
- 十四、类型转换
一、元素操作
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、max
- 定义:def max: A
- 描述:返回序列中最大的元素
示例:
array2.foreach(x=>print(x+"\t"));println()
println(array2.max)
9、min
- 定义:def min: A
- 描述:返回序列中最小的元素
示例:
array2.foreach(x=>print(x+"\t"));println()
println(array2.min)
10、maxBy
- 定义:def maxBy[B](f: (A) ⇒ B): A
- 描述:返回序列中符合条件的第一个元素
示例:
b1.foreach(x=>print(x+"\t"));println()
println(b1.maxBy(_ > 1))
11、minBy
- 定义:def minBy[B](f: (A) ⇒ B): A
- 描述:返回序列中不符合条件的第一个元素
示例:
b1.foreach(x=>print(x+"\t"));println()
println(b1.minBy(_ < 6))
12、padTo
- 定义:def padTo(len: Int, elem: A): Array[A]
- 描述:填充序列,如果当前序列长度小于 len,那么新产生的序列长度是 len,多出的几个位值填充 elem,如果当前序列大于等于 len ,则返回当前序列
示例:
b1.foreach(x=>print(x+"\t"));println()
b1.padTo(20,"-").foreach(x=>print(x+"\t"))
b1.padTo(4,"-").foreach(x=>print(x+"\t"))
13、patch
- 定义:def patch(from: Int, that: GenSeq[A], replaced: Int): Array[A]
- 描述:批量替换,从原序列的 from 处开始,后面的 replaced 个元素,将被替换成序列 that;如果替换的为空集合或双引号,则为删除操作
示例:
b1.foreach(x => print(x + "\t"));println()
var i: Array[Int] = Array() //空集合会报错,用这种形式
b1.patch(0, Array(12, 13, 14), 3).foreach(x => print(x + "\t"));println()
b1.patch(2, Array(12, 13, 14), 2).foreach(x => print(x + "\t"));println()
b1.patch(3, i, 1).foreach(x => print(x + "\t"));println()
b1.patch(3, i, 2).foreach(x => print(x + "\t"));println()
b1.patch(3, "", 2).foreach(x => print(x + "\t"));println()
14、permutations
- 定义:def permutations: collection.Iterator[Array[T]]
- 描述:permutations 表示排列,这个排列组合会选出所有排列顺序不同的字符组合,permutations 与 combinations 不同的是,相同的组合考虑排列,对于 “abc”、“cba”,视为不同的组合
示例:
a1.foreach(x=>print(x+"\t"));println()
a1.permutations.foreach(x => {
println(x.mkString(":", "*", ":"))
})
15、prefixLength
- 定义:def prefixLength(p: (T) ⇒ Boolean): Int
- 描述:由第一个索引开始,返回序列中满足条件p的元素数量,直到有不满足的则结束
示例:
b3.foreach(x=>print(x+"\t"));println()
println(b3.prefixLength(_ < 5))
println(b3.prefixLength(_ > 5))
16、transform
- 定义:def transform(f: Int => Int): scala.collection.mutable.WrappedArray[Int]
- 描述:将序列中的元素转换成指定的元素(同类型),原数组会被改变
示例:
b7.foreach(x => print(x + "\t"));println()
b7.sorted.transform(Math.pow(_,2).toInt).foreach(x => print(x + "\t"));println()
17、update
- 定义:def update(i: Int, x: T): Unit
- 描述:将序列中 i 索引处的元素更新为 x,改变原数组,返回更改后的新数组
示例:
b7.foreach(x => print(x + "\t"));println()
b7.update(3,20)
b7.foreach(x => print(x + "\t"));println()
18、updated
- 定义:def updated(index: Int, elem: A): Array[A]
- 描述:将序列中 i 索引处的元素更新为 x,不改变原数组
示例:
b7.foreach(x => print(x + "\t"));println()
b7.updated(3,40).foreach(x => print(x + "\t"));println()
b7.foreach(x => print(x + "\t"));println()
二、元素取头尾
1、head
- 定义:def head: T
- 描述:返回序列的第一个元素,如果序列为空,将引发错误
示例:
b1.foreach(x=>print(x+"\t"));println()
println(b1.head)
2、headOption
- 定义:def headOption: Option[T]
- 描述:返回序列的第一个元素的 Option 类型对象,如果序列为空,则返回 None
示例:
b1.foreach(x=>print(x+"\t"));println()
var b0:Array[Int] = Array()
println(b1.headOption)
println(b0.headOption)
3、last
- 定义:def last: T
- 描述:返回序列的最后一个元素,如果序列为空,将引发错误
示例:
b1.foreach(x=>print(x+"\t"));println()
println(b1.last)
4、lastOption
- 定义:def lastOption: Option[T]
- 描述:返回序列的最后一个元素的 Option 类型对象,如果序列为空,则返回 None
示例:
b1.foreach(x=>print(x+"\t"));println()
var b0:Array[Int] = Array()
println(b0.lastOption)
println(b1.lastOption)
5、tail
- 定义:def tail: Array[T]
- 描述:返回当前序列中不包含第一个元素的序列,除了头都是尾
示例:
b1.foreach(x=>print(x+"\t"));println()
b1.tail.foreach(x=>print(x+"\t"));println()
6、tails
- 定义:def tails: collection.Iterator[Array[T]]
- 描述:和inits类似,只不过每一步都是取尾部进行 tail 操作
示例:
b1.foreach(x=>print(x+"\t"));println()
b1.tails.foreach(x=>{x.foreach(y=>print(s"$y,"));println()})
7、init
- 定义:def init: Array[T]返回当前序列中不包含最后一个元素的序列
- 描述:返回当前序列中不包含最后一个元素的序列
示例:
b1.foreach(x=>print(x+"\t"));println()
b1.init.foreach(x=>print(x+"\t"));println()
8、inits
- 定义:def inits: collection.Iterator[Array[T]]
- 描述:对集合中的元素进行 init 迭代操作,该操作的返回值中, 第一个值是当前序列的副本,最后一个值为空,每一步都进行 init 操作,上一步的结果作为下一步的操作对象;返回一个二维数组
示例:
b1.foreach(x=>print(x+"\t"));println()
b1.inits.foreach(x=>{x.foreach(y=>print(s"$y,"));println()})
9、take
- 定义:def take(n: Int): Array[T]
- 描述:返回当前序列中,前 n 个元素组成的序列
示例:
b1.foreach(x => print(x + "\t"));println()
b1.take(3).foreach(x => print(x + "\t"));println()
10、takeRight
- 定义:def takeRight(n: Int): Array[T]
- 描述:返回当前序列中,从右边开始,后 n 个元素组成的序列
示例:
b1.foreach(x => print(x + "\t"));println()
b1.takeRight(3).foreach(x => print(x + "\t"));println()
11、takeWhile
- 定义:def takeWhile(p: (T) ⇒ Boolean): Array[T]
- 描述:返回当前序列中,从第一个元素开始,满足条件的连续元素组成的序列,如果第一个值不满足,则返回空,不管后面的元素了
示例:
b1.foreach(x => print(x + "\t"));println()
b1.takeWhile(_>2).foreach(x => print(x + "\t"));println()
b1.takeWhile(_%2!=0).foreach(x => print(x + "\t"));println()
三、数组中的计算
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、product
- 定义:def product: A
- 描述:返回所有元素乘积的值
示例:
b3.foreach(x=>print(x+"\t"));println()
println(b3.product)
6、reduce
- 定义:def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1
- 描述:对序列中的每个元素进行二元运算,不需要初始值,其他的和fold一样
示例:
b3.foreach(x => print(x + "\t"));
println()
println(b3.reduce((x, y) => {
var z = x + y
println(s"$x+$y=$z")
z
}))
7、reduceLeft
- 定义:def reduceLeft[B >: A](op: (B, T) ⇒ B): B
- 描述:同 foldLeft,从左向右计算,不需要初始值
示例:
b3.foreach(x => print(x + "\t"));
println()
println(b3.reduceLeft((x, y) => {
var z = x + y
println(s"$x+$y=$z")
z
}))
8、reduceRight
- 定义:def reduceRight[B >: A](op: (B, T) ⇒ B): B
- 描述:同 foldRight,从右向左计算,不需要初始值
示例:
b3.foreach(x => print(x + "\t"));
println()
println(b3.reduceRight((x, y) => {
var z = x + y
println(s"$x+$y=$z")
z
}))
9、reduceOption
- 定义:def reduceOptionA1>:A: scala.Option[A1]
- 描述:同 reduceLeftOption,计算Option,返回 Option
示例:
b3.foreach(x => print(x + "\t"));
println()
println(b3.reduceOption((x, y) => {
var z = x + y
println(s"$x+$y=$z")
z
}))
10、reduceLeftOption
- 定义:def reduceLeftOption[B >: A](op: (B, T) ⇒ B): Option[B]
- 描述:同 reduceLeft,返回 Option
示例:
b3.foreach(x => print(x + "\t"));
println()
println(b3.reduceLeftOption((x, y) => {
var z = x + y
println(s"$x+$y=$z")
z
}))
11、reduceRightOption
- 定义:def reduceRightOption[B >: A](op: (T, B) ⇒ B): Option[B]
- 描述:同 reduceRight,返回 Option
示例:
b3.foreach(x => print(x + "\t"));
println()
println(b3.reduceRightOption((x, y) => {
var z = x + y
println(s"$x+$y=$z")
z
}))
12、scan
- 定义:def scan[B >: A, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Array[T], B, That]): That
- 描述:同 fold,scan 会把每一步的计算结果放到一个新的集合中返回,而 fold 返回的是最后的结果
示例:
b1.foreach(x => print(x + "\t"));println()
b1.scan(0)(_+_).foreach(x => print(x + "\t"));println()
13、scanLeft
- 定义:def scanLeft[B, That](z: B)(op: (B, T) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That
- 描述:同 scan,从左向右计算,每一步的计算结果放到一个新的集合中返回
示例:
b1.foreach(x => print(x + "\t"));println()
b1.scanLeft(0)(_+_).foreach(x => print(x + "\t"));println()
14、scanRight
- 定义:def scanRight[B, That](z: B)(op: (T, B) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That
- 描述:同 foldRight,从右向左计算,每一步的计算结果放到(从右向左放)一个新的集合中返回
示例:
b1.foreach(x => print(x + "\t"));println()
b1.scanRight(0)(_+_).foreach(x => print(x + "\t"));println()
15、sum
- 定义:def sum: A
- 描述:序列求和,元素需为 Numeric[T] 类型
示例:
var a1=Array.range(1,5)
a1.foreach(x=>print(x+"\t"));println()
println(a1.sum)
四、字符串相关操作
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、stringPrefix
- 定义:def stringPrefix: String
- 描述:返回 toString 结果的前缀
示例:
b1.foreach(x => print(x + "\t"));println()
b1.stringPrefix.foreach(x=>print(x+"\t"));println()
五、方法操作
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
b1.foreach(x=>print(x+"\t"));println()
b1.foreach(x=>print(s"$x,"));println()
8、iterator
- 定义:def iterator: collection.Iterator[T]
- 描述:生成当前序列的迭代器
示例:
var a1=Array.range(1,5)
a1.foreach(x=>print(x+"\t"));println()
val it = a1.iterator
while (it.hasNext) {
println(it.next() * 3)
}
9、map
- 定义:def map[B](f: (A) ⇒ B): Array[B]
- 描述:对序列中的元素进行 f 操作,返回生成的新序列,对一个维度的数据进行操作
示例:
var a1 = Array.range(1, 5)
a1.foreach(x => print(x + "\t"));println()
a1.map(x=>x*2).foreach(x => print(x + "\t"));println()
val a2 = Array(("1001", "henry", "male", 100), ("1002", "pola", "female", 130), ("1003", "ariel", "female", 200))//元组的数组
a2.foreach(x=>print(x+"\t"));println()
a2.map(x=>(x._3,x._4)).foreach(x=>print(x+"\t"))
10、runWith
- 定义:def runWith[U](action : scala.Function1[B, U]) : scala.Function1[A, scala.Boolean] = { /* compiled code */ }
- 描述: 执行偏函数,当参数不在定义域内时,返回false,否则返回true,并执行action
示例:
val pf4: PartialFunction[Int, Int] = (x: Int) => x match {
case x if (x % 2 == 0) => x
}
pf4.runWith(println)(6)
pf4.runWith(println)(5)//偏函数,不输出,因为函数里没设置
pf4.runWith(println)(4)
var b = Array.range(1, 20)
b.runWith(print)(18);println()
b.runWith(print)(21);println()
b.runWith(print)(17);println()
println(b.runWith(x => x match {
case x if x % 2 == 0 => x
})(17))
六、指定条件判断
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))
var a1 = Array.range(1, 5)
a1.foreach(x => print(x + "\t"))
println()
println(a1.contains(1))
println(a1.contains(0))
println(a1.contains("a"))
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)))
var a1 = Array.range(1, 5)
a1.foreach(x => print(x + "\t"))
println()
var a2 = Array.range(1, 4)
a2.foreach(x => print(x + "\t"))
println()
var a3 = Array.range(2, 6)
a3.foreach(x => print(x + "\t"))
println()
println(a1.containsSlice(a1))
println(a1.containsSlice(a2))
println(a1.containsSlice(a3))
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、endsWith
- 定义:def endsWith[B](that: GenSeq[B]): Boolean
- 描述:判断当前序列是否以某个序列结尾
示例:
var a1 = Array.range(1, 5)
a1.foreach(x => print(x + "\t"))
println()
var a2 = Array.range(1,3)
a2.foreach(x => print(x + "\t"))
println()
var a3 = Array.range(4,5)
a3.foreach(x => print(x + "\t"))
println()
println(a1.endsWith(a2))
println(a1.endsWith(a3))
5、startsWith
- 定义:def startsWith[B](that: GenSeq[B], offset: Int): Boolean
- 描述:判断序列从指定偏移处是否以某个序列开始,第二个参数是主序列的偏移量,也就是从第n位开始的位置是否以子序列结束
示例:
var a1 = Array.range(1, 5)
a1.foreach(x => print(x + "\t"))
println()
var a2 = Array.range(1,3)
a2.foreach(x => print(x + "\t"))
println()
var a3 = Array.range(4,5)
a3.foreach(x => print(x + "\t"))
println()
println(a1.startsWith(a2))
println(a1.startsWith(a3))
println(a1.startsWith(a3,3))
6、exists
- 定义:def exists(p: (T) ⇒ Boolean): Boolean
- 描述:判断当前数组是否包含符合条件的元素
示例:
var a1=Array.range(1,5)
a1.foreach(x=>print(x+"\t"));println()
println(a1.exists(_ > 6))
println(a1.exists(_ > 3))
7、filter、filterNot
- 定义:def filter(p: (T) ⇒ Boolean): Array[T]、def filterNot(p: (T) ⇒ Boolean): Array[T]
- 描述:取得当前数组中符合、不符合条件的元素,组成新的数组返回
示例:
var a1 = Array.range(1, 5)
a1.foreach(x => print(x + "\t"))
println()
a1.filter(_ % 2 == 0).foreach(x=>print(x+"\t"))
println()
a1.filter(x=> x % 2 == 0).foreach(x=>print(x+"\t"))
println()
a1.filterNot(x=> x % 2 == 0).foreach(x=>print(x+"\t"))
8、withFilter
- 定义:def withFilter(p: (T) ⇒ Boolean): FilterMonadic[T, Array[T]]
- 描述:根据条件 p 过滤元素,不生成新的集合
示例:
b7.foreach(x => print(x + "\t"));println()
b7.withFilter(_>4).foreach(x => print(x + "\t"));println()
9、find
- 定义:def find(p: (T) ⇒ Boolean): Option[T]
- 描述:查找第一个符合条件的元素,返回 Option
示例:
var a1 = Array.range(1, 5)
a1.foreach(x => print(x + "\t"))
println()
println(a1.find(_ > 2))
println(a1.find(_ > 5))
10、forall
- 定义:def forall(p: (T) ⇒ Boolean): Boolean
- 描述:检测序列中的元素是否都满足条件 p,如果序列为空,则返回 true
示例:
b1.foreach(x=>print(x+"\t"));println()
println(b1.forall(_ > 0))
println(b1.forall(_ < 0))
println(b1.forall(_ > 2))
println(b1.forall(_ < 10))
println(b1.forall(_.isInstanceOf[Int]))
println(b1.forall(_ % 2 == 0))
11、hasDefiniteSize
- 定义:def hasDefiniteSize: Boolean
- 描述:检测序列是否存在有限的长度,对应 Stream 这样的流数据则返回 false,流没有确定的大小
示例:
println(b1.hasDefiniteSize)
println(b1.toStream)
println(b1.toStream.hasDefiniteSize)
12、isDefinedAt
- 定义:def isDefinedAt(idx: Int): Boolean
- 描述:判断序列中是否存在指定索引
示例:
b1.foreach(x=>print(x+"\t"));println()
println(b1.isDefinedAt(5))
println(b1.isDefinedAt(7))
println(b1.isDefinedAt(2))
13、isEmpty
- 定义:def isEmpty: Boolean
- 描述:判断序列是否为空
示例:
a2.foreach(x=>print(x+"\t"));println()
println(a2.isEmpty)
14、nonEmpty
- 定义:def nonEmpty: Boolean
- 描述:判断序列是否不为空
示例:
a2.foreach(x=>print(x+"\t"));println()
println(a2.nonEmpty)
15、isTraversableAgain
- 定义:def isTraversableAgain: Boolean
- 描述:判断序列是否可以反复遍历,该方法是 GenTraversableOnce 中的方法,对于 Traversables 一般返回 true,对于 Iterators 返回 false,除非被复写 或者说判断是否为迭代器(只能遍历一次)
示例:
array2.foreach(x=>print(x+"\t"));println()
println(array2.isTraversableAgain)
println(array2.toIterator.isTraversableAgain)
七、下标索引操作
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、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))
3、indexOf(elem)、indexOf(elem, from)
- 定义:def indexOf(elem: T): Int、def indexOf(elem: T, from: Int): Int
- 描述:返回元素 elem 在序列中第一次出现的索引,【指定从索引 from 开始查找】
示例:
b1.foreach(x=>print(x+"\t"));println()
println(b1.indexOf(2))
println(b1.indexOf(8))
println(b1.indexOf(5))
println(b1.indexOf(1,2))
5、indexOfSlice(that)、indexOfSlice(that, from)
- 定义:def indexOfSlice[B >: A](that: GenSeq[B]): Int、def indexOfSlice[B >: A](that: GenSeq[B], from: Int): Int
- 描述:检测当前序列中是否包含序列 that,并返回第一次出现该序列的索引,找不到返回-1;并且指定索引可以超出元素索引的范围,【指定从索引 from 开始查找,并返回第一次出现该序列】
示例:
b1.foreach(x=>print(x+"\t"));println()
println(b1.indexOfSlice(Array(6,5)))
println(b1.indexOfSlice(Array(6,7)))
println(b1.indexOfSlice(Array(8,6)))
println(b1.indexOfSlice(Array(8,6),2))
7、indexWhere§、indexWhere(p, from)
- 定义:def indexWhere(p: (T) ⇒ Boolean): Int、def indexWhere(p: (T) ⇒ Boolean, from: Int): Int
- 描述:返回当前序列中第一个满足条件 p 的元素的索引【,指定从索引 from 开始查找】
示例:
b1.foreach(x=>print(x+"\t"));println()
println(b1.indexWhere(_==6))
println(b1.indexWhere(_>2))
println(b1.indexWhere(_==6,3))
println(b1.indexWhere(_>2,3))
9、lastIndexOf(elem: T)、lastIndexOf(elem: T, end: Int)
- 定义:def lastIndexOf(elem: T): Int、def lastIndexOf(elem: T, end: Int): Int
- 描述:返回元素 elem 在序列中最后一次出现的索引【,指定在索引 end 之前(包括)的元素中查找】
示例:
b1.foreach(x=>print(x+"\t"));println()
println(b1.lastIndexOf(2))
println(b1.lastIndexOf(8))
println(b1.lastIndexOf(5))
println(b1.lastIndexOf(1,2))
11、lastIndexOfSlice(that)、lastIndexOfSlice(that, end)
- 定义:def lastIndexOfSlice[B >: A](that: GenSeq[B]): Int
- 描述:检测当前序列中是否包含序列 that,并返回最后一次出现该序列的索引【,指定在索引 end 之前(包括)的元素中查找】
示例:
b1.foreach(x=>print(x+"\t"));println()
println(b1.lastIndexOfSlice(Array(6,7)))
println(b1.lastIndexOfSlice(Array(8,6)))
println(b1.lastIndexOfSlice(Array(8,6),2))
14、lastIndexWhere§、lastIndexWhere(p, end)
- 定义:def lastIndexWhere(p: (T) ⇒ Boolean, end: Int): Int
- 描述:返回当前序列中最后一个满足条件 p 的元素的索引,指定在索引 end 之前(包括)的元素中查找
示例:
b1.foreach(x=>print(x+"\t"));println()
println(b1.lastIndexWhere(_==6))
println(b1.lastIndexWhere(_>2))
println(b1.lastIndexWhere(_==6,3))
println(b1.lastIndexWhere(_>2,3))
15、indices
- 定义:def indices: collection.immutable.Range
- 描述:返回当前序列索引集合
示例:
b1.foreach(x=>print(x+"\t"));println()
println(b1.indices)
b1.indices.foreach(x=>print(x+"\t"));println()
16、slice
- 定义:def slice(from: Int, until: Int): Array[T]
- 描述:返回当前序列中从 from 到 until 之间的序列,不包括 until 处的元素
示例:
b1.foreach(x => print(x + "\t"));println()
b1.slice(2,4).foreach(x => print(x + "\t"));println()
17、subSequence
- 定义:def subSequence(start: Int, end: Int): CharSequence
- 描述:返回 start 和 end 间的字符序列,不包含 end 处的元素,(返回 start 和 end 间的字符序列 只针对char类型(前包后不包))
示例:
b5.foreach(x => print(x + "\t"));println()
println(b5.subSequence(1, 3))
18、view
- 定义:def view(from: Int, until: Int): IndexedSeqView[T, Array[T]]
- 描述:返回当前序列中从 from 到 until 之间的序列,不包括 until 处的元素。对于数组的操作有点像slice,前包后不包
示例:
b1.foreach(x => print(x + "\t"));println()
b1.view(2,4).foreach(x => print(x + "\t"));println()
println(b1.view(2, 4))
八、数组拆分排序
1、groupBy
- 定义:def groupBy[K](f: (T) ⇒ K): Map[K, Array[T]]
- 描述:按条件分组,条件由 f 匹配,返回值是 Map 类型,每个 key 对应一个数组
示例:
var add2 = (x: Int, y: Int) => {
val z = x + y
println(s"$x + $y = $z")
z
}
var array2 = Array(1, 2, 3, 5, 7)
println(array2.groupBy(x => x match {
case i if i % 2 == 0 => "even"
case i => "odd"
}).map(x => (x._1, x._2.par.fold(0)(add2))))
2、grouped
- 定义:def grouped(size: Int): collection.Iterator[Array[T]]
- 描述:按指定数量分组,每组有 size 个元素,返回一个迭代器
示例:
var array2 = Array(1, 2, 3, 5, 7)
array2.grouped(2).foreach(x=>{
x.foreach(y=>print(y+"\t"))
println()
})
var array2 = Array(1, 2, 3, 5, 7)
println(array2.grouped(2).map(x => x.fold(0)(add2)).fold(0)(add2))
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、partition
- 定义:def partition(p: (T) ⇒ Boolean): (Array[T], Array[T])
- 描述:按条件将序列拆分成两个数组,满足条件的放到第一个数组,其余的放到第二个数组,返回的是包含这两个数组的
元组
示例:
b1.foreach(x=>print(x+"\t"));println()
b1.partition(_>5)._2.foreach(x=>print(x+"\t"))
println()
b1.partition(_>5)._1.foreach(x=>print(x+"\t"))
println()
5、span
- 定义:def span(p: (T) ⇒ Boolean): (Array[T], Array[T])
- 描述:将序列拆分成两个数组,从第一个元素开始,直到第一个不满足条件的元素为止,其中的元素放到第一个数组,其余的放到第二个数组,返回的是包含这两个数组的元组
示例:
a3.foreach(x => print(x + "\t"));println()
a3.span(_ <= 2)._1.foreach(x => print(x + "\t"));println()
a3.span(_ <= 2)._2.foreach(x => print(x + "\t"));println()
6、splitAt
- 定义:def splitAt(n: Int): (Array[T], Array[T])
- 描述:从指定位置开始,把序列拆分成两个数组,指定索引位置元素放入第二个数组中
示例:
b1.foreach(x => print(x + "\t"));println()
b1.splitAt(3)._1.foreach(x => print(x + "\t"));println()
b1.splitAt(3)._2.foreach(x => print(x + "\t"));println()
7、sliding(size)、sliding(size, step)
- 定义:def sliding(size: Int): collection.Iterator[Array[T]]、def sliding(size: Int): collection.Iterator[Array[T]]
- 描述:滑动,从第一个元素开始,每个元素和它后面的 size个元素组成一个数组,最终组成一个新的集合返回,当剩余元素个数不够size时,则结束。【该方法可以设置步长 step,每一组元素组合完后,下一组从上一组起始元素位置 + step 后的位置处开始】
- 如果size=step,则等同于grouped(5)
示例:
b1.foreach(x => print(x + "\t"));println()
b1.sliding(2).foreach(x =>{x.foreach(y=>print(y+"\t"));println()});println()
println()
b1.sliding(2,2).foreach(x =>{x.foreach(y=>print(y+"\t"));println()});println()
println()
b1.sliding(3).foreach(x =>{x.foreach(y=>print(y+"\t"));println()});println()
println()
b1.sliding(3,2).foreach(x =>{x.foreach(y=>print(y+"\t"));println()});println()
8、sortBy
- 定义:def sortBy[B](f: (T) ⇒ B)(implicit ord: math.Ordering[B]): Array[T]
- 描述:按指定的排序规则对序列排序
示例:
b1.foreach(x => print(x + "\t"));println()
b1.sortBy(x=>x).foreach(x => print(x + "\t"));println()
b1.sortBy(x=>(-x)).foreach(x => print(x + "\t"));println()
9、sorted
- 定义:def sorted[B >: A](implicit ord: math.Ordering[B]): Array[T]]
- 描述:使用默认的排序规则对序列排序,默认升序排列,无参数
示例:
b1.foreach(x => print(x + "\t"));println()
b1.sorted.foreach(x => print(x + "\t"));println()
10、sortWith
- 定义:def sortWith(t:(T,T)=>boolean):Array[T]
- 描述:自定义排序方法
示例:
b1.foreach(x => print(x + "\t"));println()
b1.sortWith(_>_).foreach(x => print(x + "\t"));println()
b1.sortWith(_<_).foreach(x => print(x + "\t"));println()
九、数组长度
1、length
- 定义:def length: Int
- 描述:返回序列元素个数
示例:
array2.foreach(x=>print(x+"\t"));println()
println(array2.length)
println(array2.size)
2、lengthCompare
- 定义:def lengthCompare(len: Int): Int
- 描述:比较序列的长度和参数 len,返回序列的长度减去参数len,根据二者的关系返回不同的值,长度length更小的话则为负,比较规则是:
x>0, length > len
x=0, length = len
x<0, length < len
示例:
array2.foreach(x=>print(x+"\t"));println()
println(array2.length)
println(array2.lengthCompare(5))
println(array2.lengthCompare(3))
println(array2.lengthCompare(7))
3、segmentLength
- 定义:def segmentLength(p: (T) ⇒ Boolean, from: Int): Int
- 描述:从序列的 from 开始向后查找,返回满足条件 p 的连续元素的长度,只返回第一个,第一个不满足的话就结束
示例:
b1.foreach(x => print(x + "\t"));println()
println(b1.segmentLength(_ > 4, 0))
println(b1.segmentLength(_ > 4, 1))
println(b1.segmentLength(_ > 4, 2))
4、size
- 定义:def size: Int
- 描述:返回序列元素个数,同 length
示例:
array2.foreach(x=>print(x+"\t"));println()
println(array2.length)
println(array2.size)
十、两数组操作
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、union
- 定义:def union(that: collection.Seq[T]): Array[T]
- 描述:合并两个序列,同操作符 ++
示例:
var a1=Array.range(1,5)
var a2=Array.range(8,12)
a1.foreach(x=>print(x+"\t"));println()
a2.foreach(x=>print(x+"\t"));println()
a1.union(a2).foreach(x=>print(x+"\t"));println()
(a1 union a2).foreach(x=>print(x+"\t"));println()
5、corresponds
- 定义:def corresponds[B](that: GenSeq[B])(p: (T, B) ⇒ Boolean): Boolean
- 描述:判断两个序列的长度以及对应位置元素是否符合某个条件。如果两个序列具有相同的元素数量并且 p(x, y)=true,则返回 true,不满足返回false
示例:
var a1=Array.range(1,5)
var a2=Array.range(8,12)
a1.foreach(x=>print(x+"\t"));println()
a2.foreach(x=>print(x+"\t"));println()
println(a1.corresponds(a2)((x, y) => x + 7 == y))
println(a1.corresponds(a2)((y, x) => x + 7 == y))
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、seq
- 定义:def seq: collection.mutable.IndexedSeq[T]
- 描述:产生一个引用当前序列的 sequential 视图,就是一个特殊的集合,WrappedArray
示例:
b1.foreach(x => print(x + "\t"));println()
b1.seq.foreach(x => print(x + "\t"));println()
println(b1.seq)
十二、数组反转
1、reverse
- 定义:def reverse: Array[T]
- 描述:反转序列
示例:
b1.foreach(x => print(x + "\t"));println()
b1.reverse.foreach(x => print(x + "\t"));println()
2、reverseIterator
- 定义:def reverseIterator: collection.Iterator[T]
- 描述:生成反向迭代器
示例:
b1.foreach(x => print(x + "\t"));println()
println(b1.isTraversableAgain)
b1.reverseIterator.foreach(x => print(x + "\t"));println()
println(b1.reverseIterator.isTraversableAgain)
3、reverseMap
- 定义:def reverseMap[B](f: (A) ⇒ B): Array[B]
- 描述:同 map,方向相反
示例:
b1.foreach(x => print(x + "\t"));println()
b1.map(x=>print(x + "\t"));println()
b1.reverseMap(x=>print(x + "\t"));println()
十三、数组的行列操作
1、flatMap
- 定义:def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Array[B]
- 描述:先map后降维,对当前序列的每个元素进行操作,map之后的每个元素必须还是集合,结果放入新序列返回,参数要求是 GenTraversableOnce 及其子类。什么类型调用的flatMap方法,则返回的也是什么类型
示例:
val a2 = Array(Array(1,3,5),Array(2,4,6))
a2.flatMap(x=>x.map(x=>(x,1))).foreach(x=>print(x+"\t"))
println()
a2.flatMap(x=>x.map(x=>(if(x%2==0) "even" else "odd",1))).foreach(x=>print(x+"\t"))
println()
2、flatten
- 定义:def flatten[U](implicit asTrav: (T) ⇒ collection.Traversable[U], m: ClassTag[U]): Array[U]
- 描述:扁平化(降维),将二维数组的所有元素组合在一起,形成一个一维数组返回
示例:
val a2 = Array(Array(1,3,5),Array(2,4,6),Array(7,8,9))
a2.foreach(x => {
x.foreach(y=>print(y + "\t"))
println()
})
a2.flatten.foreach(x => print(x + "\t"))
3、transpose
- 定义:def transpose[U](implicit asArray: (T) ⇒ Array[U]): Array[Array[U]]
- 描述:矩阵转置,二维数组行列转换
示例:
var b9=Array(Array(1,2,3),Array(4,5,6),Array(7,8,9),Array(11,12,13),Array(21,22,3))
b9.foreach(x =>{x.foreach(y=>print(y+"\t"));println()});println()
println()
b9.transpose.foreach(x =>{x.foreach(y=>print(y+"\t"));println()});println()
4、unzip
- 定义:def unzip[T1, T2](implicit asPair: (T) ⇒ (T1, T2), ct1: ClassTag[T1], ct2: ClassTag[T2]): (Array[T1], Array[T2])
- 描述:将二元组的数组,每个元组的第一个元素组成一个数组,第二个元素组成一个数组,返回包含这两个数组的元组
示例:
var b10=Array(("henry",19),("aaaa",12))
b10.unzip._1.foreach(x => print(x + "\t"));println()
b10.unzip._2.foreach(x => print(x + "\t"));println()
5、unzip3
- 定义:def unzip3[T1, T2, T3](implicit asTriple: (T) ⇒ (T1, T2, T3), ct1: ClassTag[T1], ct2: ClassTag[T2], ct3: ClassTag[T3]): (Array[T1], Array[T2], Array[T3])
- 描述:将三元组的数组,每个元组的第一个元素组成一个数组,第二个元素组成一个数组,第三个元素组成一个数组,返回包含这三个数组的元组
示例:
var b11=Array(("henry",19,4),("aaaa",12,4))
b11.unzip3._1.foreach(x => print(x + "\t"));println()
b11.unzip3._2.foreach(x => print(x + "\t"));println()
b11.unzip3._3.foreach(x => print(x + "\t"));println()
6、zip
- 定义:def zip[B](that: GenIterable[B]): Array[(A, B)]
- 描述:将两个序列对应位置上的元素组成一个元组数组,要求两个序列长度相同
示例:
var c1=Array(1,2,3)
var c2=Array("a","b","c")
c1.zip(c2).foreach(x=>print(x+"\t"));println()
7、zipAll
- 定义:def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): Array[(A, B)]
- 描述:同 zip ,但是允许两个序列长度不同,不足的自动填充,如果当前序列短,不足的元素填充为 thisElem,如果 that 序列短,填充为 thatElem
示例:
var c3=Array(1,2,3)
var c4=Array("a","b","c","d")
c4.zipAll(c3,0,"z").foreach(x=>print(x+"\t"));println()
c3.zipAll(c4,0,"z").foreach(x=>print(x+"\t"));println()
8、zipWithIndex
定义:def zipWithIndex: Array[(A, Int)]
描述:序列中的每个元素和它的索引组成一个元组数组
示例:
var c5=Array("a","b","c","d")
c5.zipWithIndex.foreach(x=>print(x+"\t"));println()
十四、类型转换
1、toArray
- 定义:def toArray: Array[A]
- 描述:将序列转换成 Array 类型
示例:
2、toBuffer
- 定义:def toBuffer[A1 >: A]: Buffer[A1]
- 描述:将序列转换成 Buffer 类型
示例:
3、toIndexedSeq
- 定义:def toIndexedSeq: collection.immutable.IndexedSeq[T]
- 描述:将序列转换成 IndexedSeq 类型
示例:
4、toIterable
- 定义:def toIterable: collection.Iterable[T]
- 描述:将序列转换成可迭代的类型
示例:
5、toIterator
- 定义:def toIterator: collection.Iterator[T]
- 描述:将序列转换成迭代器,同 iterator 方法
示例:
6、toList
- 定义:def toList: List[T]
- 描述:将序列转换成 List 类型
示例:
7、toMap
- 定义:def toMap[T, U]: Map[T, U]
- 描述:将序列转转换成 Map 类型,需要被转化序列中包含的元素是 Tuple2 类型,Tuple2 类型意思是:元组必须是2元的,以元组的第一个元素做键,第二个元素做值
示例:
val b8 = Array((1,"a"),(3,"c"),(4,"d"))
b8.foreach(x=>print(x+"\t"));println()
println(b8.toMap)
8、toSeq
- 定义:def toSeq: collection.Seq[T]
- 描述:转换成序列
示例:
9、toSet
- 定义:def toSet[B >: A]: Set[B]
- 描述:将序列转换成 Set 类型
示例:
var b7=Array(2,1,4,3,5,2,1)
b7.foreach(x => print(x + "\t"));println()
println(b7.toSet)
10、toStream
- 定义:def toStream: collection.immutable.Stream[T]
- 描述:将序列转换成 Stream 类型(流类型),懒de序列,只存一个值,其他值需要时再取
示例:
b7.foreach(x => print(x + "\t"));println()
println(b7.toStream)
println(b7.toStream.head)
println(b7.toStream.tail)
println(b7.inits.toStream)
11、toVector
- 定义:def toVector: Vector[T]
- 描述:将序列转换成 Vector 类型,内部线程安全,但效率低
示例: