scala数组函数（持续更新）

最新推荐文章于 2024-03-06 19:38:14 发布
最新推荐文章于 2024-03-06 19:38:14 发布
阅读量843 收藏
点赞数 1
分类专栏： scala 文章标签： scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Of_the_new/article/details/108440112
版权

具体解析请点击相应函数查看

++counthasDefiniteSizemaxBysameElementstoBuffer
++: deepheadminscantoIndexedSeq
+:diffheadOptionminByscanLefttoIterable
/:distinctindexOfmkStringscanRighttoIterator
:+dropindexOfSlicenonEmptysegmentLengthtoList
:\ dropRightindexWhereorElseseqtoMap
addStringdropWhileindicespadTosizetoSeq
aggregateelemManifestinitparslicetoSet
andThenelemTaginitspartitionslidingtoStream
applyendsWithintersectpatchsortBytoTraversable
applyOrElseexistsisDefinedAtpermutationssortWithtoVector
arrayfilterisEmptyprefixLengthsortedtransform
canEqualfilterNotisTraversableAgainproductspantranspose
clonefinditeratorreducesplitAtunion
collectflatMaplastreduceLeftstartsWithunzip
collectFirstflattenlastIndexOfreduceLeftOptionstringPrefixunzip3
combinationsfoldlastIndexOfSlicereduceOptionsumupdate
companionfoldLeftlastIndexWherereduceRighttailupdated
composefoldRightlastOptionreduceRightOptiontailsview
containsforalllengthreprtakewithFilter
containsSliceforeachlengthComparereversetakeRightzip
copyToArraygenericBuilderliftreverseIteratortakeWhilezipAll
copyToBuffergroupBymapreverseMaptozipWithIndex
correspondsgroupedmaxrunWithtoArray
++ 将两个数组合并成一个新的数组 
scala> var a = Array("aaa","bbb","ccc")
a: Array[String] = Array(aaa, bbb, ccc)
//定义了一个String类型的数组a，a的内容为aaa,bbb,ccc

scala> var b = Array(1,2,3,4)
b: Array[Int] = Array(1, 2, 3, 4)
//定义了一个Int类型的数组b，a的内容为1,2,3,4

scala> var c = a++b
c: Array[Any] = Array(aaa, bbb, ccc, 1, 2, 3, 4)
//数组a和数组b合并成数组c，因为a为String类型，b为Int类型，所以合并的c为Any类型，c的内容为：aaa, bbb, ccc, 1, 2, 3, 4

++:
和上面的++类似，但是这里可以将数组 与其他类型的结构合并，冒号后面的结构类型决定了结果的结构类型 

scala> var a = Array("aaa","bbb","ccc")
a: Array[String] = Array(aaa, bbb, ccc)
//定义了一个String类型的数组a，a的内容为aaa,bbb,ccc

scala> var c = List(1,2,3,4)
c: List[Int] = List(1, 2, 3, 4)
//定义了一个Int类型的List的c，c的内容为1,2,3,4

scala> var d = a++:c
d: List[Any] = List(aaa, bbb, ccc, 1, 2, 3, 4)
//这里d为list类型

scala> var f = c++:a
f: Array[Any] = Array(1, 2, 3, 4, aaa, bbb, ccc)
//f为Array类型

+:和:+
在数组的首位(+:)或者末尾(:+)添加一个元素，并返回一个新数组。冒号一定是 紧挨着数组，不然会报错 

scala> var b = Array(1,2,3,4)
b: Array[Int] = Array(1, 2, 3, 4)
//定义了一个Int类型的数组b，a的内容为1,2,3,4

scala> var d = 0 +: b
d: Array[Int] = Array(0, 1, 2, 3, 4)
//在首位添加

scala> var f = b :+ 0
f: Array[Int] = Array(1, 2, 3, 4, 0)
//在末尾添加
/:和:\
对数组中的所有元素进行相同的操作，（/:）foldLeft的简写，（:\）foldRight的简写

