欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

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)
  1. ++ 或者 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)
  1. ++:
    合并集合,并返回一个新的集合,新集合包含左右两个集合对象的内容,返回类型和右边的相同
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)
  1. 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)
  1. intersect
    集合交集,返回两个集合公共的元素集合,返回类型和当前集合一样
scala> b.intersect(d)
res18: Array[Int] = Array(3)
scala> d.intersect(b)
res19: scala.collection.mutable.LinkedList[Int] = LinkedList(3)
  1. +:
    在数组前面添加一个元素,并返回新的对象
scala> 100 +: b
res116: Array[Int] = Array(100, 12, 45, 78, 96, 3)
  1. :+
    在数组末尾添加一个元素,并返回新对象
scala> b :+ 0
res117: Array[Int] = Array(12, 45, 78, 96, 3, 0)
  1. /: 等价 foldLeft(v)(f)
    把v和第一个进行f操作,结果和下一个元素进行相同操作,数组取值从左到右,结果值返回
scala> ( 10/:b)(_-_)  //10-12-45-78-96-3=-224
res28: Int = -224
  1. fold(v)(f)
    把v和数组的个第个一元素进行二元运算,得到结果和下一个元素做相操同作,返回结果值
scala> b.fold(10)(_+_)
res19: Int = 244
  1. :\ 等价 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
/
  1. addString(StringBuilder b)
    将数组中的元素逐个追加到b中 返回StringBuilder
scala> a.addString(a1)
res20: StringBuilder = zhangwangli123123
  1. addString(b: StringBuilder, sep: String)
    将数组中的元素逐个追加到b中,每个元素用sep分隔符分开
scala> a.addString(a1,",")
res22: StringBuilder = zhangwangli123123zhang,wang,li,123,123
  1. 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}
  1. aggregate[B](z: ⇒ B)(seqop, combop) B
    聚合计算,柯里化方法
scala> b.par.aggregate(10)(_-_,_-_)
  1. par
    返回一个并行实现,产生的并行序列, ParArray
scala> a.par
res289: scala.collection.parallel.mutable.ParArray[Any] = ParArray(zhang, wang, li, 123, 123)
  1. apply(i: Int)
    取出指定索引处的元素
scala> var a =Array("zhang","wang","li","123",123)
scala> a.apply(0)
res130: Any = zhang
  1. canEqual(that: Any): Boolean
    判断两个对象是否可以进行比较
scala> a.canEqual("asd")
res131: Boolean = true
  1. charAt(index) charAt
    获取index索引处的字符,这个方法会执行一个隐式的转换,
    将Array[T]转换为 ArrayCharSequence,只有当T为char类型时,这个转换才会发生。
val chars = Array('a','b','c')
chars.charAt(2)
res:Char=c
  1. clone: Array[T]
    创建一个新的副本
scala> var c = a.clone
c: Array[Any] = Array(zhang, wang, li, 123, 123)
  1. 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})
  1. collectFirst(pf) Option
    在序列中查找第一个符合偏函数定义的元素,并执行偏函数计算
  val fun:PartialFunction[Any,Int] = {
    case x:Int => x*100
  }
scala> a.collectFirst(fun)
res60: Option[Int] = Some(12300)/None
  1. 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
  1. 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
  1. contains(elem: A1): Boolean
    序列中是否包含指定对象
scala> a.contains("123")
res67: Boolean = true
  1. 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
  1. 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)
  1. corresponds(arr)
    判断两个序列长度以及对应位置元素是否符合某个条件。
scala> d.corresponds(c)(_>_)
res81: Boolean = true
  1. count
    统计数组中满足条件的元素个数
scala> c.count(p=>p%2==0)
res154: Int = 4
  1. distinct Array
    去除当前集合中重复的元素,只保留一个,返回一个新的数组
