val numbers = Array(1,2,3,4) //声明一个数组对象
val first = numbers(0) //读取第一个元素
numbers(3) = 100 //替换第四个元素为100
val biggerNumbers = numbers.map(_*2) //所有元素乘2
Scala提供了大量的集合操作
++[B](that: GenTraversableOnce[B]): Array[B]
合并集合,并返回一个新的数组,新数组包含左右两个集合对象的内容
val a = Array(1,2)
val b = Array(3,4)
val c = a ++ b
++:[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
+:(elem: A): Array[A]
在数组前面添加一个元素,并返回新的对象,下面添加一个元素0
val a = List(1,2)
val c = 0 +: a
:+(elem: A): Array[A]
同上面的方法相反,在数组末尾添加一个元素,并返回新对象
val a = List(1,2)
val c = a :+ 0
/:[B](z: B)(op: (B, T) ⇒ B): B
flodLef的简写,对数组中所有元素进行相同操作(1+2+3+4+10)
val a = List(1,2,3,4)
val c = (10 /: a)(_+_)
:[B](z: B)(op: (T, B) ⇒ B): B
flodRight的简写(10+1+2+3+4)
val a = List(1,2,3,4)
val c = (a :\ 10)(_+_)
addString(b: StringBuilder): StringBuilder
将数组的元素逐个添加到b中
val a = List(1,2,3,4)
val b = new StringBuilder()
val c = a.addString(b)
将每个元素用sep分隔符分开
val a = List(1,2,3,4)
val b = new StringBuilder()
val c = a.addString(b,",")
在首尾各加一个字符串,并指定sep分隔符
val a = List(1,2,3,4)
val b = new StringBuilder()
val c = a.addString(b,"{",",","}")
aggregate[B](z: ⇒ B)(seqop: (B, T) ⇒ B, combop: (B, B) ⇒ B): B
聚合计算,aggregate是柯里化方法,参数是两个方法,为了方便理解,我们把aggregate的两个参数,分别封装成两个方法,并把计算过程打印出来。
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
}
val a = List(1,2,3,4)
val c = a.par.aggregate(5)(seqno,combine)
上面过程可以简写为
val c = a.par.aggregate(5)(_+_,_+_)
取数组中的最大值
val c = a.par.aggregate(4)((x,y) => {
println("sq:",x,y);if (x > y) x else y},(x,y) => {
println("com",x,y);if(x>y)x else y})
apply(i: Int): T
取出指定索引出的元素
val first = a.apply(1)
canEqual(that: Any): Boolean
判断两个对象是否可以进行比较
a canEqual(b)
charAt(index: Int): Char
获取index索引处的字符,这个方法会执行一个隐式的转换,将Array[T]转换为ArrayCharSequence,只有当T为Char类型时,这个转换才会发生
val chars = Array('a','b','c')
println("c:"+chars.charAt(0))
clone(): Array[T]
创建一个副本
val chars = Array(‘a’,‘b’,‘c’)
val newchars = chars.clone()
collect[B](pf: PartialFunction[A, B]): Array[B]
通过执行一个并行计算(偏函数),得到一个新的数组对象
//将chars数组的小写a转换为大写A
val chars = Array('a','b','c')
val newchars = chars.collect(fun)
println("newchars:"+newchars.mkString(","))
val fun:PartialFunction[Char,Char] = {
case 'a' => 'A'
case x => x
}
collectFirst[B](pf: PartialFunction[T, B]): Option[B]
在序列中查找第一个符合偏函数定义的元素,并执行偏函数计算
val arr = Array(1,'a',"b")
val fun:PartialFunction[Any,Int] = {
case x:Int => x*100
}
//计算
val value = arr.collectFirst(fun)
//另一种写法
val value = arr.collectFirst({
case x:Int => x*100})
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(",")))
contains[A1 >: A](elem: A1): Boolean
序列中是否包含指定对象
contains只能判断是否包含值,就算b是a的子集,也只能取b中的元素来进行判断
val a = List(1,2,3)
val b = List(1,5,6)
a contains(b)
a contains(2)
containsSlice[B](that: GenSeq[B]): Boolean
判断当前序列是否包含另一个序列
val a = List(1,2,3,4)
val b = List(2,3)
a.containsSlice(b)
copyToArray(xs: Array[A]): Unit
复制数组:将数组a中的数据复制到数组b中
copyToArray(Array,start: Int,len: Int) //start表示起始下标,len表示复制的长度
val a = Array('a', 'b', 'c')
val b : Array[Char] = new Array(5)
a.copyToArray(b)
a.copyToArray(b,1)
a.copyToArray(b,1,2)
copyToBuffer[B >: A](dest: Buffer[B]): Unit
将数组中的内容拷贝到Buffer中
使用ArrayBuffer需要先导包:import scala.collection.mutable._
val a = Array('a', 'b', 'c')
val b:ArrayBuffer[Char