/: 的示意图
在这里插入图片描述

scala> var b = Array("a","b","c","d")
b: Array[String] = Array(a, b, c, d)
//定义了一个Int类型的数组b，a的内容为a,b,c,d

scala> ("f" /: b)(_+_)
res34: String = fabcd
//这里的意思是对数组里的元素从左开始都执行+的操作，
//第一个字符串与f合并，同时合并的结果作为左边，
//继续与下一个字符串合并

:\ 示意图
在这里插入图片描述

代码：

scala> var b = Array("a","b","c","d")
b: Array[String] = Array(a, b, c, d)
//定义了一个Int类型的数组b，a的内容为a,b,c,d

scala> (b :\ "f")(_+_)
res35: String = abcdf
//这里的意思是对数组里的元素从左开始都执行+的操作，
//第一个字符串与第二个字符串合并，
//同时合并的结果作为右边，
//继续与下一个字符串合并。直到最后与f合并
addString
将数组的内容作为字符串返回，可以指定分隔符，开始字符，结束字符 
scala> a
res128: Array[Int] = Array(1, 2, 3, 4)

//addString的几种用法
scala> a.addString
def addString(b: StringBuilder): StringBuilder
def addString(b: StringBuilder,sep: String): StringBuilder
def addString(b: StringBuilder,start: String,sep: String,end: String): StringBuilder

scala> var b = new StringBuilder
b: StringBuilder =

//只传一个数组
scala> a.addString(b)
res129: StringBuilder = 1234

scala> var b = new StringBuilder
b: StringBuilder =

//指定分隔符
scala> a.addString(b,"-")
res131: StringBuilder = 1-2-3-4

scala> var b = new StringBuilder
b: StringBuilder =

//指定分隔符，开始字符，结束字符
scala> a.addString(b,"{","-","}")
res132: StringBuilder = {1-2-3-4}
aggregate
柯里化方法，需要传入两个方法作为参数,一般用来做聚合计算 
scala> a
res143: Array[Int] = Array(1, 2, 3, 4)

//seqop: (B, Int) 这个地方的Int是因为我这个a数组是Int，实际参数是泛型T
scala> a.aggregate
def aggregate[B](z: => B)(seqop: (B, Int) => B,combop: (B, B) => B): B

//这里我先创建两个简单的函数，作为参数。取名和方法实例中一样是为了方便对应，名字可以随意。
scala> def seqno(m:Int,n:Int):Int = {
  println("seqno执行"+m+"+"+n)
  return m+n
    }
seqno: (m: Int, n: Int)Int

scala> def combop(m:Int,n:Int):Int = {
  println("combop执行"+m+"+"+n)
  return m+n
    }
combop: (m: Int, n: Int)Int

//因为我将数组打散所以不能确定那个数先执行，因此是乱的
scala> var c = a.par.aggregate(10)(seqno,combop)
seqno执行10+1
seqno执行10+2
seqno执行10+4
combop执行11+12
seqno执行10+3
combop执行13+14
combop执行23+27
c: Int = 50
andThen
连续调用函数 
scala> k
res370: Array[String] = Array(a, b, c, d)

//将字符串后面拼接上一个a
scala> val pf1:PartialFunction[String,String]={
     | case x => x+"a"
     | }
pf1: PartialFunction[String,String] = <function1>

//将字符串后面拼接上一个b
scala> val pf2:PartialFunction[String,String]={
     | case x => x+"b"
     | }
pf2: PartialFunction[String,String] = <function1>

//连续执行pf1和pf2方法
scala> k.collect(pf1 andThen pf2)
res371: Array[String] = Array(aab, bab, cab, dab)
apply --def apply(i: Int): Any
获取对应索引的值 
//取对应索引的值
scala> a.apply(1)
res376: Int = 2

