#Scala之Array的方法
Scala:Array(集合、序列)
数组是一种可变的、可索引的数据集合。在Scala中用Array[T]的形式来表示Java中的数组形式 T[]。
val numbers = Array(1, 2, 3, 4) //声明一个数组对象
val first = numbers(0) // 读取第一个元素
numbers(3) = 100 // 替换第四个元素为100
val biggerNumbers = numbers.map(_ * 2) // 所有元素乘2
Scala提供了大量的集合操作:
- def ++[B](that: GenTraversableOnce[B]): Array[B] 合并集合,并返回一个新的数组,新数组包含左右两个集合对象的内容。
val a = Array(1,2)
val b = Array(3,4)
val c = a ++ b
//c中的内容是(1,2,3,4)
- def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Array[T], B, That]): That 这个方法同上一个方法类似,两个加号后面多了一个冒号,但是不同的是右边操纵数的类型决定着返回结果的类型。下面代码中List和LinkedList结合,返回结果是LinkedList类型
val a = List(1,2)
val b = scala.collection.mutable.LinkedList(3,4)
val c = a ++: b
println(c.getClass().getName())// c的类型是:scala.collection.mutable.LinkedList
- def +:(elem: A): Array[A] 在数组前面添加一个元素,并返回新的对象,下面添加一个元素 0
val a = List(1,2)
val c = 0 +: a // c中的内容是 (0,1,2)
- def :+(elem: A): Array[A] 同上面的方法想法,在数组末尾添加一个元素,并返回新对象 - def /:[B](z: B)(op: (B, T) ⇒ B): B 对数组中所有的元素进行相同的操作 ,foldLeft的简写
val a = List(1,2,3,4)
val c = (10 /: a)(_+_) // 1+2+3+4+10
val d = (10 /: a)(_*_) // 1*2*3*4*10
println("c:"+c) // c:20
println("d:"+d) // d:240
- def :[B](z: B)(op: (T, B) ⇒ B): B foldRight的简写 - def addString(b: StringBuilder): StringBuilder 将数组中的元素逐个添加到b中
val a = List(1,2,3,4)
val b = new StringBuilder()
val c = a.addString(b) // c中的内容是 1234
- def addString(b: StringBuilder, sep: String): StringBuilder 同上,每个元素用sep分隔符分开
val a = List(1,2,3,4)
val b = new StringBuilder()
val c = a.addString(b,",")
println("c: "+c) // c: 1,2,3,4
- def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder 同上,在首尾各加一个字符串,并指定sep分隔符
val a = List(1,2,3,4)
val b = new StringBuilder()
val c = a.addString(b,"{",",","}")
println("c: "+c) // c: {1,2,3,4}
- def aggregate[B](z: ⇒ B)(seqop: (B, T) ⇒ B, combop: (B, B) ⇒ B): B 聚合计算,aggregate是柯里化方法,参数是两个方法,为了方便理解,我们把aggregate的两个参数,分别封装成两个方法,并把计算过程打印出来。
def main(args: Array[String]) {
val a = List(1,2,3,4)
val c = a.par.aggregate(5)(seqno,combine)
println("c:"+c)
}
def seqno(m:Int,n:Int): Int ={
val s = "seq_exp=%d+%d"
println(s.format(m,n))
return m+n
}
def combine(m:Int,n:Int): Int ={
val s = "com_exp=%d+%d"
println(s.format(m,n))
return m+n
}
/**
seq_exp=5+3
seq_exp=5+2
seq_exp=5+4
seq_exp=5+1
com_exp=6+7
com_exp=8+9
com_exp=13+17
c:30
*/
上面过程可以简写为
val c = a.par.aggregate(5)(_+_,_+_)
- - def apply(i: Int): T 同下面代码,取出指定索引处的元素
val first = numbers(0) // 读取第一个元素
- def canEqual(that: Any): Boolean 判断两个对象是否可以进行比较 - def charAt(index: Int): Char 获取index索引处的字符,这个方法会执行一个隐式的转换,将Array[T]转换为 ArrayCharSequence,只有当T为char类型时,这个转换才会发生。
val chars = Array('a','b','c')
println("c:"+chars.charAt(0)) //结果 a
- def clone(): Array[T] 创建一个副本
val chars = Array('a','b','c')
println(a.apply(2))
val newchars = chars.clone()
- def collect[B](pf: PartialFunction[A, B]): Array[B] 通过执行一个并行计算(偏函数),得到一个新的数组对象
val chars = Array('a','b','c')
val newchars = chars.collect(fun)
println("newchars:"+newchars.mkString(","))
//我们通过下面的偏函数,把chars数组的小写a转换为大写的A
val fun:PartialFunction[Char,Char] = {
case 'a' => 'A'
case x => x
}
/**输出结果是 newchars:A,b,c */
- def collectFirst[B](pf: PartialFunction[T, B]): Option[B] 在序列中查找第一个符合偏函数定义的元素,并执行偏函数计算
val arr = Array(1,'a',"b")
//定义一个偏函数,要求当被执行对象为Int类型时,进行乘100的操作,对于上面定义的对象arr来说,只有第一个元素符合要求
val fun:PartialFunction[Any,Int] = {
case x:Int => x*100
}
//计算
val value = arr.collectFirst(fun)
println("value:"+value)
//另一种写法
val value = arr.collectFirst({case x:Int => x*100})
- def combinations(n: Int): collection.Iterator[Array[T]] 排列组合,这个排列组合会选出所有包含字符不一样的组合,对于 “abc”、“cba”,只选择一个,参数n表示序列长度,就是几个字符为一组
val arr = Array("a","b","c")
val newarr = arr.combinations(2)
newarr.foreach((item) => println(item.mkString(",")))
/**
a,b
a,c
b,c
*/
- def contains[A1 >: A](elem: A1): Boolean 序列中是否包含指定对象 - def containsSlice[B](that: GenSeq[B]): Boolean 判断当前序列中是否包含另一个序列
val a = List(1,2,3,4)
val b = List(2,3)
println(a.containsSlice(b)) //true
- def copyToArray(xs: Array[A]): Unit 此方法还有两个类似的方法 copyToArray(xs: Array[A], start: Int): Unit copyToArray(xs: Array[A], start: Int, len: Int): Unit
val a = Array('a', 'b', 'c')
val b : Array[Char] = new Array(5)
a.copyToArray(b) /**b中元素 ['a','b','c',0,0]*/
a.copyToArray(b,1) /**b中元素 [0,'a',0,0,0]*/
a.copyToArray(b,1,2) /**b中元素 [0,'a','b',0,0]*/
- def copyToBuffer[B >: A](dest: Buffer[B]): Unit 将数组中的内容拷贝到Buffer中
val a = Array('a', 'b', 'c')
val b:ArrayBuffer[Char] = ArrayBuffer()
a.copyToBuffer(b)
println(b.mkString(","))
- def corresponds[B](that: GenSeq[B])(p: (T, B) ⇒ Boolean): Boolean 判断两个序列长度以及对应位置元素是否符合某个条件。如果两个序列具有相同的元素数量并且p(x, y)=true,返回结果为true 下面代码检查a和b长度是否相等,并且a中元素是否小于b中对应位置的元素
val a = Array(1, 2, 3)
val b = Array(4, 5,6)
println