scala中常用Array函数
程序员文章站
2022-05-29 22:33:39
...
所有函数测试均s以cala交互式编程方式(wimdows cmd 下执行scala)完成。
scala数组
·存储的大小固元素索引
·数组索引从0开始
//数组创建方式一
var a1:Array[String] = new Array[String](3)
a1(0)="Jason"
a1(1)="Marie"
a1(2)="Jimmy"
a1存储结果 Array(Jason, Marie, Jimmy)
//数组创建方式二
var a2=Array("Jason","Marie","Jimmy")
a2存储结果 Array(Jason, Marie, Jimmy)
//数据创建方式三:区间数组 Array(str,end,step) 值str区间起始值 end区间终 step取值步长
var a3=Array.range(1,10,2)
a3存储结果 Array(1, 3, 5, 7, 9)
Array常用函数
测试所用变量
var a =Array("zhang","wang","li","123",123)
var b =Array(12,45,78,96,3)
val b1 = Array(1,2,3,4)
var a1 = new StringBuilder()
val c = List(1,2)
val d = scala.collection.mutable.LinkedList(3,4)
- ++ 或者 union
合并集合,并返回一个新的集合,新集合包含左右两个集合对象的内容,返回类型和第一个集合类型相同
scala> a++b
res109: Array[Any] = Array(zhang, wang, li, 123, 12, 45, 78, 96, 3)
scala> a.union(c)
res4: Array[Any] = Array(zhang, wang, li, 123, 123, 1, 2)
scala> c ++ a
res7: List[Any] = List(1, 2, zhang, wang, li, 123, 123)
- ++:
合并集合,并返回一个新的集合,新集合包含左右两个集合对象的内容,返回类型和右边的相同
scala> c ++: a
res8: Array[Any] = Array(1, 2, zhang, wang, li, 123, 123)
scala> a++:c
res9: List[Any] = List(zhang, wang, li, 123, 123, 1, 2)
- diff
集合差集,返回第一个集合中在第二个集合中没有的元素的集合,返回类型和当前集合一样
scala> b.diff(d)
res15: Array[Int] = Array(12, 45, 78, 96)
scala> d.diff(b)
res16: scala.collection.mutable.LinkedList[Int] = LinkedList(4)
- intersect
集合交集,返回两个集合公共的元素集合,返回类型和当前集合一样
scala> b.intersect(d)
res18: Array[Int] = Array(3)
scala> d.intersect(b)
res19: scala.collection.mutable.LinkedList[Int] = LinkedList(3)
- +:
在数组前面添加一个元素,并返回新的对象
scala> 100 +: b
res116: Array[Int] = Array(100, 12, 45, 78, 96, 3)
- :+
在数组末尾添加一个元素,并返回新对象
scala> b :+ 0
res117: Array[Int] = Array(12, 45, 78, 96, 3, 0)
- /: 等价 foldLeft(v)(f)
把v和第一个进行f操作,结果和下一个元素进行相同操作,数组取值从左到右,结果值返回
scala> ( 10/:b)(_-_) //10-12-45-78-96-3=-224
res28: Int = -224
- fold(v)(f)
把v和数组的个第个一元素进行二元运算,得到结果和下一个元素做相操同作,返回结果值
scala> b.fold(10)(_+_)
res19: Int = 244
- :\ 等价 foldRight(v)(f)
把v和最后一个进行f操作,结果和下一个元素进行相同操作,数组取值从右到左,结果值返回
scala> (b :\ 10)(_-_)
res27: Int = -58
/** 运算过程
3-10
96-(3-10)
78-(96-(3-10))
45-(78-(96-(3-10)))
12-(45-(78-(96-(3-10))))=-58
/
- addString(StringBuilder b)
将数组中的元素逐个追加到b中 返回StringBuilder
scala> a.addString(a1)
res20: StringBuilder = zhangwangli123123
- addString(b: StringBuilder, sep: String)
将数组中的元素逐个追加到b中,每个元素用sep分隔符分开
scala> a.addString(a1,",")
res22: StringBuilder = zhangwangli123123zhang,wang,li,123,123
- addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
同上,在首尾各加一个字符串,并指定sep分隔符
scala> a.addString(a1,"{",",","}")
res23: StringBuilder = zhangwangli123123zhang,wang,li,123,123{zhang,wang,li,123,123}
- aggregate[B](z: ⇒ B)(seqop, combop) B
聚合计算,柯里化方法
scala> b.par.aggregate(10)(_-_,_-_)
- par
返回一个并行实现,产生的并行序列, ParArray
scala> a.par
res289: scala.collection.parallel.mutable.ParArray[Any] = ParArray(zhang, wang, li, 123, 123)
- apply(i: Int)
取出指定索引处的元素
scala> var a =Array("zhang","wang","li","123",123)
scala> a.apply(0)
res130: Any = zhang
- canEqual(that: Any): Boolean
判断两个对象是否可以进行比较
scala> a.canEqual("asd")
res131: Boolean = true
- charAt(index) charAt
获取index索引处的字符,这个方法会执行一个隐式的转换,
将Array[T]转换为 ArrayCharSequence,只有当T为char类型时,这个转换才会发生。
val chars = Array('a','b','c')
chars.charAt(2)
res:Char=c
- clone: Array[T]
创建一个新的副本
scala> var c = a.clone
c: Array[Any] = Array(zhang, wang, li, 123, 123)
- collect(fun) Array[B]
通过执行一个并行计算(偏函数),得到一个新的数组对象
val fun:PartialFunction[Char,Char] = {
case 'a' => 'A'
case x => x
}
val chars = Array('a','b','c')
val newchars = chars.collect(fun)
val value = arr.collectFirst({case x:Int => x*100})
- collectFirst(pf) Option
在序列中查找第一个符合偏函数定义的元素,并执行偏函数计算
val fun:PartialFunction[Any,Int] = {
case x:Int => x*100
}
scala> a.collectFirst(fun)
res60: Option[Int] = Some(12300)/None
- combinations(int num) collection.Iterator[Array[T]]
排列组合,这个排列组合会选出所有指定长度的包含字符不一样的组合
scala> var bb =b.combinations(3)
bb: Iterator[Array[Int]] = non-empty iterator
scala> bb.foreach(x=>println(x.mkString(" ")))
12 45 78
12 45 96
12 45 3
12 78 96
12 78 3
12 96 3
45 78 96
45 78 3
45 96 3
78 96 3
- permutations collection.Iterator[Array[T]]
排列组合,他与combinations不同的是,组合中的内容可以相同,但是顺序不能相同
scala> b.permutations.foreach(x=>{print(x.mkString(" "));println()})
12 45 78 96 3
12 45 78 3 96
12 45 96 78 3
12 45 96 3 78
12 45 3 78 96
12 45 3 96 78
- contains(elem: A1): Boolean
序列中是否包含指定对象
scala> a.contains("123")
res67: Boolean = true
- containsSlice[B](that: GenSeq[B]): Boolean
判断当前序列中是否包含另一个序列
scala> var b =Array(12,45,78,96,3)
scala> var e = Array(45,12)
scala> b.containsSlice(e)
res140: Boolean = true
- copyToArray(dct,[int1,int2]) Unit
源数组拷贝到指定数组中,[从目标数组的int1位置开始,把原数组int2开始部分拷贝进去]
scala> var c =new Array[Int](6)
c: Array[Int] = Array(0, 0, 0, 0, 0, 0)
scala> b.copyToArray(c,1,0)
scala> c
res147: Array[Int] = Array(0,12, 45, 78, 96, 3)
- corresponds(arr)
判断两个序列长度以及对应位置元素是否符合某个条件。
scala> d.corresponds(c)(_>_)
res81: Boolean = true
- count
统计数组中满足条件的元素个数
scala> c.count(p=>p%2==0)
res154: Int = 4
- distinct Array
去除当前集合中重复的元素,只保留一个,返回一个新的数组
var arr =Array(1,1,0,4,6,3)
scala> arr.distinct
res93: Array[Int] = Array(1, 0, 4, 6, 3)
- drop
将当前序列中前 n 个元素去除后,作为一个新序列返回
scala> a.drop(2)
res96: Array[Any] = Array(li, 123, 123)
scala> a
res97: Array[Any] = Array(zhang, wang, li, 123, 123)
- dropRight(int)
将当前序列中前 n 个元素去除后,作为一个新序列返回
scala> var b =Array(12,45,78,96,3)
scala> b.dropRight(3)
res143: Array[Int] = Array(12, 45)
- dropWhile
从数组首个开始匹配,去除满足条件的元素(遇到不满足条件则停止),返回不满足条件的元素集合
scala> b.dropWhile(_%2==0)
res110: Array[Int] = Array(45, 78, 96, 3)
- filter
过滤出当前数组满足条件的元素,返回新的数组
scala> b.filter(_%2==0)
res111: Array[Int] = Array(12, 78, 96)
- filterNot
过滤出当前数组不满足条件的元素,返回新的数组
scala> b.filterNot(_%2==0)
res112: Array[Int] = Array(45, 3)
- exists
判断当前数组是否包含符合条件的元素
scala> b.exists(_<10)
res120: Boolean = true
scala> b.exists(_%2 ==0)
res124: Boolean = true
- endsWith
判断当前序列是否以某个序列结尾
scala> b.endsWith(Array(78,96,3))
res126: Boolean = true
scala> b.endsWith(List(78,96,3))
res127: Boolean = true
- startsWith
判断当前序列是否以某个序列开始
scala> b.startsWith(Array(12,45))
res130: Boolean = true
scala> b.startsWith(Array(13))
res131: Boolean = false
- find
找到满足条件的第一个元素,存在就以Some形式返回,不存在就返回None
scala> b.find(_>20)
res132: Option[Int] = Some(45)
scala> b.find(_==0)
res134: Option[Int] = None
- flatMap
对当前序列的每个元素进行操作,参数要求是GenTraversableOnce及其子类,结果放入新序列返回
scala> c.flatMap(x=> 1 to x )
res139: List[Int] = List(1, 1, 2)
- flatten
扁平化处理,将二维数组的所有元素联合在一起,形成一个一维数组返回
scala> val dArr = Array(Array(1,2,3),Array(4,5,6))
scala> dArr.flatten
res146: Array[Int] = Array(1, 2, 3, 4, 5, 6)
- forall
检测序列中的元素是否全都满足条件,返回true/false
scala> b.forall(_<100)
res154: Boolean = true
scala> b.forall(_<50)
res155: Boolean = false
- foreach(f)
遍历序列中的元素,进行操作
scala> a.foreach(x=>print(x+" "))
zhang wang li 123 123
- groupBy
按条件分组,匹配条件,返回值是Map类型,每个key对应一个序列
scala> b.groupBy(x=>x match{
case x if (x<20) => "small"
case _ => "big"
})
res163: scala.collection.immutable.Map[String,Array[Int]] =
Map(small -> Array(12, 3), big -> Array(45, 78, 96))
- groupde(size)
按指定数量分组,每组size个元素,返回 Iterator[Array[T]]
scala> b.grouped(2).foreach(x=>{print(x.mkString(" "));println()})
12 45
78 96
3
- hasDefinitedSize
检查序列是否存在有限的长度,对应Stream这样的流数据,返回值false
scala> a.hasDefiniteSize
res170: Boolean = true
- head
返回序列的第一个元素,如果序列为空,将引发错误
scala> a.head
res175: Any = zhang
scala> b.head
res176: Int = 12
- tail
返回序列去除第一个元素后的新序列
scala> a.tail
res178: Array[Any] = Array(wang, li, 123, 123)
- tails
连续调用tail,每一次结果作为下一次的新序列,直至序列为空,打印一次空值,返回Iterator[Array[Any]]
scala> a.tails.foreach(x=>{print(i+1+" "+x.mkString(" "));println()})
1 zhang wang li 123 zhao
1 wang li 123 zhao
1 li 123 zhao
1 123 zhao
1 zhao
1
- last
返回序列最后一个元素,如果序列为空,将引发错误
scala> a.last
res184: Any = 123
scala> b.last
res185: Int = 3
- init
返回序列去除最后一个元素后的新序列
scala> a.init
res186: Array[Any] = Array(zhang, wang, li, 123)
scala> b.init
res187: Array[Int] = Array(12, 45, 78, 96)
- headOption
返回序列第一个元素的Option类型,scala.Some,如果序列是空,返回None;通过get方法获取Some类型值
scala> b.headOption
res181: Option[Int] = Some(12)
- lastOption
返回当前序列中最后一个对象
scala> b.lastOption
res262: Option[Int] = Some(3)
- indexOf
返回目标元素在序列指定索引之后的第一个索引位置,没有就返回-1
scala> a.indexOf(13)
res182: Int = -1
scala> a.indexOf(123)
res183: Int = 4
- lastIndexOf(elem,index)
返回序列中[index开始之后的]最后一个等于elem的索引值,没有就返回-1
scala> (b:+45).lastIndexOf(45)
res254: Int = 5
- indexOfSlice(that,index)
检测当前序列中是否包含另一个序列(that),[从指定索引出开始]并返回第一个匹配出现的元素的索引,没有就返回-1
scala> a.indexOfSlice(Array("li","123"))
res198: Int = 2
- lastIndexOfSlice(that,end)
返回当前序列中最后一次出现目标序列的位置处的索引,可以指定在 end 之前(包括)的元素中查找,没有就返回-1
scala> var bb1 = b.union(Array(12,45,20,60,12,45))
bb1: Array[Int] = Array(12, 45, 78, 96, 3, 12, 45, 20, 60, 12, 45)
scala> bb1.lastIndexOfSlice(Array(12,45),7)
res256: Int = 5
- indexWhere(p,index)
返回当前序列中满足条件的第一个元素的索引,可以指定开始位置,没有就返回-1
scala> b.indexWhere(_>50)
res204: Int = 2
scala> b.indexWhere({x:Int => x> 20})
res205: Int = 1
scala> b.indexWhere({x:Int => x> 20},3)
res208: Int = 3
- lastIndexWhere(p,end)
返回当前序列中最后一个满足条件 p 的元素的索引,可以指定在 end 之前(包括)的元素中查找,没有就返回-1
scala> b.lastIndexWhere({x:Int=>x<50})
res260: Int = 4
scala> b.lastIndexWhere({x:Int=>x<50},3)
res261: Int = 1
- indices collection.immutable.Range
返回当前序列索引集合
scala> b.indices
res210: scala.collection.immutable.Range = Range(0, 1, 2, 3, 4)
scala> c.indices
res211: scala.collection.immutable.Range = Range(0, 1)
- inits
对集合中的元素进行init操作,把返回值作为新序列开始第二次init操作,最后一个为空值
scala> b.inits.foreach(x=>println(x.mkString(" ")))
12 45 78 96 3
12 45 78 96
12 45 78
12 45
12
//有一行空行
- isDefinedAt(index)
判断序列中是否存在索引
scala> a.isDefinedAt(5)
res217: Boolean = false
scala> a.isDefinedAt(0)
res218: Boolean = true
- isEmpty
判断集合是否为空,为空返回true
scala> var c2 =new Array[String](0)
c2: Array[String] = Array()
scala> c2.isEmpty
res231: Boolean = true
scala> a.isEmpty
res232: Boolean = false
- nonEmpty
判断序列非空,集合非空返回true
scala> a.nonEmpty
res282: Boolean = true
-
isTraversableAgain
判断序列是否可以反复遍历,Iterators 返回false,常规数组集合返回true -
iterator
对序列中的每个元素产生一个 iterator
scala> a.iterator
res245: Iterator[Any] = non-empty iterator
- toIterator
同 iterator 方法,返回一个迭代器
scala> b.iterator.foreach(x=>print(x+" "))
12 45 78 96 3
- reverseIterator
反向生成迭代器,collection.Iterator[T]
scala> b.reverseIterator.foreach(x=>print(x+" "))
3 96 78 45 12
- length
返回当前序列中元素个数
scala> a.length
res263: Int = 5
- size
返回当前序列中元素个数
scala> a.length
res263: Int = 5
- lengthCompare(len)
比较序列的长度和参数 len,返回序列长度与参数len的差值
x < 0 if this.length < len
x == 0 if this.length == len
x > 0 if this.length > len
- map
对序列中的元素进行相同操作,返回新的序列
scala> b.map({x:Int => x*x})
res269: Array[Int] = Array(144, 2025, 6084, 9216, 9)
- reverseMap
序列元素进行同一操作,逆序输出
scala> b.reverseMap({x:Int=>x*2})
res335: Array[Int] = Array(6, 192, 156, 90, 24)
- max
返回序列中最大的元素
scala> b.max
res274: Int = 96
- min
返回序列中最小的元素
scala> b.min
res275: Int = 3
-
minBy
返回序列中第一个符合条件的最大的元素 -
mkString(str,sep,end)
将所有元素组合成一个字符串,[指定开始符号,分割符号,结束符号]
scala> b.mkString(" ")
res280: String = 12 45 78 96 3
scala> b.mkString("{"," ","}")
res281: String = {12 45 78 96 3}
- padTo(len,elem)
后补齐序列,如果当前序列长度小于 len,产生一个新的序列长度是 len,多出的几个位值填充 elem,否则返回当前序列
scala> c.padTo(5,5)
res285: List[Int] = List(1, 2, 5, 5, 5)
scala> a.padTo(3,5)
res287: Array[Any] = Array(zhang, wang, li, 123, 123)
- partition
按条件将序列拆分成两个新序列,满足条件的放第一个序列中,其余放第二个序列中,返回(Array,Array)
scala> b.partition(_>50)
res291: (Array[Int], Array[Int]) = (Array(78, 96),Array(12, 45, 3))
- patch(from,that,replaced)
批量替换,从原序列第from个元素开始,后面的replaced数量个元素,替换成序列that,返回这个新序列
scala> a.patch(3,Array("change","111","do"),1)
res296: Array[Any] = Array(zhang, wang, li, change, 111, do, 123)
- prefixLength§
给定一个条件 p,返回一个前置数列的长度,这个数列中的元素都满足 p,匹配序列满足条件的元素,遇到不满足的元素则停止,统计当前满足条件的元素个数
scala> b.prefixLength(_%2==0)
res308: Int = 1
scala> b.prefixLength(_>20)
res309: Int = 0
scala> b.prefixLength(_>10)
res310: Int = 4
- product
返回所有元素乘积的值
scala> b.product
res313: Int = 12130560
scala> d.product
res312: Int = 12
- sum
返回所有元素累加的值
scala> b.sum
res314: Int = 234
scala> c.sum
res315: Int = 3
- reduce
序列元素顺序执行操作,每一次执行结果和下一个元素进行同一操作
scala> b.reduce(seqno)
seq_exp=12+45
seq_exp=57+78
seq_exp=135+96
seq_exp=231+3
res321: Int = 234
scala> b.reduce(_+_)
res322: Int = 234
- reduceLeft
序列元素从左向右执行相同操作,每一次结果和下一个元素进行同一操作
scala> b.reduceLeft(seqno)
seq_exp=12+45
seq_exp=57+78
seq_exp=135+96
seq_exp=231+3
res326: Int = 234
- reduceRight
序列元素从右向左执行相同操作,每一次结果和下一个元素进行同一操作
scala> b.reduceRight(seqno)
seq_exp=96+3
seq_exp=78+99
seq_exp=45+177
seq_exp=12+222
res325: Int = 234
- reduceLeftOption
计算Option
scala> b.reduceLeftOption(seqno)
seq_exp=12+45
seq_exp=57+78
seq_exp=135+96
seq_exp=231+3
res329: Option[Int] = Some(234)
- reduceRightOption
计算Option
scala> b.reduceRightOption(seqno)
seq_exp=96+3
seq_exp=78+99
seq_exp=45+177
seq_exp=12+222
res330: Option[Int] = Some(234)
- reverse
返回新的反转序列
scala> b.reverse
res327: Array[Int] = Array(3, 96, 78, 45, 12)
- sameElements(that )
判断两个序列是否顺序和对应位置上的元素都一样
b1: Array(1, 2, 3, 4)
b2:List(1,2,3,4)
c: List(1, 2)
scala> b1.sameElements(c)
res347: Boolean = false
scala> c.sameElements(b1)
res348: Boolean = false
scala> b2.sameElements(b1)
res349: Boolean = true
- scan(value)(op)
序列元素顺序执行操作,每一次执行结果和下一个元素进行同一操作,每一步计算结果放到新的集合中返回
scala> b.scan(0)(seqno)
seq_exp=0+12
seq_exp=12+45
seq_exp=57+78
seq_exp=135+96
seq_exp=231+3
res367: Array[Int] = Array(0, 12, 57, 135, 231, 234)
- scanLeft
从左向右计算
scala> b.scanLeft(0)(seqno)
seq_exp=0+12
seq_exp=12+45
seq_exp=57+78
seq_exp=135+96
seq_exp=231+3
res368: Array[Int] = Array(0, 12, 57, 135, 231, 234)
- scanRight
从右向左计算
scala> b.scanRight(0)(seqno)
seq_exp=3+0
seq_exp=96+3
seq_exp=78+99
seq_exp=45+177
seq_exp=12+222
res369: Array[Int] = Array(234, 222, 177, 99, 3, 0)
- segmentLength(p,from)
从序列的 from 处开始向后查找,所有满足 p 的连续元素的长度
scala> b.segmentLength(_%2==0,0)
res35: Int = 1
- seq
产生一个当前数组的可变数组视图,collection.mutable.IndexedSeq[T]
scala> a.seq
res370: scala.collection.mutable.IndexedSeq[Any] =
WrappedArray(zhang, wang, li, 123, 123)
- slice(from,until)
取出当前序列中,下标from 到 until (不含)之间的序列
scala> a.slice(1,3)
res371: Array[Any] = Array(wang, li)
- sliding(size,step)
序列按长度size取值,往后移动step再次取值,返回新数组,最终组成一个新的集合返回,当剩余元素不够 size 数,则停止,返回类型collection.Iterator[Array[T]]
scala> b.sliding(4,2)
res381: Iterator[Array[Int]] = non-empty iterator
scala> b.sliding(4,2).foreach(x=>{print(x.mkString(" "));println()})
12 45 78 96
78 96 3
- sortBy(f)
序列按指定排序规则排序。返回新的序列
scala> b.sortBy({x:Int=>x})
res384: Array[Int] = Array(3, 12, 45, 78, 96)
scala> b.sortBy({x:Int=> 10-x})
res386: Array[Int] = Array(96, 78, 45, 12, 3)
- sortWith
自定义排序方法
scala> b.sortWith(_.compareTo(_)>0)
res393: Array[Int] = Array(96, 78, 45, 12, 3)
- sorted()
使用默认的排序规则对序列排序,升序
scala> b.sorted
res387: Array[Int] = Array(3, 12, 45, 78, 96)
- span
分割序列为两个集合,从第一个元素开始,直到找到第一个不满足条件的元素止,
之前的元素放到第一个集合,其它的放到第二个集合,返回类型(Array[T], Array[T])
scala> b.span(_>20)
res395: (Array[Int], Array[Int]) = (Array(),Array(12, 45, 78, 96, 3))
- splitAt(n)
从指定位置开始,把序列拆分成两个集合,返回类型(Array[T], Array[T])
scala> b.splitAt(3)
res396: (Array[Int], Array[Int]) = (Array(12, 45, 78),Array(96, 3))
- stringPrefix
返回 toString 结果的前缀
scala> c.toString
res404: String = List(1, 2)
scala> c.stringPrefix
res403: String = List
scala> b.toString
res401: String = [I@6a1562d6
scala> b.stringPrefix
res399: String = [I
scala> a.toString
res402: String = [Ljava.lang.Object;@3675bbaf
scala> a.stringPrefix
res400: String = Object;
- subSequence(start,end)
返回 start 和 end (不含)间的字符序列,返回类型CharSequence
scala> val chars = Array('a','b','c','d')
chars: Array[Char] = Array(a, b, c, d)
scala> chars.subSequence(0,2)
res408: CharSequence = ab
- take(int)
返回当前序列中前 n 个元素组成的序列
scala> a.take(2)
res410: Array[Any] = Array(zhang, wang)
- takeRight(int)
返回当前序列中,从右边开始,选择 n 个元素组成的序列
scala> a.takeRight(3)
res411: Array[Any] = Array(li, 123, 123)
- takeWhile
返回当前序列中,从第一个元素开始,满足条件的连续元素组成的序列
scala> b.takeWhile(_>10)
res413: Array[Int] = Array(12, 45, 78, 96)
-
toArray
转换成 Array 类型 -
toVector
数组转换为Vector类型
scala> a.to
res414: scala.collection.immutable.IndexedSeq[Any] = Vector(zhang, wang, li, 123, 123)
- toBuffer
转换成 Buffer 类型,ArrayBuffer
scala> a.toBuffer
res425: scala.collection.mutable.Buffer[Any] = ArrayBuffer(zhang, wang, li, 123, 123)
- toList
返回List集合
scala> a.toList
res427: List[Any] = List(zhang, wang, li, 123, 123)
- transpose
矩阵转换,二维数组行列转换,返回类型 Array[Array[U]]
val chars = Array(Array("a","b"),Array("c","d"),Array("e","f"))
chars: Array[Array[String]] = Array(Array(a, b), Array(c, d), Array(e, f))
a b
c d
e f
scala> chars.transpose
res430: Array[Array[String]] = Array(Array(a, c, e), Array(b, d, f))
a c e
d b f
- unzip
将含有两个元组的数组,第一个元素取出组成一个序列,第二个元素组成一个序列,返回类型 (Array[T1], Array[T2])
val chars = Array(("a","b"),("c","d"))
chars: Array[(String, String)] = Array((a,b), (c,d))
scala> chars.unzip
res433: (Array[String], Array[String]) = (Array(a, c),Array(b, d))
scala> var chars=Array((1,4),(2,3))
chars: Array[(Int, Int)] = Array((1,4), (2,3))
scala> chars.unzip
res438: (Array[Int], Array[Int]) = (Array(1, 2),Array(4, 3))
- unzip3
将含有三个元组的数组,第一个元素取出组成一个序列,第二个元素组成一个序列,第三个元素组成一个序列,返回类型(Array[T1], Array[T2],Array[T3])
scala> val chars = Array(("a","b","x"),("c","d","y"),("e","f","z"))
chars: Array[(String, String, String)] = Array((a,b,x), (c,d,y), (e,f,z))
scala> chars.unzip3
res439: (Array[String], Array[String], Array[String]) =
(Array(a, c, e),Array(b, d, f),Array(x, y, z))
scala> val chars = Array((1,"b","x"),(2,"d","y"),(1,"f","z"))
chars: Array[(Int, String, String)] = Array((1,b,x), (2,d,y), (1,f,z))
scala> chars.unzip3
res441: (Array[Int], Array[String], Array[String]) =
Array(1, 2, 1),Array(b, d, f),Array(x, y, z))
- update(int,T)
将原数组序列中 i 索引处的元素更新为 x
scala> a.update(4,"zhao")
scala> a
res461: Array[Any] = Array(zhang, wang, li, 123, zhao)
- updated(index,elem)
将序列中 i 索引处的元素更新为 x ,并返回替换后的新数组
scala> a.updated(3,"chang")
res462: Array[Any] = Array(zhang, wang, li, chang, zhao)
scala> a
res463: Array[Any] = Array(zhang, wang, li, 123, zhao)
- view(from,until)
返回 from 到 until 间的序列,不包括 until 处的元素,返回类型IndexedSeqView[T, Array[T]]
scala> b.view(1,4)
res32: scala.collection.mutable.IndexedSeqView[Int,Array[Int]] = SeqViewS(...)
116.withFilter
按条件过滤序列,滤出符合条件的元素,返回类型为scala.collection.generic.FilterMonadic
scala> b.withFilter(_%2==0)
res31: scala.collection.generic.FilterMonadic[Int,Array[Int]] = scala.collection.TraversableLike$WithFilter@6b7c4734
- zip(that)
将两个序列对应位置上的元素组成一个pair序列,直至某个序列元素结束
scala> a.zip(b)
res471: Array[(Any, Int)] = Array((zhang,20), (wang,45), (li,78), (123,96), (zhao,3))
- zipAll(that,thisElem,thatElem)
将两个序列对应位置上的元素组成一个pair序列,如果当前序列短,空出的填充为 thisElem,如果 that 短,填充为 thatElem
scala> a.zipAll(c,"a","c")
res476: Array[(Any, Any)] = Array((zhang,1), (wang,2), (li,c), (123,c), (zhao,c))
scala> c.zipAll(a,"c","a")
res477: List[(Any, Any)] = List((1,zhang), (2,wang), (c,li), (c,123), (c,zhao))
- zipWithIndex
序列中的每个元素和它的索引组成一个序列,返回类型和当前序列相同
scala> a.zipWithIndex
res478: Array[(Any, Int)] = Array((zhang,0), (wang,1), (li,2), (123,3), (zhao,4))
scala> c.zipWithIndex
res479: List[(Int, Int)] = List((1,0), (2,1))
上一篇: There was an unexpected error (type=Bad Request, status=400).以及@RequestBody和@RequestParam区别
下一篇: k8s+gitlab实现cicd
推荐阅读
-
PHP中call_user_func_array()函数的用法演示_php入门_脚本之家
-
PHP 在数组中搜索给定的简单实例 array_search 函数,数组array_search
-
php中Curl函数常用的两个例子_PHP教程
-
PHP中array_keys和array_unique函数源码的分析_PHP
-
PHP 在数组中搜索给定的简单实例 array_search 函数
-
PHP 常用数组内部函数(Array Functions)介绍_php技巧
-
python中pickle模块的常用函数及代码示例讲解
-
【PHP】array_walk_recursive ― 对数组中的每个成员递归地施用用户函数
-
php数组函数序列之array_pop() - 删除数组中的最后一个元素_PHP教程
-
javascript中关于array的常用方法