scala数组集合函数大全

最新推荐文章于 2023-06-12 18:59:08 发布
最新推荐文章于 2023-06-12 18:59:08 发布
阅读量9k 收藏 16
点赞数 6
分类专栏： spark 文章标签： scala scala函数 scala数组函数 scala集合函数 scala函数大全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sun_0128/article/details/107495052
版权

文章目录

1.方法详解

1.1aggregate方法详解

  • 作用:进行聚合计算,有两个参数,第一个参数为初始值,第二个参数为函数(有两个函数,第一个是进行局部聚合,第二个是进行全局聚合操作)
  • 例子:对整个数组val list = Array(Array(1,2,3),Array(4,5,6),Array(7,8))进行全局求和运算
  • 1.使用flatten+reduce方法:list.flatten.reduce(_ + _)
  • 2.使用flatten+fold方法:list.flatten.fold(0)(_ + _)
  • 3.使用aggregate方法:list.aggregate(0)(_ + _.sum, _ + _)
    注意:0为初始值,第一个函数的第一个下划线为初始值0第二个下划线为每个Array,意思是0+每个Array的和作为一个结果,第二个函数是进行全局累加,将局部累加的结果全部相加
scala> val list = Array(Array(1,2,3),Array(4,5,6),Array(7,8))
list: Array[Array[Int]] = Array(Array(1, 2, 3), Array(4, 5, 6), Array(7, 8))

scala> list.flatten.reduce(_ + _)
res9: Int = 36

scala> list.flatten.fold(0)(_ + _)
res10: Int = 36

scala> list.aggregate(0)(_ + _.sum, _ + _)
res11: Int = 36

1.2其他方法如下表:

方法名描述返回值类型举例
apply(int i)按下标取数组数据 同a(i)数组元素类型Array(1 ,2,3,4,5).apply(3)
++合并数组返回一个新数组,若不同类型以左边为准左边类型Array(1 ,2) ++ List(7,8,9)
union合并两个序列，同操作符 ++左边类型Array(1,2) union List(3,4)
++:同上两个类似,右边类型决定了结果的类型右边类型Array(1,2) ++: List(3,4)
diff去交集数组Array(1,2,3).diff(Array(2,4))
intersect取交集数组Array(1,2,3).intersect(Array(2,4))
+:在数组前面添加一个元素数组1 +:Array(2,3)
:+在数组后面加入一个元素数组Array(2,3):+4
fold参数是一个值和一个操作操作结果Array(1, 2, 3, 4).fold(5)(_+_)
foldLeft参数是一个值和一个操作,从左到右计算操作结果Array(1, 2, 3, 4).foldLeft(5)(_+_)
/:foldLeft简写方式操作结果(5/:Array(1, 2, 3, 4))(_+_)
foldRight参数是一个值和一个操作,从右到左计算操作结果Array(1, 2, 3, 4).foldRight(5)(_+_)
:\foldRight简写操作结果(Array(1, 2, 3, 4):\5)(_+_)
addString将数组中的元素逐个添加到StringBuilder中StringBuilderArray(1,2,3).addString(new StringBuilder())
将数组中的元素逐个添加到StringBuilder中,并用分隔符分开StringBuilderArray(1,2,3).addString(new StringBuilder(),",")
charAt必须是字节数组,不常用可直接按数组下标取CharArray(‘a’,‘b’).charAt(0) 单引号复制会出错手写吧
clone复制数组的值,不会引用地址数组Array(1,2,3).clone
collect参数是偏函数偏函数处理后的数组Array(1,2).collect{case x if x%2==0 => x+1}
collectFirst序列中查找第一个符合条件的元素并处理OptionArray(1,2).collectFirst{case x if x%2==0 => x+1}
combinations对数组进行排列组合 参数为个数迭代器Array(1,2,3).combinations(2).foreach(x=>print(x.mkString(",")+" "))
contains判断是否包含元素BooleanArray(1,2).contains(1)
containsSlice判断是否包含子集BooleanArray(1,2,3).containsSlice(Array(2))
copyToArray数组复制,可有开始位置:目标的下标 len是原数组的长度Unitval a = Array(0,0,0);Array(1,2,3).copyToArray(a,1,2)
copyToBuffer将数组中的元素复制到ArrayBuffer中Unitval a = new ArrayBuffer[Int];Array(1,2,3).copyToBuffer(a)
corresponds判断两数组长度是否相等并且对应位置元素是否符合条件BooleanArray(1, 2).corresponds(Array(2,4))(_<_)
count统计符合条件的个数IntArray(1,2,3).count(_<2)
distinct去除重复元素数组Array(1,1,2).distinct
drop从左边去除元素 参数是长度数组Array(1,2,3).drop(2)
dropRight从右边去除元素 参数是长度数组Array(1,2,3).dropRight(2)
dropWhile去除满足条件的元素直到遇到第一个不满足的结束数组Array(1,2,-1).dropWhile(_<2)
endsWith判断数组是否以某个序列结尾BooleanArray(1,2,3).endsWith(Array(2,3))
startsWith判断数组是否以某个序列开始,可有偏移量BooleanArray(1,2,3).startsWith(Array(2,3),1)
exists判断数组中是否存在满足条件的元素BooleanArray(1,2,3).exists(_>2)
filter满足条件留下不满足过滤数组Array(1,2,3,1).filter(_ < 3)
find找第一个符合条件的元素OptionArray(1,2,3).find(_>1)
flatten扁平化处理数组Array(Array(1,2,3),Array(4,5,6)).flatten
flatMap先map然后flatten数组Array(Array(1,2),Array(4,5)).flatMap(_.map(_*2))
forall检测序列中元素是否都满足条件 都满足为trueBooleanArray(1, 2).forall(_>0)
foreach遍历操作 无返回值UnitArray(1,2,3).foreach(print(_))
groupBy按条件分组 返回一个Map类型每个key对应一个数组MapArray(1, 2, 3, 4).groupBy((_%2==0))
grouped按指定数量n分组,每个分组都有n个元素迭代器Array(1, 2, 3, 4).grouped(2).foreach(x=>print(x.mkString(",")))
hasDefiniteSize检测序列是否存在有限的长度,对应Stream这样的流数据则返回falseBooleanStream(1).hasDefiniteSize
head返回第一个元素元素类型Array(1,2,3).head
headOption返回第一个元素的Option类型对象OptionArray(1,2,3).headOption
indexOf(e[,i])返回元素e在第一次出现的索引,可指定开始下标IntArray(1,1,1).indexOf(1,1)
indexOfSlice是否包含子数组有的话返回第一次开始的下标可指定开始下标IntArray(1,2,3,2,3).indexOfSlice(Array(2,3,4))
indexWhere返回数组第一个满足条件的下标 可指定开始下标IntArray(1,2).indexWhere(_>0,1)
last返回最后一个元素元素类型Array(1,2).last
lastOption返回最后一个元素的Option类型对象OptionArray(1,2).lastOption
lastIndexOf返回元素最后一次出现的下标可有结束下标IntArray(1,1,1).lastIndexOf(1,1)
lastIndexOfSlice是否包含子序列 返回最后一次出现序列的下标可有结束下标IntArray(1,2,1,2).lastIndexOfSlice(Array(1,2),1)
lastIndexWhere返回最后一个满足条件元素的下标IntArray(1,2).lastIndexWhere(_>0)
init返回不包含最后一个元素的数组数组Array(1,2,3).init
inits每一步进行init操作最开始是自己最后是空返回的是迭代器[数组]迭代器Array(1,2,3).inits.foreach(x=>print(x.mkString("[",",","]")))
tail返回不包含第一个元素的数组数组Array(1,2,3,4).tail
tails同 inits，每一步都进行 tail 操作迭代器Array(1,2,3).tails.foreach(x=>print(x.mkString("[",",","]")))
isDefinedAt判断是否存在下标BooleanArray(1,2).isDefinedAt(3)
isEmpty判断是否为空BooleanArray().isEmpty
nonEmpty判断是否不为空BoolaenArray().nonEmpty
indices返回索引集合RangeArray(1,2).indices
iterator生成迭代器迭代器Array(1,2).iterator.foreach(print(_))
isTraversableAgain判断序列是否可以反复遍历,对于Iterators返回falseBooleanArray(1,2).iterator.isTraversableAgain
length返回数组长度IntArray(1,2).length
lengthCompare比较数组长度和参数len大小返回长度-lenIntArray(1,2).lengthCompare(1)
map对数组中的元素进行操作并且返回一个新数组数组Array(1,2).map(_+10)
max返回数组最大值元素类型Array(1,2).max
maxBy返回数组中符合条件的第一个元素元素类型Array(1,2,3).maxBy(_>1)
min返回数组最小值元素类型Array(1,2).min
minBy返回数组中不符合条件的第一个元素元素类型Array(1,2,0).minBy(_>1)
mkString将序列中所有元素拼接成一个字符串,可有开始符分隔符结束符StringArray(1,2).mkString("[",",","]")
padTo(len,e)填充序列,如果当前数组长度小于len,那么新产生的数组长度是len,多出的几个位值填充e,若当前数组大于等于len返回当前数组数组Array(1,2).padTo(5,0)
partition按条件将序列拆分成两个数组,满足条件的放到第一个数组,其余的放到第二个数组,返回的是包含这两个数组的元组二元组Array(1,2).partition(_%2==0)
patch(i,arr,len)批量替换,从原序列的i处开始后面的len个元素,将被替换成数组arr数组Array(1,2,3,4).patch(0,Array(7,8),1)
permutations对数组进行全排列 Ann迭代器Array(1,2,3).permutations.foreach(x=>print(x.toVector.mkString("[",",","]")))
prefixLength给定一个条件返回数组中满足条件元素的个数IntArray(1, 2, 3, 4).prefixLength(_ < 3)
product返回所有元素乘积的值要求是数值型Array(1, 2, 3, 4.5).product
reduce同 fold,但是参数只有操作不需要初始值元素类型Array(1, 2, 3, 4).reduce(_ + _)
reduceLeft参数只有操作不需要初始值,从左向右元素类型Array(1, 2, 3, 4).reduceLeft(_ + _)
reduceRight参数只有操作不需要初始值,从右向左元素类型Array(1, 2, 3, 4).reduceRight(_ + _)
reduceLeftOption参数只有操作不需要初始值,从左向右计算,返回一个OptionOptionArray(1, 2, 3, 4).reduceLeftOption(_ + _)
reduceRightOption参数只有操作不需要初始值,从右向左OptionArray(1, 2, 3, 4).reduceRightOption(_ + _)
reverse反转序列,可用于降序排列数组Array(1, 4, 3, 2).sorted.reverse
reverseIterator生成反向迭代器迭代器Array(1, 2, 3).reverseIterator.foreach(print)
reverseMap先map再反转数组Array(1, 2, 3, 4).reverseMap(_*3)
sameElements判断两个序列是否都相等即长度相等 对应下标元素相等BooleanArray(1, 2, 3).sameElements(Array(1, 2, 3))
scan参数是一个数值和操作,会从这个数值起,把每一步的操结果放到一个新的数组中返回数组Array(1, 2, 3).scan(4)(_ + _)
scanLeft参数是一个数值和操作,会从这个数值起,把每一步的操结果(从左到右)放到一个新的数组中返回数组Array(1, 2, 3).scanLeft(4)(_ + _)
scanRight参数是一个数值和操作,会从这个数值起,把每一步的操结果(从右到左)放到一个新的数组中返回数组Array(1, 2, 3).scanRight(4)(_ + _)
segmentLength(f,i)从序列的下标i开始向后查找,返回满足条件f的连续元素的长度,直到第一个不满足条件结束IntArray(1, 2, 4, 3).segmentLength(_<4,0)
seq产生一个引用当前序列的sequential视图视图Array(1, 2, 3, 4).seq
size返回数组元素个数 同lengthIntArray(1, 2, 3, 4).size
slice(i,j)返回当前序列中从i到j之间的序列,不包括j处的元素数组Array(1, 2, 3, 4).slice(0,3)
sliding(n,step)滑动,从第一个元素开使取参数n个元素,然后第二个直到不够n个元素结束滑动,可设置步长step即第一个元素取完不从第二个元素滑动迭代器Array(1, 2, 3, 4).sliding(2,2).foreach(x=>print(x.mkString(",")+" "))
sortBy按指定的排序规则对序列排序数组Array(3, 2, 1, 4).sortBy(x=>0-x)
sorted自然排序,默认升序数组Array(3, 2, 1, 4).sorted
span将序列拆分成两个数组,从第一个元素开始,直到第一个不满足条件的元素为止,其中满足条件的元素放到第一个数组,其余的放到第二个数组,返回的是包含这两个数组的元组二元组Array(1, 2, 3, 4).span(x=>x%2!=0)
splitAt从指定位置开始,把数组拆分成两个数组 前一个数组不包括该下标二元组Array(1, 2, 3, 4).splitAt(3)
stringPrefix返回toString结果的前缀StringArray(1, 2, 3, 4).stringPrefix
subSequence(i,j)返回i和j间的字符数组,不包含j处的元素CharSequenceArray(‘1’, ‘2’, ‘3’, ‘4’).subSequence(0,3)
sum求和,元素需要是数值类型元素类型Array(1, 2, 3, 4).sum
take(n)返回当前数值中前n个元素组成的数组数组Array(1, 2, 3, 4).take(3)
takeRight(n)返回当前数组中从右边开始后n个元素组成的数组数组Array(1, 2, 3, 4).takeRight(3)
takeWhile返回从第一个元素开始,满足条件的元素组成的数组 直到第一个不满足条件的停止数组Array(1, 2, 3, 1).takeWhile(_<=2)
toArray转换成 Array 类型ArrayList(1, 2, 3, 4).toArray
toBuffer转换成Buffer类型BufferArray(1, 2, 3, 4).toBuffer
toIndexedSeq转换成 IndexedSeq类型IndexedSeqArray(1, 2, 3, 4).toIndexedSeq
toIterable转换成可迭代的类型IterableArray(1, 2, 3, 4).toIterable
toIterator转换成迭代器,同iterator方法IteratorArray(1, 2, 3, 4).toIterator
toList转换成 List 类型ListArray(1,2,3,4).toList
toMap转转换成Map类型,需要被转化序列中包含的元素是 Tuple2类型MapArray(1,2,3,4).map((_,1)).toMap
toSeq转换成Seq类型SeqArray(1,2,3,4).toSeq
toSet转换成Set类型SetArray(1,2,3,4).toSet
toStream转换成Stream类型StreamArray(1,2,3,4).toStream
toVector转换成Vector类型VectorArray(1,2,3,4).toVector
transpose矩阵转置,二维数组行列转换数组Array(Array(1,2,3),Array(4,5,6),Array(7,8,9)).transpose
zip将两个序列对应位置上的元素组成一个元组,只取两者下标相同的元组数组Array(1,2,3,4).zip(Array(‘a’,‘b’,‘c’,‘d’,‘e’))
zipAll(arr,a2,a3)不足的自动填充,如果前面序列短,不足的元素填充为第二个参数,如果后面短,填充为第三个参数元组数组Array(1,2,3,4).zipAll(Array(‘a’,‘b’,‘c’,‘d’,‘e’),1,‘a’)
zipWithIndex每个元素和它的下标组成一个2元组数组元组数组Array(1,2,3,4,5).zipWithIndex
unzip将含有二元组的数组,每个元组的第一个元素组成一个数组,第二个元素组成一个数组二元组Array((1,‘a’), (2,‘b’), (3,‘c’), (4,‘d’)).unzip
unzip3将含有三元组的数组,每个元组的第一个元素组成一个数组,第二个元素组成一个数组,第三个元素组成一个数组,返回包含这三个数组的三元组三元组Array((1,2,3),(“a”,“b”,“c”)).unzip3
update(i,x)将数组中下标i处的元素更新为xUnitval a = Array(1,2,3,4);a.update(0,0);a
updated(i,x)将数组中下标i处的元素更新为 x,并返回替换后的数组数组Array(1,2,3,4).updated(0,0)
view(i,j)返回当前序列中从i到j之间的序列,不包括j处的元素IndexedSeqViewArray(1,2,3,4).view(0,3).mkString(",")
withFilter根据条件p过滤元素FilterMonadicArray(1, 2, 3, 4).withFilter(_>2).map(x=>x)