//若没有这个索引则报错
scala> a.apply(4)
java.lang.ArrayIndexOutOfBoundsException: 4
  ... 32 elided
applyOrElse-- def applyOrElse[A1 <: Int, B1 >: Any](x: A1,default: A1 => B1): B1
获取对应索引的值，如果没有返回给定的值 
scala> a
res26: Array[Any] = Array(1, a, b)

scala> a.applyOrElse(1,{k:Int => "one"})
res27: Any = a

scala> a.applyOrElse(3,{k:Int => "one"})
res28: Any = one
array def array(i: Int): Any
获取对应索引的值,同apply但是只能用于Array 
scala> a
res380: Array[Int] = Array(1, 2, 3, 4)

//取对应索引的值
scala> a.array(1)
res376: Int = 2

//若没有这个索引则报错
scala> a.array(4)
java.lang.ArrayIndexOutOfBoundsException: 4
  ... 32 elided
canEqual
查看两个数组是否可以比较 
scala> a
res36: Array[Any] = Array(1, a, b)

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

scala> a.canEqual(b)
res38: Boolean = true
clone
复制数组内容给另一个数组，如果多位数组，则只能复制引用 
scala> a
res36: Array[Any] = Array(1, a, b)

scala> var c = Array(1,2,a)
c: Array[Any] = Array(1, 2, Array(1, a, b))

scala> var d = c.clone
d: Array[Any] = Array(1, 2, Array(1, a, b))

scala> a(2)='c'

scala> a
res40: Array[Any] = Array(1, a, c)

scala> c
res41: Array[Any] = Array(1, 2, Array(1, a, c))

scala> d
res42: Array[Any] = Array(1, 2, Array(1, a, c))
collect
执行偏函数，将执行完偏函数的结果返回为一个新数组 
scala> b
res43: Array[Int] = Array(1, 2, 3)

scala> val pf2:PartialFunction[Int,Int]={
     | case x if x%2==0 => x+10
     | }
pf2: PartialFunction[Int,Int] = <function1>

scala> b.collect(pf2)
res44: Array[Int] = Array(12)
collectFirst
执行偏函数，将第一个符合偏函数的值执行偏函数，返回为一个Option 
scala> b
res43: Array[Int] = Array(1, 2, 3)

scala> val pf2:PartialFunction[Int,Int]={
      case x if x%2!=0 => x+10
     }

scala> b.collectFirst(pf2)
res46: Option[Int] = Some(11)
combinations
排列组合，将数组中的元素，按着指定长度组合起来，相同索引的元素组合只能出现一次(例如这里1a和a1) 
scala> a
res58: Array[Any] = Array(1, a, c)

scala> a.combinations(2)
res47: Iterator[Array[Any]] = non-empty iterator

scala> a.combinations(2).foreach(x => println(x.mkString))
1a
1c
ac
companion
将数组转化为IndexedSeq类型 
scala> a
res58: Array[Any] = Array(1, a, c)

scala> a.companion
res59: scala.collection.generic.GenericCompanion[scala.collection.mutable.IndexedSeq] = scala.collection.mutable.IndexedSeq$@168b3791
contains
查看数组中是否包含指定元素 
scala> a
res82: Array[Any] = Array(1, a, c)

scala> a.contains(1)
res83: Boolean = true

scala> a.contains(2)
res84: Boolean = false
contains
查看数组中是否包含指定序列 
scala> a
res82: Array[Any] = Array(1, a, c)

scala> c
res85: Array[Any] = Array(1, 2, Array(1, a, c))

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

scala> c.containsSlice(Array(1,a,c))
res88: Boolean = false

scala> c.containsSlice(Array(a))
res89: Boolean = true
copyToArray
将给定数组的复制到Array类型的新数组中，从指定位置开始复制，复制给定的长度 
scala> var b =Array(1,2,3)
b: Array[Int] = Array(1, 2, 3)

