在scala中，Array有大量的方法。定义一个数组arr后，输入arr.后按下tab，可以得到大量的方法。
++
合并集合，并返回一个新的数组，新数组包含左右两个集合对象的内容。
var a = Array(2,1)
var b = Array(3,4)
var c = a ++ b
var c = a.++(b)
结果如下：
++：
这个方法同上一个方法类似，两个加号后面多了一个冒号，但是返回数组类型与冒号右侧数组相同。
val a = List(1,2)
val b = scala.collection.mutable.LinkedList(3,4)
val c = a ++: b
val c = a.++:(b)
运行结果如下：
+：
在数组前面添加一个元素，并返回新的对象，下面添加一个元素。
var a = Array(1,2)
var b = 0 +: a
运行结果如下：
:+
同上面的方法想法，在数组末尾添加一个元素，并返回新对象。
/: 对数组中所有的元素进行相同的操作 ，foldLeft的简写。 var a = Array(2,3,4,5)
var b = (1/:a)(_+_)
//运算顺序为1+2+3+4+5 运行结果如下： :\
foldRight的简写，这里从右往左进行运算。
var a = Array(2,3,4,5)
var b = (a /:1)(_-_)
//运算顺序为1-2-3-4-5
var b = (a :\1))(_-_)
//运算顺序为1-（2-（3-（4-（5-1）））））
运行结果如下：
addString
将数组中的元素逐个添加到b中，并转换为字符串。
var a = List(1,1,2,4)
var b = new StringBulider()
var c = a.addString(b)
//c的内容为 1124
var c = a.addString(b)
//c的内容为 11241124
运行结果如下：
其他：
val a = List(1,2,3,4)
val b = new StringBuilder()
val c = a.addString(b,",")
println("c: "+c) // c: 1,2,3,4
val a = List(1,2,3,4)
val b = new StringBuilder()
val c = a.addString(b,"{",",","}")
println("c: "+c) // c: {1,2,3,4}
aggregate
聚合计算，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
*/
apply
取出指定索引处的元素
var b = a.apply(0)
var b = a(0)
运行结果如下：
canEqual
判断两个对象是否可以进行比较
charAt
获取index索引处的字符，这个方法会执行一个隐式的转换，将Array[T]转换为 ArrayCharSequence，只有当T为char类型时，这个转换才会发生。
var c = Array('c','b','a')
var cc = c.charAt(0)
运行结果如下：
clone
创建一个数组的副本
运行结果如下
collect
通过执行一个并行计算（偏函数），得到一个新的数组对象
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 */
运行结果如下：
collectFirst
在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算
//这里继续运用上一个偏函数
val chars = Array('a','b','c','a')
val newchars = chars.collect(fun)
val fun:PartialFunction[Char,Char] = {
case 'a' => 'A'
case x => x
}
val b = chars.collectFirst(fun)
运行结果如下
combinations
排列组合，这个排列组合会选出所有包含字符不一样的组合，对于 “abc”、“cba”，只选择一个，参数n表示序列长度，就是几个字符为一组。
val arr = Array("a","b","c")
val newarr = arr.combinations(2)
newarr.foreach((item) => println(item.mkString(",")))
运行结果如下：
contains
序列中是否包含指定对象
containsSlice
判断当前序列中是否包含另一个序列
copyToArray
拷贝数组中的元素
此外，还有两种用法：
corresponds
判断两个序列长度以及对应位置元素是否符合某个条件。如果两个序列具有相同的元素数量并且p(x, y)=true，返回结果为true 。注意，如果长度不同，始终返回false
下面代码检查a和b长度是否相等，并且a中元素是否小于b中对应位置的元素
count
统计符合条件的元素个数，下面统计大于 2 的元素个数。
好文推荐
发表评论