scala函数大全

最新推荐文章于 2024-07-15 18:30:19 发布
最新推荐文章于 2024-07-15 18:30:19 发布
阅读量894 收藏 5
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mqd_chan/article/details/111799567
版权

scala 数组函数大全

  • 数组简介

1、数组的长度是不允许改变的,元素是可以改变的

2、var arr:Array[T]=new Array[T](capacity)  //声明数组

3、var arr:Array[T]=Array(T V1,T v2...)   //值已知
      var arr:Array[Int]=Array.range(begin,end,step)

4、arr.foreach(println)  //数组遍历

  • 创建数组

在 window DOS 窗口，输入 scala 进入scala命令行

定义数组：val a1= Array.range(1,4)    val a2=Array("a","b","c")

  • 数组函数汇总

    1.新增

++union+::+
clonecopyToArraycopyToBuffer 

  

 

 

方法名： ++  等同于 union
描述：合并两个序列，若序列类型不同以左边序列类型为主；若泛型类型不同以两个序列共同的最小父类为结果类型；

返回类型：左边序列类型，最小父类序列泛型类型
示例：

scala> a1++a2
res0: Array[Any] = Array(1, 2, 3, a, b, c)

scala> a1.union(a2)
res1: Array[Any] = Array(1, 2, 3, a, b, c)

scala> val a3 = List(1,2)
a3: List[Int] = List(1, 2)

scala> a3++a1
res3: List[Int] = List(1, 2, 1, 2, 3)

方法名：  +:  
描述：在数组前面添加一个元素，结果泛型类型取元素类型和数组类型的共同最小父类

返回类型：Array[T]
示例：

scala> 4+:a1
res2: Array[Int] = Array(4, 1, 2, 3)

方法名：  :+ 
描述： 在数组后面添加一个元素(添加的元素在后，就在数组尾部添加，冒号要离数组近)；和 +: 相反

返回类型：Array[T]
示例：

scala> a1:+5
res4: Array[Int] = Array(1, 2, 3, 5)

方法名：clone
描述： 创建一个数组的副本，复制数组的值,但不会引用地址；就是说是浅克隆

返回类型：Array[T]
示例：

scala> a2.clone
res13: Array[String] = Array(a, b, c)

