Scala函数大全命令提示符页面应用,可按A-W顺序查看

最新推荐文章于 2022-11-01 09:15:00 发布

大数据与云计算开发者Cd

最新推荐文章于 2022-11-01 09:15:00 发布

阅读量653

点赞数 1

文章标签： linux 运维服务器 scala 大数据

本文链接：https://blog.csdn.net/qq_56795768/article/details/121657113

版权

本文详细列举了Scala中Array和Map的主要函数，包括++、+:、:+、/:、:/、addString、collect、contains、copyToArray、distinct、drop、dropRight、filter等，介绍了它们的功能和用法，帮助读者快速查阅和理解Scala数组和Map的操作。

摘要由CSDN通过智能技术生成

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 表示组合，这个排列组合会选出所有包含字符不一样的组合，但不考虑顺序，对于 “

最低0.47元/天解锁文章

大数据与云计算开发者Cd

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Scala函数大全命令提示符页面应用,可按A-W顺序查看

++ count hasDefiniteSize maxBy sameElements toBuffer++: deep head min scan toIndexedSeq+: diff..
复制链接

扫一扫