2.scala交互界面演示如下:

Welcome to Scala 2.11.8 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_191).
Type in expressions for evaluation. Or try :help.
scala> Array(1 ,2,3,4,5).apply(3)
res0: Int = 4

scala> Array(1 ,2) ++ List(7,8,9)
res1: Array[Int] = Array(1, 2, 7, 8, 9)

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

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

scala> Array(1,2,3).diff(Array(2,4))
res4: Array[Int] = Array(1, 3)

scala> Array(1,2,3).intersect(Array(2,4))
res5: Array[Int] = Array(2)

scala> 1 +:Array(2,3)
res6: Array[Int] = Array(1, 2, 3)

scala> Array(2,3):+4
res7: Array[Int] = Array(2, 3, 4)

scala> Array(1, 2, 3, 4).fold(5)(_+_)
res8: Int = 15

scala> Array(1, 2, 3, 4).foldLeft(5)(_+_)
res9: Int = 15

scala> (5/:Array(1, 2, 3, 4))(_+_)
res10: Int = 15

scala> Array(1, 2, 3, 4).foldRight(5)(_+_)
res11: Int = 15

scala> (Array(1, 2, 3, 4):\5)(_+_)
res12: Int = 15

scala> Array(1,2,3).addString(new StringBuilder())
res13: StringBuilder = 123