方法名：copyToArray
描述： copyToArray(Array[,destStartPos[,destLen])将集合中的元素从0开始，拷贝到参数1数组从startPos开始长度为len数组中

 

返回类型：Unit
示例：

scala> var a3=Array.range(1,5)
a3: Array[Int] = Array(1, 2, 3, 4)

scala> var a4=Array.range(5,8)
a4: Array[Int] = Array(5, 6, 7)

scala> a4.copyToArray(a3,0,2)

scala> a3
res6: Array[Int] = Array(5, 6, 3, 4)

方法名：copyToBuffer
描述： copyToBuffer(buffer)将集合中的所有元素拷贝至参数buffer中

返回类型：ArrayBuffer
示例：

scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer

scala> var builder = new ArrayBuffer[Int]()
builder: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

scala> a3.copyToBuffer(builder)

scala> builder
res8: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(5, 6, 3, 4)

2.空/长度

isEmpty nonEmptyhasDefiniteSizelength
sizelengthCompareprefixLengthsegmentLength

 

 

 

方法名： isEmpty
描述： 判断序列是否为空

返回类型：Boolean
示例：

scala> a1.isEmpty
res9: Boolean = false

方法名：nonEmpty
描述：判断序列是否不为空

返回类型：Boolean
示例：

scala> a1.nonEmpty
res10: Boolean = true

方法名：hasDefiniteSize
描述： 检测序列是否存在有限的长度，对应 Stream 类型的流数据则返回 false

返回类型：Boolean
示例：

scala> a1.hasDefiniteSize
res11: Boolean = true
scala> a1.toStream.hasDefiniteSize
res13: Boolean = false

方法名：length  等同于 size
描述：  返回序列元素个数

返回类型：Int
示例：

scala> a1.length
res14: Int = 3
scala> a1.size
res17: Int = 3

方法名：lengthCompare
描述： 比较序列的长度和参数 len，返回序列的长度 - len

返回类型：Int
示例：

scala> a1.lengthCompare(5)
res16: Int = -2

方法名：prefixLength
描述：  prefixLength(p:T=>Boolean)返回序列中满足条件的元素数量，如果第一个元素就不满足返回0，到第一个不满足条件的元素为止

返回类型：Int
示例：

scala> a1.prefixLength(_>1)
res18: Int = 0

scala> a1.prefixLength(_<2)
res19: Int = 1

方法名：segmentLength
描述：segmentLength(p:T=>Boolean,fromIndex)返回一个从fromIndex开始连续满足参数1条件的元素数量

返回类型：Int
示例：

scala> var a5 = Array(0,1,3,10,15,21)
a5: Array[Int] = Array(0, 1, 3, 10, 15, 21)

scala> a5.segmentLength(_<15,2)
res20: Int = 2

3.索引

indicesisDefineAtindexOfindexOfSlice
indexWherelastIndexOflastIndexOfSlicelastIndexWhere

 

 

 

方法名：indices
描述：  返回当前序列索引集合

返回类型：Range 
示例：

scala> a1.indices
res21: scala.collection.immutable.Range = Range 0 until 3

方法名：isDefineAt
描述： isDefineAt(index)   判断序列中是否存在指定索引

返回类型：Boolean
示例：

scala> a1.isDefinedAt(2)
res23: Boolean = true
scala> a1.isDefinedAt(5)
res24: Boolean = false

方法名：indexOf
描述：indexOf(E,(fromIndex)) 返回元素E 在序列中第一次出现的索引，也可以指定索引 （包括）from从左向右开始查找，找不到返回-1；

返回类型：Int
示例：

scala> a1.indexOf(2)
res26: Int = 1
scala> a1.indexOf(4)
res27: Int = -1
scala> a1.indexOf(2,1)
res29: Int = 1

方法名：indexOfSlice
描述：indexOfSlice(GenSeq,(fromIndex))检测当前序列中是否包含序列 that，并返回第一次出现该序列的索引

返回类型：Int
示例：

scala> val b = Array(2, 3)
b: Array[Int] = Array(2, 3)

scala> a1.indexOfSlice(b)
res33: Int = 1

方法名：indexWhere
描述：indexWhere(p:B=>Boolean)返回当前序列中第一个满足条件 p 的元素的索引,可以指定从索引 from 开始查找

返回类型：Int
示例：

scala> val a = Array(1, 2, 3, 4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> a.indexWhere(_>2)
res40: Int = 2

scala> a.indexWhere(_>2,3)
res41: Int = 3

方法名：lastIndexOf
描述：lastIndexOf(E[,endIndex])返回元素 E 在序列中最后一次出现的索引

返回类型：Int
示例：

scala> val a = Array(1, 3, 2, 3, 4)
a: Array[Int] = Array(1, 3, 2, 3, 4)

scala> a.lastIndexOf(3)
res42: Int = 3

方法名：lastIndexOfSlice
描述： lastIndexOfSlice(GenSeq[,endIndex])检测当前序列中是否包含序列 that，并返回最后一次出现该序列的索引

返回类型：Int
示例：

scala> val a = Array(1, 2, 3, 2, 3, 4)
a: Array[Int] = Array(1, 2, 3, 2, 3, 4)

scala> val b = Array(2, 3)
b: Array[Int] = Array(2, 3)

scala> a.lastIndexOfSlice(b)
res43: Int = 3

方法名：lastIndexWhere
描述： lastIndexWhere(p:B=>Boolean)返回当前序列中最后一个满足条件 p 的元素的索引

返回类型：Int
示例：

val a = Array(1, 2, 3, 2, 3, 4)
scala> a.lastIndexWhere(_>2)
res45: Int = 5

4.提取

applyapplyOrElsecharAtfindlift
headtailtailslast 
initinitsheadOptionlastOption 

 

 

 

 

 

方法名：apply
描述： apply(index)按下标取数组数据

返回类型：T(数组中的元素类型)
示例：

scala> a1
res47: Array[Int] = Array(1, 2, 3)

scala> a1.apply(1)
res48: Int = 2

方法名：applyOrElse
描述： applyOrElse(index,{item:Int=>default value})，根据下标取数组元素，如果越界，则返回默认值，第二个参数为偏函数

返回类型：结果泛型类型取数组类型和默认值类型的共同最小父类
示例：

scala> a1.applyOrElse(0,{i:Int=>None})
res52: Any = 1

scala> a1.applyOrElse(5,{i:Int=>None})
res53: Any = None

方法名：charAt
描述： charAt(index)根据索引取字符，只能是字符数组

返回类型：char
示例：

scala> var a4 = Array('a','d','g')
a4: Array[Char] = Array(a, d, g)

scala> a4.charAt(1)
res54: Char = d

方法名：head
描述： 返回序列的第一个元素，如果序列为空会报错

返回类型：T(数组中的元素类型)
示例：

scala> a1.head
res55: Int = 1

方法名：headOption
描述： 返回序列的第一个元素的 Option 类型对象，就是scala.Some 或者 None，如果序列为空，则返回 None

返回类型：Option[T]
示例：

scala> a1.headOption
res57: Option[Int] = Some(1)

scala> var lst:Array[Int]=Array()
lst: Array[Int] = Array()

scala> lst.headOption
res58: Option[Int] = None

方法名：tail
描述：  返回当前序列中不包含第一个元素的序列

返回类型：Array[T]
示例：

scala> a1.tail
res59: Array[Int] = Array(2, 3)

方法名：tails
描述： 对序列进行tail迭代

返回类型：Iterator[Array[T]]
示例：

scala> a1.tails
res23: Iterator[Array[Int]] = <iterator>

方法名：last
描述： 返回序列的最后一个元素，如果序列为空，将引发错误

返回类型：T(数组中的元素类型)
示例：

scala> a1.last
res63: Int = 3

方法名：lastOption
描述：  返回序列的最后一个元素的 Option 类型对象，如果序列为空，则返回 None

返回类型：Option[T]
示例：

scala> a1.lastOption
res64: Option[Int] = Some(3)

scala> lst.lastOption
res66: Option[Int] = None

方法名：init
描述：  返回当前序列中不包含最后一个元素的序列

返回类型：Array[T]
示例：

scala> a1.init
res67: Array[Int] = Array(1, 2)

方法名：inits
描述： 对集合中的元素进行 init 迭代操作，该操作的返回值中， 第一个值是当前序列的副本，最后一个值为空

返回类型：Iterator[Array[T]]
示例：

scala> a1.inits.foreach(x=>{x.foreach(print);println})
123
12
1

方法名：find
描述： 查找第一个满足条件的元素

返回类型：Option[T]
示例：

scala> a1.find(_>1)
res69: Option[Int] = Some(2)

方法名：lift
描述：lift(index)返回该索引处的Option类的值

返回类型：Option[T]
示例：

scala> a1.lift(1)
res25: Option[Int] = Some(1)

scala> a1.lift(5)
res26: Option[Int] = None

5.删除、过滤

dropdropRightdropWhile
filterwithFilterfilterNot

 

 

 

方法名：drop
描述： drop(n) 删除数组左边的n个元素

返回类型：Array[T]
示例

scala> a1.drop(2)
res70: Array[Int] = Array(3)

方法名：dropRight
描述：dropRight(n) 删除数组右边的n个元素

返回类型：Array[T]
示例

scala> a1.dropRight(1)
res73: Array[Int] = Array(1, 2)

scala> a1.dropRight(4)
res74: Array[Int] = Array()

方法名：dropWhile
描述： dropWhile(p:Type=>Boolean)删除数组中符合条件的元素，若第一个元素就不符合条件，则不删除，从第一个符合条件的开始删除，到第一个不符合条件的结束

返回类型：Array[T]
示例

scala> a1.dropWhile(_%2==0)
res77: Array[Int] = Array(1, 2, 3)

scala> a1.dropWhile(_%2==1)
res78: Array[Int] = Array(2, 3)

方法名：filter
描述： filter(p:Type=>Boolean)保留满足条件的元素

返回类型：Array[T]
示例

scala> a1.filter(_>2)
res79: Array[Int] = Array(3)

scala> a1.filter(_%2==0)
res80: Array[Int] = Array(2)

方法名：withFilter
描述：withFilter(p:Type=>Boolean)保留满足条件的元素

返回类型：FilterMonadic[T,Array[T]]
示例

scala> a1.withFilter(_%2==0).map(x=>x)
res83: Array[Int] = Array(2)

scala> a1.withFilter(_%2==1).map(x=>x)
res84: Array[Int] = Array(1, 3)

方法名：filterNot
描述： filterNot(p:Type=>Boolean)移除满足条件的元素

返回类型：Array[T]
示例


scala> val a = Array(1, 2, 3, 4, 0)
a: Array[Int] = Array(1, 2, 3, 4, 0)

scala> a.filterNot(x => x > 2)
res85: Array[Int] = Array(1, 2, 0)

6.包含

containscontainsSlicestartsWithendsWith
collectcollectFirstforallexists

 

 

 

方法名：contains
描述： contains(E) 判断序列中是否包含E

返回类型：Boolean
示例

scala> a1.contains(2)
res86: Boolean = true

方法名：containsSlice
描述：containsSlice(seq) 判断当前序列中是否包含另一个序列

返回类型：Boolean
示例

scala> a1.containsSlice(Array(1,2))
res87: Boolean = true

scala> a1.containsSlice(Array(1,3))
res88: Boolean = false

方法名：startsWith
描述： startsWith(seq) 当前序列是否以参数序列开始

返回类型：Boolean
示例

scala> a1.startsWith(Array(1,2))
res90: Boolean = true

方法名：endsWith
描述：endsWith(seq)当前序列是否以参数序列结尾

返回类型：Boolean
示例

scala> a1.endsWith(Array(3,4))
res91: Boolean = false

scala> a1.endsWith(Array(3))
res92: Boolean = true

scala> a1.endsWith(Array(2,3))
res93: Boolean = true

方法名：collect
描述： collect(PartialFunction)输入参数类型为偏函数，对序列中的元素进行转换

返回类型：Array[T]
示例

scala> a1.collect({case i if i%2==1 =>2*i})
res96: Array[Int] = Array(2, 6)

方法名：collectFirst
描述：查找序列中第一个符合偏函数的元素  返回Option类型

返回类型：Option[T]
示例

scala> a1.collectFirst({case i if i%2==0 =>i})
res97: Option[Int] = Some(2)

方法名：forall
描述：forall(p:T=>Boolean)集合中的元素是否都满足条件

返回类型：Boolean
示例

scala> val a = Array(1, 2, 3, 4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> a.forall(x => x > 0)
res98: Boolean = true

scala> a.forall(x => x > 2)
res99: Boolean = false

方法名：exists
描述： exists(p:T=>Boolean)判断当前数组是否包含符合条件的元素

返回类型：Boolean
示例

scala> a1.exists(x=>x==3)
res100: Boolean = true

7.比较

canEqualsameElementscorresponds

 

 

方法名：canEqual
描述： 两个集合之间是否可以比较,集合中都可以比但equals比较地址

返回类型：Boolean
示例

scala> a1.canEqual(a2)
res101: Boolean = true

方法名：sameElements
描述： sameElements(GenSeq)两个序列是否值相同，长度相同，同一索引下的值相同

返回类型：Boolean
示例

scala> val a = Array(1, 2, 3, 4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> val b = Array(1, 2, 3, 4)
b: Array[Int] = Array(1, 2, 3, 4)

scala> val c = Array(1, 3, 2, 4)
c: Array[Int] = Array(1, 3, 2, 4)

scala> a.sameElements(b)
res102: Boolean = true

scala> a.sameElements(c)
res103: Boolean = false

方法名：corresponds
描述： corresponds(GenSeq)((x,y)=>Boolean) a1和a2长度相同,同一位置的元素必须符合条件

返回类型：Boolean
示例

scala> a.corresponds(b)(_==_)
res104: Boolean = true

   8.遍历

foreachiteratorisTraversableAgainrepr

 

 

方法名：foreach
描述： foreach(p:T=>U)遍历输出

返回类型：Unit
示例

scala> a.foreach(x => println(x * 10))
10
20
30
40

方法名：iterator
描述： 获得集合迭代器

返回类型：Iterator[T]
示例

scala> a
res110: Array[Int] = Array(1, 2, 3, 4)

scala> a.iterator
res111: Iterator[Int] = <iterator>

scala> a.iterator.next
res112: Int = 1

方法名：isTraversableAgain
描述： 是否可以重复遍历

返回类型：Boolean
示例

scala> a.isTraversableAgain
res113: Boolean = true

scala> a.iterator.isTraversableAgain
res114: Boolean = false

方法名：repr
描述：将对象转化为供解释器读取的形式

返回类型：Array[T]
示例

scala> a.repr
res115: Array[Int] = Array(1, 2, 3, 4)

  9.排序、排列、反转、转置

combinationspermutationstranspose
sortedsortWithsortBy
reversereverseIteratorreverseMap
 
 
 
 
 
 
 
 
方法名：combinations
描述：combinations(n)排列组合，不考虑顺序，n任意选择集合中n个集合组合
返回类型：Iterator[Array[T]]
示例 
scala> a2.combinations(2).foreach(x=>{x.foreach(print);println()})
ab
ac
bc
 
方法名：permutations
描述：排列组合会选出所有排列顺序不同的字符组合，与 combinations 不同的是，对于相同的字符组合，比如 “abc”、“cba”，视为不同的组合
返回类型：Iterator[Array[T]]
示例 
scala> a2.permutations.foreach(x=>{x.foreach(print);println()})
abc
acb
bac
bca
cab
cba

方法名：transpose
描述：矩阵转置

返回类型： Array[Array[T]] 
示例

scala> var a = Array(Array(1,2),Array(3,4))
a: Array[Array[Int]] = Array(Array(1, 2), Array(3, 4))

scala> a.transpose
res120: Array[Array[Int]] = Array(Array(1, 3), Array(2, 4))

方法名：sorted
描述： 默认升序排列

返回类型：Array[T]
示例

scala> val a = Array(3, 2, 1, 4)
a: Array[Int] = Array(3, 2, 1, 4)

scala> a.sorted
res121: Array[Int] = Array(1, 2, 3, 4)

方法名：sortWith
描述：自定义排序方法

返回类型：Array[T]
示例

scala> a.sortWith(_<_)
res122: Array[Int] = Array(1, 2, 3, 4)

scala> a.sortWith(_>_)
res123: Array[Int] = Array(4, 3, 2, 1)

方法名：sortBy
描述：按指定的排序规则对序列排序

返回类型：Array[T]
示例

scala> a.sortBy(x=>x)
res124: Array[Int] = Array(1, 2, 3, 4)

scala> a.sortBy(x=>x*(-1))
res125: Array[Int] = Array(4, 3, 2, 1)

方法名：reverse
描述：反转序列

返回类型：Array[T]
示例

scala> a1
res127: Array[Int] = Array(1, 2, 3)
scala> a1.reverse
res128: Array[Int] = Array(3, 2, 1)

方法名：reverseIterator
描述：生成反向迭代器

返回类型：Iterator[T]
示例

scala> a2
res47: Array[String] = Array(a, b, c)

scala> a2.reverseIterator.foreach(x=>println(x))
c
b
a

方法名：reverseMap
描述：同 map，方向相反

返回类型：Array[T]
示例

scala> a1.reverseMap(_+1)
res5: Array[Int] = Array(4, 3, 2)

10.拼接、替换

addStringmkStringstringPrefixpatch
padToupdateupdated 

 

 

 

方法名：addString
描述：addString(StringBuilder,[start,seq,end])将数组拼接为字符串，需要StringBuilder对象

返回类型：StringBuilder
示例

import scala.collection.mutable.StringBuilder
var builder = new mutable.StringBuilder
println(a1.addString(builder,","))  => 1,2,3,4

方法名：mkString
描述：将序列中所有元素拼接成一个字符串，可以设置参数：mkString(start, sep, end) 将序列中所有元素拼接成一个字符串，以 start 开头，以 sep 作为元素间的分隔符，以 end 结尾)
返回类型：String

示例

scala> a1.mkString(",")
res131: String = 1,2,3

方法名：stringPrefix
描述：返回toString的前缀

返回类型：String
示例

方法名：patch
描述：patch(startIndex,Genseq,num) 批量替换，将元序列中从startIndex(包含)的num个元素替换成Genseq，元数组不变

返回类型：Array[T]
示例

val a1=Array.range(1,4)
val a2=Array("a","b","c")
a1.patch(1,a2,1)
=> Array(1, a, b, c, 3)

方法名：padTo
描述：padTo(len,e) 如果当前长度小于len,则扩展序列长度至len,并使用e填充len-size,结果泛型类型取数组类型和默认值类型的共同最小父类，元数组不变

返回类型：Array[T]
示例

scala> a1.padTo(5,"a")
res7: Array[Any] = Array(1, 2, 3, a, a)

scala> a1.padTo(3,0.1)
res10: Array[AnyVal] = Array(1, 2, 3)

方法名：update
描述：将数组中pos下标位置的元素的值改为V,元数组改变

返回类型：Unit
示例

scala> a1.update(0,4)

scala> a1
res18: Array[Int] = Array(4, 2, 3)

方法名：updated
描述： 将数组中pos下标位置的元素的值改为V,元数组不改变

返回类型：Array[T]
示例

scala> a1.updated(0,4)
res15: Array[Int] = Array(4, 2, 3)

scala> a1
res16: Array[Int] = Array(1, 2, 3)

11.数学

maxmaxByminminByproduct
sumdiffintersectdistinctcount

 

 

 

方法名：max
描述：  返回序列中最大的元素

返回类型：T(数组中的元素类型)
示例

scala> a2.max
res19: String = c

scala> a1.max
res20: Int = 4

方法名：maxBy
描述： 返回序列中符合条件的第一个元素(找不到满足条件的元素返回一个元素)

返回类型：T(数组中的元素类型)
示例

scala> a1
res22: Array[Int] = Array(4, 2, 3)

scala> a1.maxBy(_>2)
res23: Int = 4

scala> a1.maxBy(_<1)
res24: Int = 4

方法名：min
描述： 返回序列中最小的元素
示例

scala> a1.min
res27: Int = 2

scala> a2.min
res28: String = a

方法名：minBy
描述：  返回序列中不符合条件的第一个元素(找不到满足条件的元素返回一个元素)

返回类型：T(数组中的元素类型)
示例

scala> a1.minBy(_>3)
res26: Int = 2

方法名：product
描述：所有元素的乘积

返回类型：T(数组中的元素类型)
示例

scala> b
res32: List[Double] = List(2.3, 3.4, 5.3)

scala> b.product
res33: Double = 41.446

方法名：sum
描述：所有元素的和

返回类型：T(数组中的元素类型)
示例

scala> a1
res38: Array[Int] = Array(4, 2, 3)

scala> a1.sum
res39: Int = 9

方法名：diff
描述： a1.diff(a2)返回a1相对于a2的差集,a1不在a2中的元素

返回类型：Array[T]
示例

scala> a2
res42: Array[String] = Array(a, b, c)

scala> val a3=Array("b","c","e")
a3: Array[String] = Array(b, c, e)

scala> a2.diff(a3)
res43: Array[String] = Array(a)

方法名：intersect
描述：a1.intersect(a2)返回a1相对于a2的交集

返回类型：Array[T]
示例

scala> a2.intersect(a3)
res44: Array[String] = Array(b, c)

方法名：distinct
描述：数组元素去重

返回类型：Array[T]
示例

scala> val a5=Array("b","c","e","c")
a5: Array[String] = Array(b, c, e, c)

scala> a5.distinct
res45: Array[String] = Array(b, c, e)

方法名：count
描述：count(p:T=>Boolean) 统计符合条件的元素数量

返回类型：Int
示例

scala> a1
res48: Array[Int] = Array(4, 2, 3)

scala> a1.count(_>2)
res49: Int = 2

12.截取

sliceviewslidingspansplitAt
subSequencetaketakeRighttakeWhile 

 

 

 

方法名：slice
描述：slice(fromIndex,toIndex) 截取fromIndex~toIndex元素前包后不包

返回类型：Array[T]
示例

scala> a5
res50: Array[String] = Array(b, c, e, c)

scala> a5.slice(1,3)
res51: Array[String] = Array(c, e)

方法名：view
描述：view(fromIndex,toIndex)截取fromIndex~toIndex元素前包后不包

返回类型：IndexedSeqView[T,Array[T]]
示例

scala> a1.view(1,3)
res54: scala.collection.mutable.IndexedSeqView[Int,Array[Int]] = SeqViewS(...)

方法名：sliding
描述：sliding(size[,step])从0开始以step默认为1为步伐滑动，并取出当前位置开始的size个元素

返回类型：Iterator[Array[T]]
示例

scala> a1
res56: Array[Int] = Array(4, 2, 3)

scala> a1.sliding(2)
res57: Iterator[Array[Int]] = <iterator>

scala> a1.sliding(2).toArray
res58: Array[Array[Int]] = Array(Array(4, 2), Array(2, 3))

方法名：span
描述：span(p:T=>Boolean)从第一个元素开始，到第一个不满足条件的元素为止，存放于第一个数组,其余的存放于第二个数组,如果第一个元素不满足，则第一个数组长度为0

返回类型：(Array[T],Array[T]) 
示例

scala> a1.span(_>4)
res60: (Array[Int], Array[Int]) = (Array(),Array(4, 2, 3))

scala> a1.span(_%2==0)
res61: (Array[Int], Array[Int]) = (Array(4, 2),Array(3))

方法名：splitAt
描述：splitAt(pos) 从指定位置开始，将数组拆分为两个数组

返回类型：(Array[T],Array[T])
示例

scala> a2.splitAt(1)
res62: (Array[String], Array[String]) = (Array(a),Array(b, c))

方法名：subSequence
描述：subSequence(start,end)只能用于字符序列,前包后不包

返回类型：CharSequence
示例

scala> b
res66: Array[Char] = Array(a, b, c, d)

scala> b.subSequence(1,4)
res67: CharSequence = bcd

方法名：take
描述：take(n)  从左边提取n个元素的子序列

返回类型：Array[T]
示例

scala> b.take(2)
res68: Array[Char] = Array(a, b)

方法名：takeRight
描述：takeRight(n)从右边提取n个元素的子序列

返回类型：Array[T]
示例

scala> b.takeRight(2)
res69: Array[Char] = Array(c, d)

方法名：takeWhile
描述：takeWhile(p:T=>Boolean)返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列

返回类型：Array[T]
示例

 

13.zip

unzipunzip3zipzipAllzipWithIndex

 

 

方法名：unzip
描述：将两个元素构成的元祖数组的第一个元素和第二个元素分别组成两个数组并封装为元祖

返回类型：（Array[T]，Array[T]）
示例

var arr = Array(("henry","male"),("pola","female"),("ariel","female"))
arr.unzip  =>(Array(henry, pola, ariel),Array(male, female, female))

方法名：unzip3
描述：将三个元素构成的元祖数组封装成分别由三个元素构成数组的元祖

返回类型：（Array[T]，Array[T]，Array[T]）
示例

scala> var arr1 = Array(("henry","male",18),("pola","female",19),("ariel","female",20))
arr1: Array[(String, String, Int)] = Array((henry,male,18), (pola,female,19), (ariel,female,20))

scala> arr1.unzip3
res79: (Array[String], Array[String], Array[Int]) = (Array(henry, pola, ariel),Array(male, female, female),Array(18, 19, 20))

方法名：zip
描述：如果两个序列长度相等，将两个序列同一位置元素组成元祖数组

 返回类型：Array[(T, T)]
示例

val a2=Array("a","b","c")
val a3=Array(1,2,3)
a2.zip(a3)  =>  Array((a,1), (b,2), (c,3))

方法名：zipAll
描述：zipAll(GenSeq,thisEle,thatEle) 同 zip ，但是允许两个序列长度不同，不足的自动填充，如果当前序列短，不足的元素填充为 thisElem，如果 that 序列短，填充为 thatElem
示例

val a4=Array("a","b","c","d")
val a5=Array(1,2,3)
a4.zipAll(a5,"m",0)   => Array((a,1), (b,2), (c,3), (d,0))
a5.zipAll(a4,"m",0)   => Array((1,a), (2,b), (3,c), (m,d))

方法名：zipWithIndex
描述：序列中的元素和他的索引构成二元元祖数组
示例

a2.zipWithIndex  => Array((a,0), (b,1), (c,2))

 

14.聚合、分组

/: :\foldfoldLeftfoldRight
scanscanLeftscanRightaggregategrouped
groupBypartitionpar  

 

 

 

 

方法名：/:  <=>fold/foldLeft
描述：fold/foldLeft(initVal)(p:(T,T)=>T)从左向右进行计算， arrItem左到右依次取值

返回类型：T
示例

scala> a1
res87: Array[Int] = Array(4, 2, 3)

scala> println(a1.fold(0)((x, y) => {
     | println(s"$x\t$y")
     | x + y
     | }))
0       4
4       2
6       3
9

方法名：:\ <=>foldRight
描述：foldRigh(initVal)(p:(T,T)=>T)从右向左进行计算， arrItem左到右依次取值

返回类型：T
示例

scala> val a1= Array(4, 2, 3)
a1: Array[Int] = Array(4, 2, 3)

scala> println(a1.foldRight(0)((x, y) => {
     |   println(s"$x\t$y")
     |   x + y
     | }))
3       0
2       3
4       5
9

方法名：scan/scanLeft()
描述：从左向右计算，每一步的计算结果放到一个新的集合中返回

返回类型：Array[T]
示例

scala> a1
res3: Array[Int] = Array(4, 2, 3)

scala> a1.scan(0)(_+_)
res4: Array[Int] = Array(0, 4, 6, 9)

scala> a1.scanLeft(0)(_+_)
res5: Array[Int] = Array(0, 4, 6, 9)

方法名：scanRight
描述：从右向左计算，每一步的计算结果放到（从右向左放）一个新的集合中返回

返回类型：Array[T]
示例

scala> a1.scanRight(0)(_+_)
res6: Array[Int] = Array(9, 5, 3, 0)

方法名：aggregate
描述：aggregate(initValue)(mapCal,reduceCal)聚合函数，接受多个输入，并按照一定的规则运算以后输出一个结果值。map端聚合mapCal生效，不走reduce端reduceCal失效；par分区,mapCal->reduceCal

返回类型：T
示例

val lst = List[Int](1,2,3,4)
var mapAdd=(x:Int,y:Int)=>{
     var z=x+y
     println(s"map:$x + $y =$z")
     z
 }
 var redAdd=(x:Int,y:Int)=>{
     var z=x+y
     println(s"red:$x + $y =$z")
     z
 }
 println(lst.par.aggregate(0)(mapAdd,redAdd))

map:0 + 3 =3
map:0 + 4 =4
map:0 + 1 =1
map:0 + 2 =2
red:3 + 4 =7
red:1 + 2 =3
red:3 + 7 =10
10

println(lst.aggregate(0)(mapAdd,redAdd))
map:0 + 1 =1
map:1 + 2 =3
map:3 + 3 =6
map:6 + 4 =10
10

方法名：grouped
描述：按指定数量分组，每组有size数量个元素，返回一个集合，当指定数量超出数组元素的长度时，分为一组

返回类型：Iterator[Array[T]]
示例

scala> a1
res11: Array[Int] = Array(4, 2, 3)

scala> a1.grouped(1).toArray
res12: Array[Array[Int]] = Array(Array(4), Array(2), Array(3))

scala> a1.grouped(2).toArray
res13: Array[Array[Int]] = Array(Array(4, 2), Array(3))

方法名：groupBy
描述：groupBy(x:T=>K)=>Map 返回值是Map类型，每个key对应一个数组

返回类型：Map[T,Array[T]] 
示例

scala> a1.groupBy(_ match {
     | case i if(i%2==0) => "even"
     | case i  => "odd"
     | })
res14: scala.collection.immutable.Map[String,Array[Int]] = Map(odd -> Array(3), even -> Array(4, 2))

 

方法名：partition
描述：partition(p:T=>Boolean)将序列拆成满足和不满足条件的两个序列

返回类型：（Array[T]，Array[T]）
示例

scala> a1.partition(_%2==0)
res16: (Array[Int], Array[Int]) = (Array(4, 2),Array(3))

方法名：par
描述：开启分区

返回类型：ParArray[T]
示例

 

15.变形

transformmapflattenflatMapreduce
reduceLeftreduceRightreduceOptionreduceLeftOptionreduceRightOption

 

 

 

方法名：map
描述： 对序列中的元素进行 f 操作，返回生成的新序列

返回类型：Array[T]
示例

scala> a1.map(_*2)
res17: Array[Int] = Array(8, 4, 6)

方法名：flatten
描述： flatMap = map + flatten 即先对集合中的每个元素进行map，再对map后的每个元素（map后的每个元素必须还是集合）中的每个元素进行flatten

返回类型：Array[T]
示例

scala> var a4=Array(Array(1,2,3),Array(4,5,6))
a4: Array[Array[Int]] = Array(Array(1, 2, 3), Array(4, 5, 6))

scala> a4.flatten
res18: Array[Int] = Array(1, 2, 3, 4, 5, 6)

方法名：flatMap
描述：扁平化操作，通常配合map使用；将二维数组的所有元素联合在一起，形成一个一维数组返回。

返回类型：Array[T]
示例

scala> val arr = Array(Array(1, 2, 3), Array(4, 5, 6), Array(7, 8, 9))
arr: Array[Array[Int]] = Array(Array(1, 2, 3), Array(4, 5, 6), Array(7, 8, 9))

scala> arr.flatMap(x=>x)
res23: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

方法名：reduce/reduceLeft
描述：reduce(p:(T,T)=>T)从左向右计算，不需要初始值

返回类型：T
示例

scala> a1.reduceLeft(_+_)
res25: Int = 9

scala> a1.reduce(_+_)
res26: Int = 9

方法名：reduceRight
描述：reduceRight(p:(T,T)=>T)从右向左计算，不需要初始值

返回类型：T
示例

 

方法名：reduceOption/reduceLeftOption
描述：reduceOption(p:(T,T)=>T) =>Option[T]

返回类型：Array[T]
示例

scala> a1.reduceOption(_+_)
res27: Option[Int] = Some(9)

方法名：reduceRightOption
描述：reduceRightOption(p:(T,T)=>T) =>Option[T]

返回类型：Array[T]
示例

16.转化为其他类型

toarraytoArraytoBuffer
toIndexedSeqtoIterabletoIteratortoList
toMaptoSeqseqtoSet
toStreamtoTraversabletoVectorgenericBuilder

 

 

 

 

 

17.其他

orElseandThencomposerunWith
elemManifestelemTagdeepcompanion

 

 

 

方法名：andThen
描述：f1和f2只有一个参数且类型相同，f1的输出为f2的输入

返回类型：T
示例

val add=(x:Int)=>{
	println("add")
	x+3}
		
val mul=(x:Int)=>{
	println("mul")
	x*3}
		
def f=add andThen(mul)
println(f(10))=>39

方法名：compose
描述：f1和f2只有一个参数且类型相同，f2的输出为f1的输入

返回类型：T
示例

def f=add compose(mul) 
println(f(10))=>33

 

蒙奇D婵
关注
Scala函数式编程
03-18
　这本书所讲授的，正是基于 Scala 的函数式编程基础。基于 Scheme、Haskell 等老牌函数式语言的传统教材的问题在于，相关语言的语法和思维方式与读者现有的知识体系迥异，容易造成较为陡峭的入门门槛。此外，由于...
scala中的函数和方法
liyang7916的博客
04-09 2185
一：scala中的函数 Scala中，函数上升和变量同等的位置，或者说函数也是一种变量； Scala中的函数可以作为实参传递给另一个函数； 函数可以作为返回值； 函数可以赋值给变量(这个变量需符合函数的类型的变量)； 函数可以存储在数据结构之中。 函数如同普通变量一样，也具有类型； 函数的定义可以有很多种，因此需要掌握最基本的定义方法： 1，函数的基本定义 val f1 = (a: Int, b: Int) => a + b val f2 = ((a: Int, b: Int.
scala 方法大全（你必须掌握的百种方法！！！）
WCL0520的博客
09-10 1160
–scala函数整合 – ++ 合并集合，并返回一个新的数组 var k = Array(1,2,3,"a") var e = Array("a","b","c") k++e 结果：Array(1,2,3,a,a,b,c)(新数组) – ++：并数组，结果由冒号右边类型决定 var d = List(1,2,3,4) var f = Array("a","b","c") d++:f 结果：Array(1, 2, 3, 4, a, b, c) f++:d 结果：List(a, b, c, 1, 2, 3,
从新手到高手：Scala函数式编程完全指南，Scala 数组（16）
最新发布
qq_45746668的博客
07-15 281
Scala 语言中提供的数组是用来存储固定大小的同类型元素，数组对于每一门编辑应语言来说都是重要的数据结构之一。 声明数组变量并不是声明 number0、number1、...、number99 一个个单独的变量，而是声明一个就像 numbers 这样的变量，然后使用 numbers[0]、numbers[1]、...、numbers[99] 来表示一个个单独的变量。数组中某个指定的元素是通过索引来访问的。 数组的第一个元素索引为0，最后一个元素的索引为元素总数减1。
Scala函数详细介绍
xiaoxionghanhan的博客
10-21 1970
Scala函数 函数是Scala的核心 //函数的定义 def 函数名[参数列表]:[返回值类型]={ 函数体 return[表达式] } //函数调用 函数名[参数列表] 命名参数 //通常情况下，传入的参数与函数定义的参数列表应一一对应 def printName(first:String, last:String) = { println(first + " " + last) } printName("John","Smith") //也允许使用任意顺序传入参数 pr
scala 数组的 head tail init last 都是什么作用
艾斯比
01-27 3738
背景 今天在看我们公司的 spark 项目. 其中有看到调用数组的 head 方法. 于是搜索相关信息 作用 下图可以很形象地表达含义 head 表示数组的第一个元素 tail 表示数组除去 head 后的数组 last 表示数组的最后一个元素 init 表示数组除去 last 后的数组 @Test def testHead() = { val array = Array(1, 2, 3, 4, 5) println(array.head) println(ar
Scala函数式编程.pdf
05-18
函数式编程（FP）是一种...《Scala函数式编程》是针对希望学习FP并将它应用于日常编码中的程序员而写的，内容包括：函数式编程的概念；函数式编程相关的各种“为什么”和“怎么做”；如何编写多核程序；练习和检测。
Scala中的Option
Mr.Phoebe的专栏
02-13 3089
Scala中的Option 避免null使用 大多数语言都有一个特殊的关键字或者对象来表示一个对象引用的是“无”，在Java，它是null。 写Java程序的时候，经常会碰到没有有意义的东西可以返回，我们返回null。 在Java 里，null 是一个关键字，不是一个对象，所以对它调用任何方法都是非法的。因此调用方必须检查返回值，不然会有NullPointerException的异常。 ...
为Scala初学者准备的基础知识
weixin_34146986的博客
10-19 205
2019独角兽企业重金招聘Python工程师标准>>> ...
scala函数总结
qq_34566673的博客
09-12 1211
数组函数大全： 方法名：++ 描述：合并两个序列，若类型不同以左侧类型为主，左侧集合的值在新集合的左侧 返回值：左边序列类型 方法名：++: 描述：合并两个序列，若类型不同则以右边的类型为主， 返回值：右边序列的类型 方法名：+: 描述：在数组前面添加一个元素，在数组的头部添加，冒号要离数组近 返回值：数组（类型依据集合中的元素类型而定） 方法名：/: 描述：对数组中的所有元素从左向右遍历，进行相同的迭代操作，是flodLeft的简写 返回值：计算的结果 方法名：:+ 描述：在数组后面添加一个元素
scala常用函数大全
qq_41704237的博客
08-02 1719
一、添加、更新元素函数 ++ 两个集合相加，返回一个左边集合类型的新集合 val a = Array(1, 2) val b = Array(3, 4) val c = a ++ b println(c.mkString(",")) // 1,2,3,4 ++：两个集合相加，返回一个右边集合类型的新集合 val a = List(1, 2) val b = scala.collection.mutable.LinkedList(3, 4) val c = a ++:
Scala数组集合函数以及案例大全（一看就懂）！！！！
Better0417的博客
09-12 929
Scala数组大全++++：+：:+/::\addString(b)addString(b,sep)aggregateapplycanEqualcharAtclonecollectcollectFirstcombinationscomposecontainscontainsSlicecopyToArray(xs)copyToArray(xs, start)copyToArray(xs, start, len)copyToBuffercorrespondscountdiffdistinctdropdropRi
Scala的高阶函数（2）
weixin_49165958的博客
10-27 393
1.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' c
Scala函数
m0_54357806的博客
05-30 498
Scala函数
Scala 基础函数
专注基础架构领域
12-23 686
分布式高并发语言Go、R、Erlang等等为何选择Scala？Spark是大数据处理的核心方式，用scala语言编写！Kafka分布式发布订阅消息系统，由LinkedIn捐给Apache，以极高的吞吐量著称，是目前最火爆的MQ，用scala语言编写！Flink最新一代分布式海量数据计算框架，Alibaba收购并开源，自己开发Blink分支，Scala语言编写！为什么学习scala1.基于强大的java基础。（.class文件）2.大数据以及分布式的开发项目中（服务）都是基于java开发的。
Scala函数基础
2401_84048521的博客
04-17 655
总而言之，面试官问来问去，问的那些Redis知识点也就这么多吧，复习的不够到位，知识点掌握不够熟练，所以面试才会卡壳。将这些Redis面试知识解析以及我整理的一些学习笔记分享出来给大家参考学习《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
Scala | Scala的四种函数种类
XING_Gou的博客
07-25 973
Scala的四种函数种类 知识点： scala的函数种类可分为4种: ①成员函数,函数定义在类的内部,作为类的成员,即为成员函数 ②本地函数,定义在函数内的函数,即为本地函数 重点:③匿名函数,特点:没有函数名;通过=>来连接参数列表和方法体 关键是匿名函数的作用: 匿名函数可以当做参数进行赋值 ,比如:val f2=(a:Int,b:Int)=>{a+b} 匿名函数可以当做参数进行传递,比如:def f3(a:Int,b:Int,f:(Int,Int)=>Int)={f(a,b)}
探索Scala函数式编程
"Functional Programming in Scala 是一本针对程序员的深入教程，旨在介绍函数式编程（FP）并将其应用于日常编码工作。这本书适用于没有Scala或FP经验的读者，它以清晰、简洁的方式从基础开始教授FP，同时解释了其...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值