scala> var d = new Array[Int](5)
d: Array[Int] = Array(0, 0, 0, 0, 0)

scala> b.copyToArray(d)

scala> d
res102: Array[Int] = Array(1, 2, 3, 0, 0)

scala> var d = new Array[Int](5)
d: Array[Int] = Array(0, 0, 0, 0, 0)

scala> b.copyToArray(d,1)

scala> d
res106: Array[Int] = Array(0, 1, 2, 3, 0)

scala> var d = new Array[Int](5)
d: Array[Int] = Array(0, 0, 0, 0, 0)

scala> b.copyToArray(d,1,2)

scala> d
res108: Array[Int] = Array(0, 1, 2, 0, 0)
copyToBuffer
将给定数组的复制的内容复制到Buffer中 
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer

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

scala> b.copyToBuffer(d)

scala> d
res116: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)
corresponds
判断两个数组长度是否相等，且每隔位置的元素是否都满足给定条件 
scala> b
res119: Array[Int] = Array(1, 2, 3)

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

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

scala> b.corresponds(f)(_<_)
res122: Boolean = false

scala> b.corresponds(k)(_<_)
res120: Boolean = true
count
计算数组中满足条件的元素有几个 
scala> b
res126: Array[Int] = Array(1, 2, 3)

scala> b.count(_>1)
res124: Int = 2

scala> b.count(_==1)
res125: Int = 1
deep
取出对应索引的值，并将值的类型给改为Any类型 
scala> b
res135: Array[Int] = Array(1, 2, 3)

scala> b.deep(1)
res136: Any = 2

scala> b.deep(3)
java.lang.ArrayIndexOutOfBoundsException: 3
  at scala.collection.mutable.ArrayOps$ofInt$.apply$extension(ArrayOps.scala:241)
  at scala.collection.mutable.ArrayOps$ofInt.apply(ArrayOps.scala:234)
  at scala.collection.mutable.ArrayLike$$anon$1.apply(ArrayLike.scala:42)
  ... 32 elided
diff
去除前面数组与后面相同的元素，同一个元素只能去除一次 
scala> var k = Array(2,3,2,3,4,5)
k: Array[Int] = Array(2, 3, 2, 3, 4, 5)

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

scala> k.diff(b)
res139: Array[Int] = Array(2, 3, 4, 5)
distinct
去除数组中重复的元素 
scala> var k = Array(2,3,2,3,4,5)
k: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.distinct
res140: Array[Int] = Array(2, 3, 4, 5)
drop
从左往右删除指定个数的元素 
scala> var k = Array(2,3,2,3,4,5)
k: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.drop(2)
res141: Array[Int] = Array(2, 3, 4, 5)

scala> k.drop(3)
res142: Array[Int] = Array(3, 4, 5)
dropRight
从右往左删除指定个数的元素 
scala> var k = Array(2,3,2,3,4,5)
k: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.dropRight(2)
res143: Array[Int] = Array(2, 3, 2, 3)
dropWhile
从左往右删除满足条件的元素，直到第一个不满足条件的元素 
scala> var k = Array(2,3,2,3,4,5)
k: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.dropWhile(x => x%2==0)
res145: Array[Int] = Array(3, 2, 3, 4, 5)
endsWith
判断数组是否以某个序列结尾 
scala> k
res157: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.endsWith(Array(4,5))
res159: Boolean = true
exists
判断数组是否有满足条件的元素 
scala> k
res157: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.exists(_>2)
res161: Boolean = true
filter
过滤数组中不符合条件的元素，保留符合条件的元素 
scala> k
res157: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.filter(_>2)
res162: Array[Int] = Array(3, 3, 4, 5)
filter
过滤数组中符合条件的元素，保留不符合条件的元素 
scala> k
res157: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.filterNot(_>2)
res163: Array[Int] = Array(2, 2)
find
查找数组中第一个符合条件的元素 
scala> k
res157: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.find(_>2)
res164: Option[Int] = Some(3)