scala> Array(1,2,3).addString(new StringBuilder(),",")
res14: StringBuilder = 1,2,3

scala> Array('a','b').charAt(0)
res15: Char = a

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

scala> Array(1,2).collect{case x if x%2==0 => x+1}
res17: Array[Int] = Array(3)

scala> Array(1,2).collectFirst{case x if x%2==0 => x+1}
res18: Option[Int] = Some(3)

scala> Array(1,2,3).combinations(2).foreach(x=>print(x.mkString(",")+" "))
1,2 1,3 2,3
scala> Array(1,2).contains(1)
res20: Boolean = true

scala> Array(1,2,3).containsSlice(Array(2))
res21: Boolean = true

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

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

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

scala> Array(1, 2).corresponds(Array(2,4))(_<_)
res25: Boolean = true

scala> Array(1,2,3).count(_<2)
res26: Int = 1

scala> Array(1,1,2).distinct
res27: Array[Int] = Array(1, 2)

scala> Array(1,2,3).drop(2)
res28: Array[Int] = Array(3)

scala> Array(1,2,3).dropRight(2)
res29: Array[Int] = Array(1)

scala> Array(1,2,-1).dropWhile(_<2)
res30: Array[Int] = Array(2, -1)

scala> Array(1,2,3).endsWith(Array(2,3))
res31: Boolean = true

