Scala

++
合并集合，并返回一个新的数组

scala> var  a=Array(1,2,3)
a: Array[Int] = Array(1, 2, 3)
 
scala> var b=Array('a','b','c')
b: Array[Char] = Array(a, b, c)
 
scala> a++b
res197: Array[AnyVal] = Array(1, 2, 3, a, b, c)
++：
并数组，结果由冒号右边类型决定

scala> var a=Array(1,2,3)
a: Array[Int] = Array(1, 2, 3)
 
scala> var b=List(4,5,6)
b: List[Int] = List(4, 5, 6)
 
scala> a++:b
res5: List[Int] = List(1, 2, 3, 4, 5, 6)
 
scala> b++:a
res6: Array[Int] = Array(4, 5, 6, 1, 2, 3)
 
*******************************************************
scala> var  a=Array(1,2,3)
a: Array[Int] = Array(1, 2, 3)
scala> var b=Array('a','b','c')
b: Array[Char] = Array(a, b, c)
scala> a++:b
res198: Array[AnyVal] = Array(1, 2, 3, a, b, c)
 
scala> b++:a
res199: Array[AnyVal] = Array(a, b, c, 1, 2, 3)

 +：/:+
冒号跟着集合，在数组前或后加值

scala> var  a=Array(1,2,3)
a: Array[Int] = Array(1, 2, 3)
scala> a:+4
res201: Array[Int] = Array(1, 2, 3, 4)
 
scala> 4+:a
res202: Array[Int] = Array(4, 1, 2, 3)
 /: :\
左子树加，右子树加

scala> var  a=Array(1,2,3)
scala> (10 /: a)((x,y)=>{println(x,y);x+y})
(10,1)
(11,2)
(13,3)
res218: Int = 16
 
scala> (a :\ 10)((x,y)=>{println(x,y);x+y})
(3,10)
(2,13)
(1,15)
res219: Int = 16
addString
将数组中的元素逐个添加到StringBuilder中

scala> var  a=Array(1,2,3)
scala> var c=new StringBuilder()
c: StringBuilder =
 
scala> a.addString(c)
res224: StringBuilder = 123
 
scala> var d=new StringBuilder()
d: StringBuilder =
 
scala> a.addString(d,"-")
res225: StringBuilder = 1-2-3
 
scala> var f=new StringBuilder()
f: StringBuilder =
 
scala> a.addString(f,"(","-",")")
res226: StringBuilder = (1-2-3)

aggregate
聚合计算，是柯理化方法，参数是两个方法

scala> var a=Array(1,2,3,4,5,6,7,8,9,10,11,12,13,14)
a: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)
不分区计算，串型计算
scala> a.aggregate(1)((x,y)=>x+y,(x,y)=>x+y)
res228: Int = 106
scala> a.aggregate(1)((x,y)=>x+y,(x,y)=>x+y)
res229: Int = 106
 
并行
scala> a.par.aggregate(10,0)((x,y)=>{if (y>10) (x._1,x._2+1) else x },(x,y)=>(x._1,x._2+y._2))
res236: (Int, Int) = (10,4)
 apply
取下标对应的值，必须为Int类型

scala> var a=Array(1,2,3,4,5,6,7,8,9,10,11,12,13,14)
scala> a.apply(1)
res238: Int = 2
 
scala> a.apply(0)
res239: Int = 1
charAt 
charAt(index：Int)和apply功能类似

scala> var b=Array('a','b','c')
b: Array[Char] = Array(a, b, c)
 
scala> b
res242: Array[Char] = Array(a, b, c)
 
scala> b.charAt(1)
res243: Char = b
 clone
创建一个副本（默认为浅拷贝，即拷贝对象的引用，拷贝中数据改变原值也会改变）

scala> var b=Array('a','b','c')
b: Array[Char] = Array(a, b, c)
scala> var c=b.clone()
c: Array[Char] = Array(a, b, c)
scala> c
res245: Array[Char] = Array(a, b, c)
collect  PartialFunction
collect 通过执行一个并行计算（偏函数），得到一个新对象
PartialFunction(入参，出参) 即只处理指定数据

scala> var a=Array(1,2,3,4,5,6)
a: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> def fun:PartialFunction[Int,Int]={
     | case 2=>4
     | case 3=>5
     | case 4=>6
     | case x=>x}
scala> a.collect(fun)
res251: Array[Int] = Array(1, 4, 5, 6, 5, 6)
 
scala> c
res245: Array[Char] = Array(a, b, c)
scala> c.collect(x=>x match {case 'a' =>"A"  case _=>"demo"})
res249: Array[String] = Array(A, demo, demo)
collectFirst
在序列中查找第一个符号偏函数定义的元素，并执行偏函数计算

scala> def fun:PartialFunction[Any,Int]={case x:Int=>x*10}
fun: PartialFunction[Any,Int]
 
scala> var a=Array(1,'a',"a")
a: Array[Any] = Array(1, a, a)
 
scala> a.collectFirst(fun)
res252: Option[Int] = Some(10)
 
scala> res252.getOrElse(-1)
res253: Int = 10
combinations
排列组合

scala> var a=Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)
scala> a.combinations(2)
res258: Iterator[Array[Int]] = non-empty iterator
 
scala> res258.foreach(x=>println(x.mkString(",")))
1,2
1,3
1,4
2,3
2,4
3,4
contains
序列中是否包含指定对象

scala> a
res262: Array[Int] = Array(1, 2, 3, 4)
 
scala> a.contains(1)
res263: Boolean = true
containsSlice
类型，值，顺序都要匹配，不比较长度

scala> a
res264: Array[Int] = Array(1, 2, 3, 4)
scala> var b=Array(1,2)
b: Array[Int] = Array(1, 2)
 
scala> a.containsSlice(b)
res266: Boolean = true
 
scala> var b=Array(2,1)
b: Array[Int] = Array(2, 1)
 
scala> a.containsSlice(b)
res267: Boolean = false