scala> k.find(_>2).get
res165: Int = 3
flatMap
先对集合中的每个元素进行map，再对map后的每个元素（map后的每个元素必须还是集合）中的每个元素进行flatten 
scala> b
res176: Array[Int] = Array(1, 2, 3)

scala> var f = b.flatMap(x => 0 to x)
f: Array[Int] = Array(0, 1, 0, 1, 2, 0, 1, 2, 3)
flatten
降维，将二维数组降一维，但是既有二位数组又有一维数组无法再降 
scala> var f = Array(Array(1,2,3),Array(1,2,3))
f: Array[Array[Int]] = Array(Array(1, 2, 3), Array(1, 2, 3))

scala> f.flatten
res180: Array[Int] = Array(1, 2, 3, 1, 2, 3)
fold
对序列中的每个元素进行二元运算，和 aggregate类似,但是不太相同 
scala> b
res181: Array[Int] = Array(1, 2, 3)

//不分区执行
scala> var c = b.fold(10)(combop)
combop执行10+1
combop执行11+2
combop执行13+3
c: Int = 16

//分区执行
scala> var c = b.par.fold(10)(combop)
combop执行10+1
combop执行10+2
combop执行10+3
combop执行12+13
combop执行11+25
c: Int = 36
foldLeft
等同于 /:
foldRight
等同于 :\
foreach
遍历数组，并进行相同的操作 
scala> b
res186: Array[Int] = Array(1, 2, 3)

scala> b.foreach(x => println(x+10))
11
12
13
groupBy
将数组中的元素按指定的条件分组，并返回一个map，每个key对应一个数组 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.groupBy(_%2==0)
res190: scala.collection.immutable.Map[Boolean,Array[Int]] = Map(false -> Array(3, 3, 5), true -> Array(2, 2, 4))
grouped
将数组中的元素按指定的数量分组，并返回一个iterator 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.grouped(2)
res196: Iterator[Array[Int]] = non-empty iterator

scala> k.grouped(2).foreach(x => println(x.mkString(",")))
2,3
2,3
4,5
hasDefiniteSize
检测序列是否存在有限的长度，一般对应Stream这样的流数据，返回false 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.hasDefiniteSize
res200: Boolean = true
head
返回数组中的第一个元素 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.head
res204: Int = 2
headOption
将数组中的第一个元素转化为Option类型返回 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.headOption
res205: Option[Int] = Some(2)
indexOf
返回指定元素在数组中第一次出现的索引，没有则返回-1，第二个参数值是指定从什么位置开始往后找 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.indexOf(1)
res206: Int = -1

scala> k.indexOf(3)
res210: Int = 1

scala> k.indexOf(3,2)
res215: Int = 3
indexOfSlice
返回指定序列在数组中第一次出现的索引，没有则返回-1，第二个参数值是指定从什么位置开始往后找 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.indexOfSlice(Array(3,4))
res213: Int = 3

scala> k.indexOfSlice(Array(3,4),4)
res216: Int = -1
indexWhere
返回数组中第一个满足条件的的元素的索引，没有则返回-1，第二个参数值是指定从什么位置开始往后找 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.indexWhere(_>2)
res217: Int = 1

scala> k.indexWhere(_>2,2)
res218: Int = 3
indices
返回当前数组的索引数组 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.indices
res219: scala.collection.immutable.Range = Range(0, 1, 2, 3, 4, 5)
init
返回去除最后一个元素的新数组，或指定索引（除最后一个索引）的元素 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.init
res222: Array[Int] = Array(2, 3, 2, 3, 4)

scala> k.init(0)
res223: Int = 2

scala> k.init(3)
res224: Int = 3

scala> k.init(4)
res225: Int = 4

scala> k.init(5)
java.lang.ArrayIndexOutOfBoundsException: 5
  ... 32 elided