scala> Array(1,2,3).startsWith(Array(2,3),1)
res32: Boolean = true

scala> Array(1,2,3).exists(_>2)
res33: Boolean = true

scala> Array(1,2,3,1).filter(_ < 3)
res34: Array[Int] = Array(1, 2, 1)

scala> Array(1,2,3).find(_>1)
res35: Option[Int] = Some(2)

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

scala> Array(Array(1,2),Array(4,5)).flatMap(_.map(_*2))
res37: Array[Int] = Array(2, 4, 8, 10)

scala> Array(1, 2).forall(_>0)
res38: Boolean = true

scala> Array(1,2,3).foreach(print(_))
123
scala> Array(1, 2, 3, 4).groupBy((_%2==0))
res40: scala.collection.immutable.Map[Boolean,Array[Int]] = Map(false -> Array(1, 3), true -> Array(2, 4))

scala> Array(1, 2, 3, 4).grouped(2).foreach(x=>print(x.mkString(",")))
1,23,4
scala> Stream(1).hasDefiniteSize
res42: Boolean = false

scala> Array(1,2,3).head
res43: Int = 1

scala> Array(1,2,3).headOption
res44: Option[Int] = Some(1)

scala> Array(1,1,1).indexOf(1,1)
res45: Int = 1

scala> Array(1,2,3,2,3).indexOfSlice(Array(2,3,4))
res46: Int = -1

scala> Array(1,2).indexWhere(_>0,1)
res47: Int = 1

scala> Array(1,2).last
res48: Int = 2

scala> Array(1,2).lastOption
res49: Option[Int] = Some(2)

scala> Array(1,1,1).lastIndexOf(1,1)
res50: Int = 1

scala> Array(1,2,1,2).lastIndexOfSlice(Array(1,2),1)
res51: Int = 0

scala> Array(1,2).lastIndexWhere(_>0)
res52: Int = 1

scala> Array(1,2,3).init
res53: Array[Int] = Array(1, 2)

scala> Array(1,2,3).inits.foreach(x=>print(x.mkString("[",",","]")))
[1,2,3][1,2][1][]
scala> Array(1,2,3,4).tail
res55: Array[Int] = Array(2, 3, 4)

scala> Array(1,2,3).tails.foreach(x=>print(x.mkString("[",",","]")))
[1,2,3][2,3][3][]
scala> Array(1,2).isDefinedAt(3)
res57: Boolean = false

scala> Array().isEmpty
res58: Boolean = true

scala> Array().nonEmpty
res59: Boolean = false

scala> Array(1,2).indices
res60: scala.collection.immutable.Range = Range(0, 1)

scala> Array(1,2).iterator.foreach(print(_))
12
scala> Array(1,2).iterator.isTraversableAgain
res62: Boolean = false

scala> Array(1,2).length
res63: Int = 2

scala> Array(1,2).lengthCompare(1)
res64: Int = 1

scala> Array(1,2).map(_+10)
res65: Array[Int] = Array(11, 12)

scala> Array(1,2).max
res66: Int = 2

scala> Array(1,2,3).maxBy(_>1)
res67: Int = 2

scala> Array(1,2).min
res68: Int = 1

scala> Array(1,2,0).minBy(_>1)
res69: Int = 1

scala> Array(1,2).mkString("[",",","]")
res70: String = [1,2]

scala> Array(1,2).padTo(5,0)
res71: Array[Int] = Array(1, 2, 0, 0, 0)

scala> Array(1,2).partition(_%2==0)
res72: (Array[Int], Array[Int]) = (Array(2),Array(1))

scala> Array(1,2,3,4).patch(0,Array(7,8),1)
res73: Array[Int] = Array(7, 8, 2, 3, 4)