var arr =Array(1,1,0,4,6,3)
scala> arr.distinct
res93: Array[Int] = Array(1, 0, 4, 6, 3)
  1. drop
    将当前序列中前 n 个元素去除后,作为一个新序列返回
scala> a.drop(2)
res96: Array[Any] = Array(li, 123, 123)
scala> a
res97: Array[Any] = Array(zhang, wang, li, 123, 123)
  1. dropRight(int)
    将当前序列中前 n 个元素去除后,作为一个新序列返回
scala> var b =Array(12,45,78,96,3)
scala> b.dropRight(3)
res143: Array[Int] = Array(12, 45)
  1. dropWhile
    从数组首个开始匹配,去除满足条件的元素(遇到不满足条件则停止),返回不满足条件的元素集合
scala> b.dropWhile(_%2==0)
res110: Array[Int] = Array(45, 78, 96, 3)
  1. filter
    过滤出当前数组满足条件的元素,返回新的数组
scala> b.filter(_%2==0)
res111: Array[Int] = Array(12, 78, 96)
  1. filterNot
    过滤出当前数组不满足条件的元素,返回新的数组
scala> b.filterNot(_%2==0)
res112: Array[Int] = Array(45, 3)
  1. exists
    判断当前数组是否包含符合条件的元素
scala> b.exists(_<10)
res120: Boolean = true
scala> b.exists(_%2 ==0)
res124: Boolean = true
  1. endsWith
    判断当前序列是否以某个序列结尾
scala> b.endsWith(Array(78,96,3))
res126: Boolean = true
scala> b.endsWith(List(78,96,3))
res127: Boolean = true
  1. startsWith
    判断当前序列是否以某个序列开始
scala> b.startsWith(Array(12,45))
res130: Boolean = true
scala> b.startsWith(Array(13))
res131: Boolean = false
  1. find
    找到满足条件的第一个元素,存在就以Some形式返回,不存在就返回None
scala> b.find(_>20)
res132: Option[Int] = Some(45)
scala> b.find(_==0)
res134: Option[Int] = None
  1. flatMap
    对当前序列的每个元素进行操作,参数要求是GenTraversableOnce及其子类,结果放入新序列返回
scala> c.flatMap(x=> 1 to x )
res139: List[Int] = List(1, 1, 2)
  1. 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)
  1. forall
    检测序列中的元素是否全都满足条件,返回true/false
scala> b.forall(_<100)
res154: Boolean = true
scala> b.forall(_<50)
res155: Boolean = false
  1. foreach(f)
    遍历序列中的元素,进行操作
scala> a.foreach(x=>print(x+" "))
zhang wang li 123 123
  1. 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))
  1. groupde(size)
    按指定数量分组,每组size个元素,返回 Iterator[Array[T]]
scala> b.grouped(2).foreach(x=>{print(x.mkString(" "));println()})
12 45
78 96
3
  1. hasDefinitedSize
    检查序列是否存在有限的长度,对应Stream这样的流数据,返回值false
scala> a.hasDefiniteSize
res170: Boolean = true
  1. head
    返回序列的第一个元素,如果序列为空,将引发错误
scala> a.head
res175: Any = zhang
scala> b.head
res176: Int = 12
  1. tail
    返回序列去除第一个元素后的新序列
scala> a.tail
res178: Array[Any] = Array(wang, li, 123, 123)
  1. 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
  1. last
    返回序列最后一个元素,如果序列为空,将引发错误
scala> a.last
res184: Any = 123
scala> b.last
res185: Int = 3
  1. init
    返回序列去除最后一个元素后的新序列
scala> a.init
res186: Array[Any] = Array(zhang, wang, li, 123)
scala> b.init
res187: Array[Int] = Array(12, 45, 78, 96)
  1. headOption
    返回序列第一个元素的Option类型,scala.Some,如果序列是空,返回None;通过get方法获取Some类型值
scala> b.headOption
res181: Option[Int] = Some(12)
  1. lastOption
    返回当前序列中最后一个对象
