scala> a.然后按tap建查看所有常用函数
++ count hasDefiniteSize maxBy sameElements toBuffer
++: deep head min scan toIndexedSeq
+: diff headOption minBy scanLeft toIterable
/: distinct indexOf mkString scanRight toIterator
:+ drop indexOfSlice nonEmpty segmentLength toList
:\ dropRight indexWhere orElse seq toMap
addString dropWhile indices padTo size toSeq
aggregate elemManifest init par slice toSet
andThen elemTag inits partition sliding toStream
apply endsWith intersect patch sortBy toTraversable
applyOrElse exists isDefinedAt permutations sortWith toVector
array filter isEmpty prefixLength sorted transform
canEqual filterNot isTraversableAgain product span transpose
clone find iterator reduce splitAt union
collect flatMap last reduceLeft startsWith unzip
collectFirst flatten lastIndexOf reduceLeftOption stringPrefix unzip3
combinations fold lastIndexOfSlice reduceOption sum update
companion foldLeft lastIndexWhere reduceRight tail updated
compose foldRight lastOption reduceRightOption tails view
contains forall length repr take withFilter
containsSlice foreach lengthCompare reverse takeRight zip
copyToArray genericBuilder lift reverseIterator takeWhile zipAll
copyToBuffer groupBy map reverseMap to zipWithIndex
corresponds grouped max runWith toArray
Array,Map
数组是一种可变的、可索引的数据集合。在 Scala 中用 Array[T] 的形式来表示 Java 中的数组形式 T[]。
Map用于将数组里面的每一个数按要求进行运算打印出来
示例:
scala> val a=Array(1,2,3,4)//申明一个数组对象
a: Array[Int] = Array(1, 2, 3, 4)
scala> a//查看
res1: Array[Int] = Array(1, 2, 3, 4)
scala> a.getClass//查看类型
res2: Class[_ <: Array[Int]] = class [I
scala> a(0)//查看第一个数组元素
res3: Int = 1
scala> a.map(x=>x*2)
res6: Array[Int] = Array(2, 4, 6, 8)
scala> a.map(_*2)
res8: Array[Int] = Array(2, 4, 6, 8)
++
定义:def ++[B](that: GenTraversableOnce[B]): Array[B]
描述:合并集合,并返回一个新的数组,新数组包含左右两个集合的内容
类型:默认的是左边的类型
示例:
scala> val a=Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)
scala> val b=Array(5,6)
b: Array[Int] = Array(5, 6)
scala> a++b
res11: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> a.mkString(",")
res9: String = 1,2,3,4
scala> a.mkString("-")
res10: String = 1-2-3-4
++:
定义:def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Array[T], B, That]): That
描述:这个方法同上一个方法类似,两个加号后面多了一个冒号,但是不同的是右边操纵数的类型决定着返回结果的类型
示例:Array 和 List 结合,返回结果是 List 类型
scala> val a=Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)
scala> val b=List(5,6)
b: List[Int] = List(5, 6)
scala> a++:b
res12: List[Int] = List(1, 2, 3, 4, 5, 6)
scala> b++:a
res15: Array[Int] = Array(5, 6, 1, 2, 3, 4)
scala> res12.getClass
res14: Class[_ <: List[Int]] = class scala.collection.immutable.$colon$colon
+:
定义:def +:(elem: A): Array[A]
描述:在数组前面添加一个元素,并返回新的数组对象
示例:
scala> val a=Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)
scala> val b=List(5,6)
b: List[Int] = List(5, 6)
scala> a+:b
res16: List[Any] = List(Array(1, 2, 3, 4), 5, 6)
scala> 1+:a
res17: Array[Int] = Array(1, 1, 2, 3, 4)
scala> 2+:b
res18: List[Int] = List(2, 5, 6)
:+
定义:def :+(elem: A): Array[A]
描述:在数组后面添加一个元素,并返回新的数组对象
示例:
scala> val a=Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)
scala> a:+5
res26: Array[Int] = Array(1, 2, 3, 4, 5)
scala> a:+b
res27: Array[Any] = Array(1, 2, 3, 4, Array(5, 6))
scala>
/:
定义:def /:[B](z: B)(op: (B, T) ⇒ B): B
描述:对数组中所有的元素从左向右遍历,进行相同的迭代操作,foldLeft 的简写
示例:
scala> val a=Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)
scala> (10/:a)(_+_)//(10+1)+2)+3)+4)
res28: Int = 20
scala> val b=Array(4,5)
b: Array[Int] = Array(4, 5)
scala> (2/:b)(_*_) //(2*4)*5)
res29: Int = 40
scala> a.foldLeft(10)(_+_)
res34: Int = 20
scala> (10/:a)((x,y)=>{println(x,y);x+y})//x导表10,y代表a里面的数从左遍历,每次x+y后的值变为新x
(10,1)
(11,2)
(13,3)
(16,4)
res30: Int = 20
:\
定义:def :[B](z: B)(op: (T, B) ⇒ B): B
描述:对数组中所有的元素从右向左遍历,进行相同的迭代操作,foldRight 的简写
示例:
scala> (a:\10)((x,y)=>{println(x,y);x+y})
(4,10)
(3,14)
(2,17)
(1,19)
res31: Int = 20
scala> a.foldRight(10)(_+_)
res35: Int = 20
addString(b)
定义:def addString(b: StringBuilder): StringBuilder
描述:将数组中的元素逐个添加到 StringBuilder 中
addString(b, sep)
定义:def addString(b: StringBuilder, sep: String): StringBuilder
描述:将数组中的元素逐个添加到 StringBuilder 中,每个元素用 sep 分隔符分开
示例:
scala> val a=Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)
scala> val b=new StringBuilder()
b: StringBuilder =
scala> a.addString(b)
res36: StringBuilder = 1234
scala> b
res37: StringBuilder = 1234
scala> val b=new StringBuilder()//也可以手动添加分隔符
b: StringBuilder =
scala> a.addString(b,",")
res39: StringBuilder = 1,2,3,4
aggregate
定义:def aggregate[B](z: ⇒ B)(seqop: (B, T) ⇒ B, combop: (B, B) ⇒ B): B
描述:聚合计算,aggregate 是柯里化方法,参数是两个方法
示例:为了方便理解,把 aggregate 的两个参数分别封装成两个方法,并把分区和不分区的计算过程分别打印出来
个人理解分区和不分区的区别
不分区
就类似于(5+1)+2)+3)+4)+5)
分区之后
就按5进行分区,将数组里面的每一个元素和5相加,每一次相加的结果放进com里面重新进行相互相加,因为aggregate是并行运算的,所以顺序会乱,每次结果可能也会不一样
scala> a.aggregate(5)((x,y)=>{println("seqop",x,y);x+y},(x,y)=>{println("scombop",x,y);x+y})
(seqop,5,1)
(seqop,6,2)
(seqop,8,3)
(seqop,11,4)
(seqop,15,5)
res45: Int = 20
scala> a.par.aggregate(5)((x,y)=>{println("seqop",x,y);x+y},(x,y)=>{println("scombop",x,y);x+y})
(seqop,5,1)
(seqop,5,3)
(seqop,5,2)
(seqop,5,5)
(seqop,5,4)
(scombop,6,7)
(scombop,9,10)
(scombop,8,19)
(scombop,13,27)
res47: Int = 40
scala> a.par.aggregate(2)((x,y)=>{println("seqop",x,y);if(y>x) y else x},(x,y)=>{println("scombop",x,y);x+y} )
(seqop,2,1)
(seqop,2,2)
(seqop,2,3)
(seqop,2,4)
(scombop,2,2)
(scombop,3,4)
(scombop,4,7)
res71: Int = 11
通过上面的运算不难发现,不分区时,seqno 是把初始值顺序和每个元素相加,把得到的结果与下一个元素进行运算。
分区时,seqno 是把初始值与每个元素相加,但结果不参与下一步运算,而是放到另一个序列中,由第二个方法 combine 进行处理。
上面过程可以简写为
scala> val a=Array(1,2,3,4,5)
a: Array[Int] = Array(1, 2, 3, 4, 5)
scala> a.aggregate(5)(_+_,_+_)
res41: Int = 20
scala> a.par.aggregate(5)(_+_,_+_)
res42: Int = 40
apply
定义:def apply(i: Int): T
描述:获取指定索引处的元素
示例:
scala> val a=Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)
scala> val b=a.apply(1)
b: Int = 2
scala> b
res78: Int = 2
canEqual
定义:def canEqual(that: Any): Boolean
描述:判断两个对象是否可以进行比较
示例:基本上所有对象都可以进行比较,我不知道这个方法的意义何在
scala> val a=Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)
scala> val b=List(1,2)
b: List[Int] = List(1, 2)
scala> println(a.canEqual(b))
true
charAt
定义:def charAt(index: Int): Char
描述:获取 index 索引处的字符,这个方法会执行一个隐式的转换,将 Array[T] 转换为 ArrayCharSequence,只有当 T 为 Char 类型时,这个转换才会发生
示例:
scala> val a=Array('a','b','c')
a: Array[Char] = Array(a, b, c)
scala> a.charAt(2)
res80: Char = c
clone
定义:def clone(): Array[T]
描述:创建一个副本
示例:
scala> val a=Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)
scala> val b=a.clone()
b: Array[Int] = Array(1, 2, 3, 4)
scala> b
res85: Array[Int] = Array(1, 2, 3, 4)
collect
定义:def collect[B](pf: PartialFunction[A, B]): Array[B]
描述:通过执行一个并行计算(偏函数),得到一个新的数组对象
示例:
scala> val a=Array('a','b','c')
a: Array[Char] = Array(a, b, c)
scala> val fun:PartialFunction[Char,Char]={case 'a'=>'A' case x=>x}
fun: PartialFunction[Char,Char] = <function1>
scala> val b=a.collect(fun)
b: Array[Char] = Array(A, b, c)
collectFirst
定义:def collectFirst[B](pf: PartialFunction[T, B]): Option[B]
描述:在序列中查找第一个符合偏函数定义的元素,并执行偏函数计算
示例:
scala> val a=Array(1,'a','b')
a: Array[Int] = Array(1, 97, 98)
scala> val b =a.collectFirst(fun)
b: Option[Int] = Some(100)
combinations
定义:def combinations(n: Int): collection.Iterator[Array[T]]
描述:combinations 表示组合,这个排列组合会选出所有包含字符不一样的组合,但不考虑顺序,对于 “