scala> Array(1,2,3).permutations.foreach(x=>print(x.toVector.mkString("[",",","]")))
[1,2,3][1,3,2][2,1,3][2,3,1][3,1,2][3,2,1]
scala> Array(1, 2, 3, 4).prefixLength(_ < 3)
res75: Int = 2

scala> Array(1, 2, 3, 4.5).product
res76: Double = 27.0

scala> Array(1, 2, 3, 4).reduce(_ + _)
res77: Int = 10

scala> Array(1, 2, 3, 4).reduceLeft(_ + _)
res78: Int = 10

scala> Array(1, 2, 3, 4).reduceRight(_ + _)
res79: Int = 10

scala> Array(1, 2, 3, 4).reduceLeftOption(_ + _)
res80: Option[Int] = Some(10)

scala> Array(1, 2, 3, 4).reduceRightOption(_ + _)
res81: Option[Int] = Some(10)

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

scala> Array(1, 2, 3).reverseIterator.foreach(print)
321
scala> Array(1, 2, 3, 4).reverseMap(_*3)
res84: Array[Int] = Array(12, 9, 6, 3)

scala> Array(1, 2, 3).sameElements(Array(1, 2, 3))
res85: Boolean = true

scala> Array(1, 2, 3).scan(4)(_ + _)
res86: Array[Int] = Array(4, 5, 7, 10)

scala> Array(1, 2, 3).scanLeft(4)(_ + _)
res87: Array[Int] = Array(4, 5, 7, 10)

scala> Array(1, 2, 3).scanRight(4)(_ + _)
res88: Array[Int] = Array(10, 9, 7, 4)

scala> Array(1, 2, 4, 3).segmentLength(_<4,0)
res89: Int = 2

scala> Array(1, 2, 3, 4).seq
res90: scala.collection.mutable.IndexedSeq[Int] = WrappedArray(1, 2, 3, 4)

scala> Array(1, 2, 3, 4).size
res91: Int = 4

scala> Array(1, 2, 3, 4).slice(0,3)
res92: Array[Int] = Array(1, 2, 3)

scala> Array(1, 2, 3, 4).sliding(2,2).foreach(x=>print(x.mkString(",")+" "))
1,2 3,4
scala> Array(3, 2, 1, 4).sortBy(x=>0-x)
res94: Array[Int] = Array(4, 3, 2, 1)

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

scala> Array(1, 2, 3, 4).span(x=>x%2!=0)
res96: (Array[Int], Array[Int]) = (Array(1),Array(2, 3, 4))

scala> Array(1, 2, 3, 4).splitAt(3)
res97: (Array[Int], Array[Int]) = (Array(1, 2, 3),Array(4))

scala> Array(1, 2, 3, 4).stringPrefix
res98: String = [I

scala> Array('1','2','3','4').subSequence(0,3)
res99: CharSequence = 123

scala> Array(1, 2, 3, 4).sum
res100: Int = 10

scala> Array(1, 2, 3, 4).take(3)
res101: Array[Int] = Array(1, 2, 3)

scala> Array(1, 2, 3, 4).takeRight(3)
res102: Array[Int] = Array(2, 3, 4)

scala> Array(1, 2, 3, 1).takeWhile(_<=2)
res103: Array[Int] = Array(1, 2)

scala> List(1, 2, 3, 4).toArray
res104: Array[Int] = Array(1, 2, 3, 4)

scala> Array(1, 2, 3, 4).toBuffer
res105: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3, 4)

scala> Array(1, 2, 3, 4).toIndexedSeq
res106: scala.collection.immutable.IndexedSeq[Int] = Vector(1, 2, 3, 4)

scala> Array(1, 2, 3, 4).toIterable
res107: Iterable[Int] = WrappedArray(1, 2, 3, 4)

scala> Array(1, 2, 3, 4).toIterator
res108: Iterator[Int] = non-empty iterator

scala> Array(1,2,3,4).toList
res109: List[Int] = List(1, 2, 3, 4)

scala> Array(1,2,3,4).map((_,1)).toMap
res110: scala.collection.immutable.Map[Int,Int] = Map(1 -> 1, 2 -> 1, 3 -> 1, 4 -> 1)

scala> Array(1,2,3,4).toSeq
res111: Seq[Int] = WrappedArray(1, 2, 3, 4)

scala> Array(1,2,3,4).toSet
res112: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 4)

scala> Array(1,2,3,4).toStream
res113: scala.collection.immutable.Stream[Int] = Stream(1, ?)