scala> b.lastOption
res262: Option[Int] = Some(3)
  1. indexOf
    返回目标元素在序列指定索引之后的第一个索引位置,没有就返回-1
scala> a.indexOf(13)
res182: Int = -1
scala> a.indexOf(123)
res183: Int = 4
  1. lastIndexOf(elem,index)
    返回序列中[index开始之后的]最后一个等于elem的索引值,没有就返回-1
scala> (b:+45).lastIndexOf(45)
res254: Int = 5
  1. indexOfSlice(that,index)
    检测当前序列中是否包含另一个序列(that),[从指定索引出开始]并返回第一个匹配出现的元素的索引,没有就返回-1
scala> a.indexOfSlice(Array("li","123"))
res198: Int = 2
  1. 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
  1. 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
  1. 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
  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)
  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
//有一行空行
  1. isDefinedAt(index)
    判断序列中是否存在索引
scala> a.isDefinedAt(5)
res217: Boolean = false
scala> a.isDefinedAt(0)
res218: Boolean = true
  1. 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
  1. nonEmpty
    判断序列非空,集合非空返回true
scala> a.nonEmpty
res282: Boolean = true
  1. isTraversableAgain
    判断序列是否可以反复遍历,Iterators 返回false,常规数组集合返回true

  2. iterator
    对序列中的每个元素产生一个 iterator

scala> a.iterator
res245: Iterator[Any] = non-empty iterator
  1. toIterator
    同 iterator 方法,返回一个迭代器
scala> b.iterator.foreach(x=>print(x+" "))
12 45 78 96 3
  1. reverseIterator
    反向生成迭代器,collection.Iterator[T]
scala> b.reverseIterator.foreach(x=>print(x+" "))
3 96 78 45 12
  1. length
    返回当前序列中元素个数
scala> a.length
res263: Int = 5
  1. size
    返回当前序列中元素个数
scala> a.length
res263: Int = 5
  1. lengthCompare(len)
    比较序列的长度和参数 len,返回序列长度与参数len的差值
x <  0       if this.length <  len
x == 0       if this.length == len
x >  0       if this.length >  len
  1. map
    对序列中的元素进行相同操作,返回新的序列
scala> b.map({x:Int => x*x})
res269: Array[Int] = Array(144, 2025, 6084, 9216, 9)
  1. reverseMap
    序列元素进行同一操作,逆序输出
scala> b.reverseMap({x:Int=>x*2})
res335: Array[Int] = Array(6, 192, 156, 90, 24)
  1. max
    返回序列中最大的元素
scala> b.max
res274: Int = 96
  1. min
    返回序列中最小的元素
scala> b.min
res275: Int = 3
  1. minBy
    返回序列中第一个符合条件的最大的元素

  2. mkString(str,sep,end)
    将所有元素组合成一个字符串,[指定开始符号,分割符号,结束符号]

scala> b.mkString(" ")
res280: String = 12 45 78 96 3

scala> b.mkString("{"," ","}")
res281: String = {12 45 78 96 3}
  1. 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)
  1. partition
    按条件将序列拆分成两个新序列,满足条件的放第一个序列中,其余放第二个序列中,返回(Array,Array)
scala> b.partition(_>50)
res291: (Array[Int], Array[Int]) = (Array(78, 96),Array(12, 45, 3))
  1. 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)
  1. 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
  1. product
返回所有元素乘积的值
scala> b.product
res313: Int = 12130560
scala> d.product
res312: Int = 12
  1. sum
    返回所有元素累加的值
scala> b.sum
res314: Int = 234
scala> c.sum
res315: Int = 3
  1. 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
  1. reduceLeft
    序列元素从左向右执行相同操作,每一次结果和下一个元素进行同一操作