inits
对数组进行迭代操作，返回一个迭代器，第一个值为数组的副本，往后则依次少一个，直到最后一个值为空 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.inits.foreach(x=>println(x.mkString))
232345
23234
2323
232
23
2
intersect
求两个集合的交集 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

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

scala> k.intersect(b)
res233: Array[Int] = Array(2, 3)
intersect
判断数组中是否有指定索引 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.isDefinedAt(5)
res235: Boolean = true

scala> k.isDefinedAt(6)
res236: Boolean = false
isEmpty
判断数组是否为空 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.isEmpty
res238: Boolean = false

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

scala> f.isEmpty
res239: Boolean = true
isTraversableAgain
判断序列是否可以反复遍历，一般除了iterator返回false，其他都返回true 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.isTraversableAgain
res240: Boolean = true
iterator
将数组转化为iterator 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.iterator
res243: Iterator[Int] = non-empty iterator

scala> k.iterator.foreach(x => println(x))
2
3
2
3
4
5
last
返回数组中最后一个元素 
scala> b
res250: Array[Int] = Array(1, 2, 3)

scala> b.last
res249: Int = 3
lastIndexOf
返回数组中指定元素最后一次出现的索引 
scala> b
res250: Array[Int] = Array(1, 2, 3)

scala> b.lastIndexOf(3)
res251: Int = 2
lastIndexOfSlice
返回数组中指定序列最后一次出现的索引 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.lastIndexOfSlice(Array(2,3))
res252: Int = 2
lastIndexOfSlice
返回数组中满足条件的元素最后一次出现的索引 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.lastIndexWhere(_>2)
res253: Int = 5
lastOption
返回数组中最后一个元素，并将其转化为Option类型 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.lastOption
res255: Option[Int] = Some(5)
length
返回数组的长度 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.length
res256: Int = 6
lengthCompare
返回数组的长度与指定数字的差值 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.lengthCompare(8)
res258: Int = -2

scala> k.lengthCompare(3)
res259: Int = 3

scala> k.lengthCompare(6)
res260: Int = 0
lift
将数组指定索引的值转为Option类型 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.lift(0)
res263: Option[Int] = Some(2)

scala> k.lift(1)
res264: Option[Int] = Some(3)
map
遍历数组，并对每个数组执行相同的操作，返回一个新数组，并显示出来（foreach不显示） 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.map(_+10)
res266: Array[Int] = Array(12, 13, 12, 13, 14, 15)
max
找出数组中的最大值 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.max
res269: Int = 5
maxBy
找出数组满足条件的第一个值 
scala> l
res273: Array[Int] = Array(2, 3, 4, 1, 5)

scala> l.maxBy(_>3)
res274: Int = 4
min
找出数组中的最小值 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.min
res269: Int = 2
maxBy
找出数组不满足条件的第一个值 
scala> l
res273: Array[Int] = Array(2, 3, 4, 1, 5)

scala> l.minBy(_>4)
res275: Int = 2
mkString
将数组的内容作为字符串返回，可以指定分隔符，开始字符，结束字符.与addString不一样的是mkString返回String，addString返回StringBuilder（需要先定义） 
scala> l
res273: Array[Int] = Array(2, 3, 4, 1, 5)


scala> k.mkString("{",",","}")
res276: String = {2,3,2,3,4,5}

scala> k.mkString(",")
res277: String = 2,3,2,3,4,5
nonEmpty
判断数组是否非空 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> k.nonEmpty
res238: Boolean = true

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

scala> f.nonEmpty
res239: Boolean = false
orElse
将多个偏函数组合起来使用，效果类似case语句。 
scala> k
res195: Array[Int] = Array(2, 3, 2, 3, 4, 5)

scala> val pf1:PartialFunction[Int,String]={
     | case x if x%2==0 => "one"
     | }
pf1: PartialFunction[Int,String] = <function1>

scala>

scala> val pf2:PartialFunction[Int,String]={
     | case x if x%2!=0 => "two"
     | }