scala> Array(1,2,3,4).toVector
res114: Vector[Int] = Vector(1, 2, 3, 4)

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

scala> Array(1,2,3,4).zip(Array('a','b','c','d','e'))
res116: Array[(Int, Char)] = Array((1,a), (2,b), (3,c), (4,d))

scala> Array(1,2,3,4).zipAll(Array('a','b','c','d','e'),1,'a')
res117: Array[(Int, Char)] = Array((1,a), (2,b), (3,c), (4,d), (1,e))

scala> Array(1,2,3,4,5).zipWithIndex
res118: Array[(Int, Int)] = Array((1,0), (2,1), (3,2), (4,3), (5,4))

scala> Array((1,'a'),(2,'b'),(3,'c'),(4,'d')).unzip
res119: (Array[Int], Array[Char]) = (Array(1, 2, 3, 4),Array(a, b, c, d))

scala> Array((1,2,3),("a","b","c")).unzip3
res120: (Array[Any], Array[Any], Array[Any]) = (Array(1, a),Array(2, b),Array(3, c))

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

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

scala> Array(1,2,3,4).view(0,3).mkString(",")
res123: String = 1,2,3

scala> Array(1, 2, 3, 4).withFilter(_>2).map(x=>x)
res124: Array[Int] = Array(3, 4)
sun_0128
关注
专栏目录
Scala数组Array
攸的博客
01-16 853
目录 1. 定长数组 1. 初始化定长数组 2. 转换成数组缓冲 2. 变长数组（数组缓冲） 1. 使用数组缓冲 2. 追加 3. 插入 4. 删除 5. 截断 6. 转成定长数组 3. 遍历数据 1、 增强 for 循环 2、 to 3、 until 4.数组转换 5.数组常用算法 6. 多维数组 1. 定长数组 1. 初始化定长数组 1.初始化一...
scala的数组常用算法
汉子一枚
02-09 4759
数组常用算法 scala中的数组封装了一些常用的计算操作，将来在对数据处理的时候，不需要我们自己再重新实现。以下为常用的几个算法： 求和——sum方法 求最大值——max方法 求最小值——min方法 排序——sorted方法 求和 数组中的sum方法可以将所有的元素进行累加，然后得到结果 示例 定义一个数组，包含以下几个元素（1,2,3,4) 请计算该数组的和 参考代码 scala scala&g...
Scala中对于Array[Array[Int]]类似形式求和或者平均值
Buevara的博客
11-12 3223
举例： 我们有一个String “(1,2,3)-(11,22,33)-(111,222,333)” 现在想切分成为Array[Array[Int]] 并且对应位相加 用到相关函数 map 这里的map是指map方法，而非map映射(详细可点击这篇博客)。 map 在某一个列表（List）调用 map 时，map 可以接受一个函数或者一个表达式为参数，这个函数或者表达式将作用于列表中的每一个元...
【图文详细 】Scala——Scala 数组 Array
谦卑t
12-19 4839
4、Scala 数组 Array  4.1、定长数组和变长数组  1、由于 Array 是不可变（长度不可变）的，初始化之初就有了固定的长度，所以不能直接 地对其元素进行删除操作，也不能多增加元素，只能修改某个位置的元素的值，要实现删除 可以通过过滤生成新的 Array 的方式来删除不要的元素。所以也就没有 add,insert,remove 等 操作。    2、而 ArrayBuffer ...
scala中Array数组大全
知其然，知其所以然
03-02 1330
美图欣赏： 一.背景 数组里面有很多方法，需要多加练习 二.数组例子 scala> val arr = Array(1,2,3,4,5) arr: Array[Int] = Array(1, 2, 3, 4, 5) scala> val arr1 = new Array(1) arr1: Array[Nothing] = Array(null) scala> arr1...
scala 数组函数大全（143个1个不漏，全面案例详解）
BigData_Hubert的博客
09-09 3660
scala系列 scala 143个数组函数大全 scala 数组函数大全scala系列前言一、scala 数据简介二、数组函数汇总 前言 本篇博客为大家带来的是 scala 所有（没错，没有看错，就是所有）数组函数的案例详解大全。scala 数组函数是 scala 能够实现代码飘逸的核心基础所在，因此在 scala 入门的时候必须强记下来，没有任何商量的余地。 相信大家在看完的数组函数汇总后，都能够代码敲的飘逸！“so easy” ![在这里插入图片描述](https://img-blog.
scala的数组及集合函数详细总结（详细示例分析）
blessness的博客
09-12 1216
@[TOC] (目录) 三级目录
scala数组、集合函数大全143条，耗时259200秒
RacardoMlu的博客
09-10 675
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码
Scala集合——数组
xia3138641636的博客
04-17 289
Scala集合——数组 不可变数组： *1）第一种方式定义数组(定长数组) 定义：val arr1 = new ArrayInt （1）new是关键字 （2）[Int]是指定可以存放的数据类型，如果希望存放任意数据类型，则指定Any （3）(10)，表示数组的大小，确定后就不可以变化 *2）第二种方式定义数组 val arr1 = Array(1, 2) （1）在定义数组时，直接赋值 （2）使用apply方法创建数组对象 可变数组： （1）ArrayBuffer是有序的集合 （2）增加元素使用的是appen
Scala数组基本方法的使用
May_J_Oldhu的博客
10-29 824
05.Scala数组基本方法 a: Array[Int] = Array(1, 2, 3, 4, 5, 6) 1.求数组元素的和: (0/:a)(_+_) a.aggregate(0)(_+_,_+_) a.fold(0)(_+_) a.reduce(_+_) (a.scan(0)(_+_)).apply(a.size) a.sum 2.求数组元素的积 (1/:a)(_*_) a.aggregate(1)(_*_,_*_) a.fold(1)(_*_) a.reduce(_*_) a.product
Scala 中的 Array 数组 详解
m0_51697147的博客
04-18 463
一、不可变长数组 1.一维数组的创建与遍历 2.二维数组的创建与遍历 3.数组的一些方法 二、可变长数组ArrayBuffer 三、数组其余的一些方法
掌握Scala数据结构（1）ARRAY、LIST
最新发布
dmzshyl1123的博客
06-12 1531
先定义，后赋值，这叫数组的动态初始化避免数组下标越界错误（数据溢出：Data Overflow）变长数组使用类scala.collection.mutable.ArrayBuffer进行定义定义一个变长Int类型数组arr，利用+=运算符、append方法添加一个数组元素（注意是追加元素），还可以利用appendAll方法添加一个数组（多个元素）
Scala 添加/修改/删除元素，遍历数组
抓住人生的每一分每一秒，胜过虚度中的每一年每一月！！！
08-24 7930
添加/修改/删除元素 使用+=添加元素 使用-=删除元素 使用++=追加一个数组到变长数组 参考代码 // 定义变长数组 scala> val a = ArrayBuffer("hadoop", "spark", "flink") a: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(hadoop, spark, flink) // 追加一个元素 scala> a += "flume" re..
Scala之Array数组
KGC的博客
12-12 428
数组作为一种最常见的数据结构，想来大家已经熟悉，本篇主要介绍scala中Array的使用。 数组中的元素都是同一种数据类型。 数组在scala中也分为定长数组和变长数组。 1.定长数组 定长数组：即数组长度固定不变 实例：  val array1 = new Array[Int](10) //初始元素都为0的长度为10的Int类型数组 val array2 = new Array[String...
Scala学习笔记(11)—集合(二)—数组
m0_56602092的博客
08-19 326
一、数组 1.不可变数组Array (1) 定义 第一种定义方式 val arr1 = new Array[Int](10) 第二种定义方式，利用apply方法 val arr1 = Array(1, 2) (2) 遍历 普通遍历 for (i <- arr01) { println(i) } 简化遍历，调用foreach方法 arr2.foreach( (elem: Int) => println(elem) ) //继续简化 arr.foreach( println ) (3
Scala 中Array的算子
weixin_49180684的博客
07-29 284
提取元素 val v:T = arr.head 提取第一个元素 val v:Option[T] = arr.headOption 提取第一个元素，返回值是一个Option类型，与上面相比，这个即使是空元素也不会报错，返回一个None val v:T = arr.last 提取最后一个元素 val v:Option[T] = arr.lastOptin 提取最后一个元素，返回值类型是Option类型，空元素也不会报错 val v:T = arr(index:Int) 根据下标
scala之函数式编程及高阶函数
fengge18306的博客
04-15 374
1、 函数式编程 使用Spark/Flink的大量业务代码都会使用到函数式编程。 1.1 遍历 - foreach （1）方法描述 foreach(f: (A) ⇒ Unit): Unit （2）方法说明 foreach API 说明 参数 f: (A) ⇒ Unit ...
Scala数组元素的增加(:+)方法
热门推荐
学亮编程手记
04-16 1万+
Scala数组、区间与集合详解：不可变与可变的对比
在Scala编程语言中，数组集合是数据结构的重要组成部分，它们为处理和操作一系列有序的数据提供了便利。本文主要介绍了Scala中的三种核心集合类型：数组（Array）、区间（Range）和向量（Vector），以及另一种非数组...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值