scala> b.reduceLeft(seqno)
seq_exp=12+45
seq_exp=57+78
seq_exp=135+96
seq_exp=231+3
res326: Int = 234
  1. reduceRight
    序列元素从右向左执行相同操作,每一次结果和下一个元素进行同一操作
scala> b.reduceRight(seqno)
seq_exp=96+3
seq_exp=78+99
seq_exp=45+177
seq_exp=12+222
res325: Int = 234
  1. 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)
  1. 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)
  1. reverse
    返回新的反转序列
scala> b.reverse
res327: Array[Int] = Array(3, 96, 78, 45, 12)
  1. 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
  1. 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)
  1. 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)
  1. 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)
  1. segmentLength(p,from)
    从序列的 from 处开始向后查找,所有满足 p 的连续元素的长度
scala> b.segmentLength(_%2==0,0)
res35: Int = 1
  1. seq
    产生一个当前数组的可变数组视图,collection.mutable.IndexedSeq[T]
scala> a.seq
res370: scala.collection.mutable.IndexedSeq[Any] =
WrappedArray(zhang, wang, li, 123, 123)
  1. slice(from,until)
    取出当前序列中,下标from 到 until (不含)之间的序列
scala> a.slice(1,3)
res371: Array[Any] = Array(wang, li)
  1. 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
  1. 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)
  1. sortWith
    自定义排序方法
scala> b.sortWith(_.compareTo(_)>0)
res393: Array[Int] = Array(96, 78, 45, 12, 3)			
  1. sorted()
    使用默认的排序规则对序列排序,升序
scala> b.sorted
res387: Array[Int] = Array(3, 12, 45, 78, 96)
  1. span
    分割序列为两个集合,从第一个元素开始,直到找到第一个不满足条件的元素止,
    之前的元素放到第一个集合,其它的放到第二个集合,返回类型(Array[T], Array[T])
scala> b.span(_>20)
res395: (Array[Int], Array[Int]) = (Array(),Array(12, 45, 78, 96, 3))
  1. splitAt(n)
    从指定位置开始,把序列拆分成两个集合,返回类型(Array[T], Array[T])
scala> b.splitAt(3)
res396: (Array[Int], Array[Int]) = (Array(12, 45, 78),Array(96, 3))
  1. 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;
  1. 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
  1. take(int)
    返回当前序列中前 n 个元素组成的序列
scala> a.take(2)
res410: Array[Any] = Array(zhang, wang)
  1. takeRight(int)
    返回当前序列中,从右边开始,选择 n 个元素组成的序列
scala> a.takeRight(3)
res411: Array[Any] = Array(li, 123, 123)
  1. takeWhile
    返回当前序列中,从第一个元素开始,满足条件的连续元素组成的序列
scala> b.takeWhile(_>10)
res413: Array[Int] = Array(12, 45, 78, 96)
  1. toArray
    转换成 Array 类型

  2. toVector
    数组转换为Vector类型

scala> a.to
res414: scala.collection.immutable.IndexedSeq[Any] = Vector(zhang, wang, li, 123, 123)
  1. toBuffer
    转换成 Buffer 类型,ArrayBuffer
scala> a.toBuffer
res425: scala.collection.mutable.Buffer[Any] = ArrayBuffer(zhang, wang, li, 123, 123)
  1. toList
    返回List集合
scala> a.toList
res427: List[Any] = List(zhang, wang, li, 123, 123)
  1. 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
  1. 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))
  1. 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))
  1. update(int,T)
    将原数组序列中 i 索引处的元素更新为 x
scala> a.update(4,"zhao")
scala> a
res461: Array[Any] = Array(zhang, wang, li, 123, zhao)
  1. 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)
  1. 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
  1. zip(that)
    将两个序列对应位置上的元素组成一个pair序列,直至某个序列元素结束
scala> a.zip(b)
res471: Array[(Any, Int)] = Array((zhang,20), (wang,45), (li,78), (123,96), (zhao,3))
  1. 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))
  1. 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))
相关标签: scala spark