pf2: PartialFunction[Int,String] = <function1>

scala> k.collect
collect   collectFirst

scala> k.collect(pf1 orElse pf2)
res283: Array[String] = Array(one, two, one, two, one, two)
Of_the_new
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
大数据手写面试题Scala语言实现大全（持续更新）
大模型大数据攻城狮的专栏
03-29 368
在大数据领域，Scala语言因其强大的函数式编程特性和对并发处理的良好支持而成为了开发者们的热门选择。有些面试官，为了考验面试者的基本功，需要让手写一些面试题，以数据结构和算法类的居多。本文将为您提供一些常见的Scala手写面试题及参考答案，帮助您在面试或工作中更好地运用Scala。
js中的map，filter，reduce
linglingzi001的博客
08-25 1659
map map 作用是生成一个新数组，遍历原数组，将每个元素拿出来做一些变换然后放入到新的数组中。 let arr = [1,2,3] let newArr = arr.map(item => item + 1) console.log(newArr)//[2,3,4] 另外 map 的回调函数接受三个参数，分别是当前索引元素，索引，原数组。 filter filter 的作用也是生成一个新数组，在遍历数组的时候将返回值为 true 的元素放入新数组，我们可以利用这个函数删除一些不需要的元素。 l
perl 字符串转换成数组
温故而知新
11-25 6536
从配置文件中读出的字符串，里面包含了多个元素，若想依次对元素进行操作，就需要把字符串转换成数组格式。 比如  volume  e:，f:，g: 代码如下： #!/usr/bin/perl my $str="e:\, g: , f:"; strtoArray($str); sub strtoArray { my $str=shift(@_); my @outArray; my
JS中filter/map/reduce方法
wfy17030212的博客
12-21 635
先提出问题 取出所有小于100的数字 将所有小于100的数字转换,全都X2 在2的数组上使所有数字相加，得出最终结果 //取出所有小于100的数字 const str1=[12,155,45,156,180,180,45,99]; let newList1=[],list1_len=0; for (let i = 0; i < str1.length; i++) { if(str1[i]<100) { newList1[list1_len++
JS数组之map、filter、reduce使用详解
m0_47670683的博客
09-16 1181
map、filter、reduce都是高阶函数，它们的功能非常强大，可以搭配箭头函数来完成复杂的数组数据处理。关于它们的用法很多人写过，但少有人写结合案例来写。在这里我会对这3个函数的用法结合案例来详细讲述，并额外写了for循环版本用来帮助理解。 模拟数据 要详细讲述这3个高阶函数的用法必须结合实际案例来讲。现在有一个这样的数组，这个数组是任务清单： let todo = [ {id: 1, name: "吃饭", done: true}, {id: 2, name: "睡觉", done:
JS中的filter,map,reduce函数
qq_41385011的博客
06-12 606
今天学Vue的时候，视频里CodeWhy老师讲了filter，map,reduce三个函数的使用。 以下是自己的理解： 这三个函数一般是对数组进行处理 fliter函数用于筛选，当return ture时表示通过筛选，数组中的数（item）将会被返回一个新的数组 let arr=[1,2,3,4,5,6,7,8,9,10]; let newarr = arr.filter(function(item){ return item%2==0; }) // newarr=[2,4,6,8,
【scala专栏_持续更新】23_scala正则表达式+模式匹配+偏函数+提取器
专注大数据与自由
11-20 497
【大纲】 【正文】
scala学习中 持续更新
欢迎大神交流讨论
11-21 335
1.简单实现scala的helloworld打印 package mylession01 //object 关键字：声明一个单例对象（伴生对象） object Helloworld { // main 方法 可以从外部调用的方法 // def 方法名称（参数名称：参数类型）：返回值类型={方法体} def main(args: Array[String]): Unit = { println("hello world") //打印helloworld } } 2.scala伴生类.
scala-kafka-client：用于运行Apache Kafka客户端库的Scala帮助器模块（0.9.x-2.1.0）
02-05
10. **社区支持**：作为一个开源项目，Scala-Kafka-Client拥有活跃的开发者社区，持续更新和维护，确保其与Kafka的新版本保持同步，并及时响应用户反馈的问题。 在实际项目中，通过使用Scala-Kafka-Client，开发者...
Scala编程语言详解（从入门到精通）spark
03-30
- **数组**：Scala 支持定长和变长数组，并可以轻松地与 Java 数组进行互操作。 - **映射**：Scala 的映射类型非常强大，支持多种操作，如添加、删除键值对等。 #### 七、Scala与Spark的关系 - **Scala 与 Spark**...
【JavaScript】Map、Reduce 和 Filter - 通过代码示例解释 JS 数组函数
最新发布
Jerryqjr的博客
03-06 1595
Map、reduce 和 filter 都是 JavaScript 中的数组方法。每个都将迭代一个数组并执行转换或计算。每个函数都会根据函数的结果返回一个新数组。在本文中，您将了解为什么以及如何使用每一个。参考链接：https://www.freecodecamp.org/news/javascript-map-reduce-and-filter-explained-with-examples/
perl列表和数组
热门推荐
mikiah的专栏
09-20 1万+
1.数组元素引用 如果下标超出了数组的范围，则其值为undef。这和通常的变量情况是一样的，如果没有值存放在变量中，则其为undef。 $blank = $fred [142_857] #此数组元素未存放值，得到undef $blanc = $mel; #$mel未存放值（未初始化），得到undef   特殊的数组索引 如果将一个元素存储在数组最后元素的后面的位置，数组会自动增长的。P
Js之 filter、map、reduce的使用
gyueh的博客
12-25 350
总结: 1.filter() 不会对空数组进行检测,filter() 不会改变原始数组 2.map() 不会对空数组进行检测,map() 不会改变原始数组
js中的map, filter, reduce
ygx_work的博客
05-17 171
map map 作用是生成一个新数组，遍历原数组，将每个元素拿出来做一些变换然后放入到新的数组中。 let arr = [1,2,3] let newArr = arr.map(item => item + 1) console.log(newArr)//[2,3,4] 另外 map 的回调函数接受三个参数，分别是当前索引元素，索引，原数组。 filter filter 的作用也是生成一个新数组，在遍历数组的时候将返回值为 true 的元素放入新数组，我们可以利用这个函数删除一些不
javascript高级算法题
徐同保的专栏
04-08 971
&lt;!DOCTYPE html&gt; &lt;html lang="en"&gt; &lt;head&gt; &lt;meta charset="UTF-8"&gt; &lt;title&gt;javascript高级算法题&lt;/title&gt;
js高级脚本算法
chuanggangbo5551的博客
07-05 96
摘要：判断电话号码算法 function telephoneCheck(str) { var re=/^[1-9]\d{9}$|^[1-9]\d{2}-[0-9]\d{2}-[0-9]\d{3}$|^[1−9]\d2[1−9]\d2[0-9]\d{2}-[0-9]\d{3}$|^\([1-9...
JS数组操作之map、reduce、filter
Symin_的博客
09-17 165
个人学习
JS中的filter、map、reduce
Matcha_ice_cream的博客
08-10 496
简单介绍js中的filter、map、reduce函数
js中map，reduce，filter的使用
10 种最常见的 Javascript 错误
05-05 2580
在页面显示数据时我们经常需要进行数据处理以后然后再让它在页面显示出来，在javascript中我们常用的函数有map（），reduce（），filter（）；map（）的使用    map 方法会迭代数组中的每一个元素，并根据回调函数来处理每一个元素，最后返回一个新数组。注意，这个方法不会改变原始数组。    举个栗子当一个数组需要把每个元素都进行加3处理时，使用map方法就很简单了var old...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值