Scala Array函数大全详解

最新推荐文章于 2022-06-07 23:26:38 发布

数据孤岛

最新推荐文章于 2022-06-07 23:26:38 发布

阅读量484

点赞数

分类专栏： Scala 文章标签： scala spark

本文链接：https://blog.csdn.net/m0_46657040/article/details/108494077

版权

Scala 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

所有Array的函数

++              count            hasDefiniteSize      maxBy               sameElements    toBuffer
++:             deep             head                 min                 scan            toIndexedSeq
+:              diff             headOption           minBy               scanLeft        toIterable
/:              distinct         indexOf              mkString            scanRight       toIterator
:+              drop             indexOfSlice         nonEmpty            segmentLength   toList
:\              dropRight        indexWhere           orElse              seq             toMap
addString       dropWhile        indices              padTo               size            toSeq
aggregate       elemManifest     init                 par                 slice           toSet
andThen         elemTag          inits                partition           sliding         toStream
apply           endsWith         intersect            patch               sortBy          toTraversable
applyOrElse     exists           isDefinedAt          permutations        sortWith        toVector
array           filter           isEmpty              prefixLength        sorted          transform
canEqual        filterNot        isTraversableAgain   product             span            transpose
clone           find             iterator             reduce              splitAt         union
collect         flatMap          last                 reduceLeft          startsWith      unzip
collectFirst    flatten          lastIndexOf          reduceLeftOption    stringPrefix    unzip3
combinations    fold             lastIndexOfSlice     reduceOption        sum             update
companion       foldLeft         lastIndexWhere       reduceRight         tail            updated
compose         foldRight        lastOption           reduceRightOption   tails           view
contains        forall           length               repr                take            withFilter
containsSlice   foreach          lengthCompare        reverse             takeRight       zip
copyToArray     genericBuilder   lift                 reverseIterator     takeWhile       zipAll
copyToBuffer    groupBy          map                  reverseMap          to              zipWithIndex
corresponds     grouped          max                  runWith             toArray

++

val k=Array(1,2,3,“a”)
k: Array[Any] = Array(1, 2, 3, a)
scala> val b=Array(1,“a”)
b: Array[Any] = Array(1, a)
scala> k.++(b)
res13: Array[Any] = Array(1, 2, 3, a, 1, a)

++:

右边类型决定最终类型
val a = List(1,2)
val b = scala.collection.mutable.LinkedList(3,4)
val c = a ++: b
println(c.getClass().getName())
scala.collection.mutable.LinkedList

+:

24+:k
res14: Array[Any] = Array(24, 1, 2, 3, a)

:+

k:+24
res15: Array[Any] = Array(1, 2, 3, a, 24)

/:

val y=Array(1,2,3)
(10/:y)(+) 10+1+2+3 左子树
res16: Int = 16

:\

val y=Array(1,2,3)
(y:\10)(+) 10+3+2+1 右子树
res16: Int = 16

addString

拼成字符串
def addString(b: StringBuilder): StringBuilder
def addString(b: StringBuilder,sep: String): StringBuilder
def addString(b: StringBuilder,start: String,sep: String,end: String): StringBuilder
案例
var k=Array(11,22,33)
var g=new StringBuilder(“asd”)
k.addString(g)
res7: StringBuilder = asd112233 把数组k内容直接拼接到StringBuilder g后面
或
k.addString(g,"/")
res6: StringBuilder = asd11/22/33 把数组k内容以/分割开拼接到StringBuilder g后面
或
k.addString(g,“w”,"/",“u”)
res13: StringBuilder = asdw11/22/33u 把数组k内容以/分割开，并在k的开头和结尾加w和u然后拼接到StringBuilder g后面

aggregate

聚合计算，aggregate是柯里化方法，参数是两个方法，为了方便理解，我们把aggregate的两个参数，分别封装成两个方法，并把计算过程打印出来。

def main(args: Array[String]) {
val a = List(1,2,3,4)
seqno只执行一遍,combine执行多遍
val c = a.par.aggregate(5)(seqno,combine)
println(“c:”+c)
}
def seqno(m:Int,n:Int): Int ={
val s = “seq_exp=%d+%d”
println(s.format(m,n))
return m+n
}
def combine(m:Int,n:Int): Int ={
val s = “com_exp=%d+%d”
println(s.format(m,n))
return m+n
}

seq_exp=5+3
seq_exp=5+2
seq_exp=5+4
seq_exp=5+1
com_exp=6+7
com_exp=8+9
com_exp=13+17
c:30

compose 与 andThen

def abc(a:Int)={
a+2
}
def cde(a:Int)={
a*3
}
def aa=abc _ compose cde _ 先调后面函数再调前面的函数

aa(1) abc(cde(1))
res22: Int = 5
def bb=abc _ andThen cde _ 先调前面函数再调后面的函数
bb(1) cde(abc(1))
res24: Int = 9

apply

apply(i: Int): T
取出索引处的元素
val y=Array(4,5,6)
y.apply(1)
res46: Int = 5

applyOrElse

array

array(index:Int): T
var a = Array(1,2,3,“a”)
a.array(2)
3

canEqual

canEqual(that: Any): Boolean
判断两个对象能不能比较
val a=Array(1,2,3)
val b=Array(1,2,3)
a.canEqual(b)
res143: Boolean = true

charAt

charAt(index: Int): Char
获取index索引处的字符
val r = Array(‘a’,‘b’,‘d’)
r.charAt(0) 等价于 r.apply(0)
res47: Char = a

clone

clone(): Array[T]
克隆不改变原值
var k = Array(1,2,3,“a”)
var j = k.clone()
j
res48: Array[Any] = Array(1, 2, 3, a)
j(0)=100
j
res50: Array[Any] = Array(100, 2, 3, a)
k
res51: Array[Any] = Array(1, 2, 3, a)

var aa = Array(1,2,3) 克隆里面对象是浅克隆，值会变
var k = Array(10,3,aa)
k: Array[Any] = Array(10, 3, Array(1, 2, 3, a))
var j= k.clone()
aa(1)=10 aa的值变化后k和j也会变化，因为k和j引用指向aa
scala> k
res13: Array[Any] = Array(10, 3, Array(1, 10, 3))
scala> j
res14: Array[Any] = Array(10, 3, Array(1, 10, 3))

j引用k的地址，j值变化时k的值也会变
var k=Array(1,2,3,“a”)
var j=k
j(0)=100
j
res53: Array[Any] = Array(100, 2, 3, a)
k
res54: Array[Any] = Array(100, 2, 3, a)

collect

collect[B](pf: PartialFunction[A, B]): Array[B]
通过执行一个并行计算（偏函数），得到一个新的数组对象
偏函数只对一部分数据进行处理
val a=Array(1,2,3,4)
val func:PartialFunction[Int,Int]={
case x if x%2==0 => x+2
case x=>x+1
}
a.collect(func)
res1: Array[Int] = Array(2, 4, 4, 6)

偏函数定义：
进入是Int,出来是Int
val func:PartialFunction[Int,Int]={
case x if x%2==0 => x+2
case _=>1 其它任何数直接变成1
}

a.map(func) 不支持偏函数

collectFirst

collectFirst[B](pf: PartialFunction[T, B]): Option[B]
通过执行一个并行计算（偏函数），得到一个新的数组对象的第一个值
val a=Array(1,2,3,4)
val func:PartialFunction[Int,Int]={
case x if x%2==0 => x+2
}
a.collect(func)
res2: Array[Int] = Array(4, 6)

collectFirst
a.collectFirst(func)
res4: Option[Int] = Some(4)

a.collectFirst(func).get Some类型用get取值，结果是4

combinations

combinations(n: Int): collection.Iterator[Array[T]]
排列组合，这个排列组合会选出所有包含字符不一样的组合
对于 “12”、“21”，只选择一个，参数n表示序列长度，就是几个字符为一组
val a=Array(1,2,3,4)
a.combinations(2)
res5: Iterator[Array[Int]] = non-empty iterator
res5.foreach(x=>println(x.mkString(",")))
1,2
1,3
1,4
2,3
2,4
3,4

companion

companion(b):ArrayBuffer(b)
var a = Array(1,2,3,“a”)
a.companion(1,5)
res25: scala.collection.mutable.IndexedSeq[Int] = ArrayBuffer(1, 5)

contains

contains[A1 >: A](elem: A1): Boolean
序列中是否包含指定对象
val a=Array(1,2,3,4)
a.contains(5) false
a.contains(4) true

containsSlice

containsSlice[B](that: GenSeq[B]): Boolean
判断当前序列中是否包含另一个序列包含必须顺序一样
val b=Array(1,2,3,Array(4,5))
val c=Array(4,5)
b.containsSlice© false 不要写Array,识别不了

val b=Array(1,2,3,4)
val c=Array(1,2)
b.containsSlice© true

copyToArray

copyToArray(xs: Array[A]): Unit
val a=Array(‘a’,‘b’,‘c’)
val b=new ArrayChar
a.copyToArray(b)
res3: Array[Char] = Array(a, b, c, ?, ?)

copyToBuffer

copyToBuffer[B >: A](dest: Buffer[B]): Unit

import scala.collection.mutable.ArrayBuffer
val a=Array(1,2,3,4)
var d =new ArrayBufferInt
a.copyToBuffer(d)
res6: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4)

corresponds

corresponds[B](that: GenSeq[B])(p: (T, B) ⇒ Boolean): Boolean
判断两个序列长度以及对应位置元素是否符合某个条件。
如果两个序列具有相同的元素数量并且p(x, y)=true，返回结果为true
val a = Array(1, 2, 3)
val b = Array(4, 5, 6)
a.corresponds(b)(<)
res4: Boolean = true

如果两个序列不对应直接false
集合的底层就是数组，所以下面是true
import scala.collection.mutable.ArrayBuffer
val a=List(1,2,3,4)
val b =List(2,3,4,5)
a.corresponds(b)(<)
res58: Boolean = true

count

count(p: (T) ⇒ Boolean): Int
统计符合条件的元素个数
var a=Array(1,2,3,4)
Int取决于数组的类型
a: Array[Int] = Array(1, 2, 3, 4)
a.count(x=> x%2==0)
res7: Int = 2

var a=Array(“Hello”,“world”,“hadoop”)
a.count(x=> x.contains(‘o’))
a.count(x=> x.indexOf(‘o’)> -1)
res9: Int = 3

deep

deep: IndexedSeq[Any] 返回Any类型数组
val a = Array(1,2,3,4)
a.deep
res31: IndexedSeq[Any] = Array(1, 2, 3, 5, 2, 6)
a.deep(2)
res30: Any = 3

diff

diff(that: collection.Seq[T]): Array[T]
计算当前数组与另一个数组的不同。
将当前数组中没有在另一个数组中出现的元素返回

val a = Array(1,2,3,4)
val b = Array(4,5,1,7)
看看数组a里有哪些数组b没有的元素
val c = a.diff(b)
c: Array[Int] = Array(2, 3)

distinct

distinct: Array[T]
去重
val a=Array(1,1,2,3,4)
a.distinct
res13: Array[Int] = Array(1, 2, 3, 4)

drop

drop(n: Int): Array[T]
将当前序列中前 n 个元素去除后，作为一个新序列返回
val a = Array(1, 2, 3,4)
a.drop(2)
res14: Array[Int] = Array(3, 4)

dropRight

dropRight(n: Int): Array[T]
去掉尾部的 n 个元素
val a = Array(1, 2, 3,4)
a.dropRight(2)
res15: Array[Int] = Array(1, 2)

dropWhile

dropWhile(p: (T) ⇒ Boolean): Array[T]
去除当前数组中符合条件的元素，这个需要一个条件，
就是从当前数组的第一个元素起，就要满足条件，
直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），
否则返回整个数组
val a=Array(1,2,3,4)
a.dropWhile(x => x < 3 )
res16: Array[Int] = Array(3, 4)

val a=Array(3,1,3,4)
a.dropWhile(x => x >2 )
res19: Array[Int] = Array(1, 3, 4)
val a=Array(3,1,3,4)
a.dropWhile(_ >2 )
res19: Array[Int] = Array(1, 3, 4)

endsWith

endsWith[B](that: GenSeq[B]): Boolean
判断是否以某个序列结尾
val a =Array(1,2,3,5,2)
val b =Array(5,2)
a.endsWith(b)
res35: Boolean = true

exists

exists(p: (T) ⇒ Boolean): Boolean
是否有一个满足条件
val a=Array(1,2,3)
a.exists(x=>x > 3)
res23: Boolean = false
a.exists(x=>x > 2)
res24: Boolean = true

filter

filter(p: (T) ⇒ Boolean): Array[T]
过滤函数
取得当前数组中符合条件的元素，组成新的数组返回
val a=Array(1,2,3,4,5,6,2,5,1)
a.filter(_!=5)
res21: Array[Int] = Array(1, 2, 3, 4, 6, 2, 1)

filterNot

filterNot(p: (T) ⇒ Boolean): Array[T]
与filter 作用相反

find

find(p: (T) ⇒ Boolean): Option[T]
查找第一个符合条件的元素没有就返回None
val a = Array(1, 2, 3,4)
a.find(x=>x>2)
res25: Option[Int] = Some(3)

flatMap

flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Array[B]
重要函数
对当前序列的每个元素进行操作，结果放入新序列返回，参数要求是GenTraversableOnce及其子类

1 to 3
res30: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3)

val a = Array(1,2,3,4)
a.map(x=>1 to x)
res31: Array[scala.collection.immutable.Range.Inclusive] = Array(Range(1), Range(1, 2), Range(1, 2, 3), Range(1, 2, 3, 4))
a.map(x=>1 to x).flatten
res32: Array[Int] = Array(1, 1, 2, 1, 2, 3, 1, 2, 3, 4)
a.flatMap(x=>1 to x)
res33: Array[Int] = Array(1, 1, 2, 1, 2, 3, 1, 2, 3, 4)

flatten

降维
将二维数组的所有元素联合在一起，形成一个一维数组返回
不能一个一维，一个二维
val a=Array(Array(1,2,3),Array(4,5,6))
a.flatten
res27: Array[Int] = Array(1, 2, 3, 4, 5, 6)

val a=Array(Array(Array(1,2,3)),Array(Array(4,5,6)))
a.flatten.flatten
res29: Array[Int] = Array(1, 2, 3, 4, 5, 6)

fold

fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1
对序列中的每个元素进行二元运算，和aggregate有类似的语义
def seqno(m:Int,n:Int): Int ={
val s = “seq_exp=%d+%d”
println(s.format(m,n))
return m+n
}
def combine(m:Int,n:Int): Int ={
val s = “com_exp=%d+%d”
println(s.format(m,n))
return m+n
}
val a = Array(1, 2, 3,4)
val b = a.fold(5)(seqno)
/** 运算过程
seq_exp=5+1
seq_exp=6+2
seq_exp=8+3
seq_exp=11+4
/
val c = a.par.aggregate(5)(seqno,combine)
/* 运算过程
seq_exp=5+1
seq_exp=5+4
seq_exp=5+3
com_exp=8+9
seq_exp=5+2
com_exp=6+7
com_exp=13+17
*/

foldLeft

foldLeft[B](z: B)(op: (B, T) ⇒ B): B
和/:相同左二叉树
def seqno(m:Int,n:Int): Int ={
val s = “seq_exp=%d+%d”
println(s.format(m,n))
return m+n
}
val a = Array(1, 2, 3,4)
val b = a.foldLeft(5)(seqno)
/** 运算过程
seq_exp=5+1
seq_exp=6+2
seq_exp=8+3
seq_exp=11+4
*/
简写 (5 /: a)(+)

foldRight

foldRight[B](z: B)(op: (B, T) ⇒ B): B
和:\相同右二叉树
def seqno(m:Int,n:Int): Int ={
val s = “seq_exp=%d+%d”
println(s.format(m,n))
return m+n
}
val a = Array(1, 2, 3,4)
val b = a.foldRight(5)(seqno)
/** 运算过程
seq_exp=4+5
seq_exp=3+9
seq_exp=2+12
seq_exp=1+14
*/
简写 (a :\ 5)(+)

forall

forall(p: (T) ⇒ Boolean): Boolean
检测序列中的元素是否都满足条件 p，如果序列为空，返回true
exixts是有没有一个元素满足条件，有就是true
val a=Array(1,2,3,4,5,6)
a.forall(_<7)
res37: Boolean = true

foreach

foreach(f: (A) ⇒ Unit): Unit
val a = Array(1,2,3,4,5,6)
a.foreach(x => println(x))
1
2
3
4
5
6

groupBy

groupBy[K](f: (T) ⇒ K): Map[K, Array[T]]
重要方法
按条件分组，条件由 f 匹配，返回值是Map类型，每个key对应一个序列
val a = Array(1, 2, 3,4)
val b = a.groupBy( x => x match {
case x if (x < 3) => “small”
case _ => “big”
})
b: scala.collection.immutable.Map[String,Array[Int]] = Map(small -> Array(1, 2), big -> Array(3, 4))
下面两个都能取值
b.apply(“ji”)
b.get(“ji”).get

val a = Array(1, 2, 3,4)
a.groupBy( _ match{
case x if (x%2==0) =>“ou”
case _ => “ji”
})
res0: scala.collection.immutable.Map[String,Array[Int]] = Map(ou -> Array(2, 4), ji -> Array(1, 3))

grouped

grouped(size: Int): collection.Iterator[Array[T]]
按指定数量分组，每组有 size 数量个元素，返回一个集合
val a = Array(1, 2, 3,4)
a.grouped(3).foreach(x=>println(x.mkString(",")))
1,2,3
4

hasDefiniteSize

hasDefiniteSize: Boolean
检测序列是否存在有限的长度，无限长就false
val a = Array(1, 2, 3,4)
a.hasDefiniteSize
res4: Boolean = true

head

head: T
返回序列的第一个元素，如果序列为空，将引发错误
val a = Array(1, 2, 3,4)
a.head
1

last是返回最后一个元素

headOption

headOption: Option[T]
数组为空时不会报错
val a =ArrayInt
a.headOption
res103: Option[Int] = Some(0)

indexOf

indexOf(elem: T): Int
返回元素在数组中从左到右第一次出现的下标，没有就返回-1
val a = Array(1, 3, 2,4)
a.indexOf(2)
res108: Int = 2
val a = Array(1,3,2,4,2,3)
a.indexOf(3)
res111: Int = 1

indexOfSlice

indexOfSlice[B >: A](that: GenSeq[B], from: Int): Int
检测当前序列中是否包含另一个序列（that），并返回第一个匹配出现的元素的索引，
指定从 from 索引处开始
val a = Array(1,3,2,4,2,4,3)
a.indexOfSlice(Array(2,4))
res114: Int = 2

a.indexOfSlice(Array(2,4),3)
res114: Int = 4

indexWhere

indexWhere(p: (T) ⇒ Boolean): Int
返回当前序列中第一个满足 p 条件的元素的索引
val a = Array(1, 2, 3, 4)
a.indexWhere( {x:Int => x>3})
3

indices

indices: collection.immutable.Range
返回当前序列索引集合把下标变成集合
val a = Array(10, 2, 3, 40, 5)
a.indices
res118: scala.collection.immutable.Range = Range(0, 1, 2, 3, 4)

init

init: Array[T]
返回当前序列中不包含最后一个元素的序列
val a = Array(10, 2, 3, 40, 5)
a.init
res6: Array[Int] = Array(10, 2, 3, 40)

inits

inits: collection.Iterator[Array[T]]
对集合中的元素进行 init 操作，该操作的返回值中，第一个值是当前序列的副本，
包含当前序列所有的元素，最后一个值是空的，对头尾之间的值进行init操作，
上一步的结果作为下一步的操作对象
val a = Array(1, 2, 3, 4, 5)
scala> a.inits.foreach(x=> println(x.mkString))
12345
1234
123
12
1

intersect

intersect(that: collection.Seq[T]): Array[T]
取两个集合的交集
val a = Array(1, 2, 3, 4, 5)
val b = Array(3, 4, 6)
a.intersect(b)
res7: Array[Int] = Array(3, 4)

isDefinedAt

isDefinedAt(idx: Int): Boolean
判断序列中是否存在指定索引
val a = Array(1, 2, 3, 4, 5)
a.isDefinedAt(2) true
a.isDefinedAt(9) false

isEmpty

isEmpty: Boolean
判断当前序列是否为空
val a = Array(1, 2, 3, 4, 5)
a.isEmpty
res135: Boolean = false

val a=ArrayInt
a.isEmpty
res136: Boolean = true

isTraversableAgain

isTraversableAgain: Boolean
判断序列是否可以反复遍历,也就是判断是不是Iterators
val a = Array(1, 2, 3, 4, 5)
a.inits
res8: Iterator[Array[Int]] = non-empty iterator
res8.isTraversableAgain
false

a.isTraversableAgain
true

iterator

collection.Iterator[T]
对序列中的每个元素产生一个 iterator
val a = Array(1, 2, 3,4)
val b = a.groupBy( x => x match {
case x if (x < 3) => “small”
case _ => “big”
})
b: scala.collection.immutable.Map[String,Array[Int]] = Map(small -> Array(1, 2), big -> Array(3, 4))
b.iterator.foreach(x=> println(x._1,x._2.mkString(",")))
(small,1,2)
(big,3,4)

last

last: T
取得序列中最后一个元素
val a = Array(1,2,3,4,5)
a.last
res12: Int = 5

lastIndexOf

lastIndexOf(elem: T): Int
取得序列中最后一个等于 elem 的元素的位置
val a = Array(1,4,3,4,2,3,4,5)
a.lastIndexOf(4)
res13: Int = 6

lastIndexOf(elem: T, end: Int): Int
取得序列中最后一个等于 elem 的元素的位置，可以指定在 end 之前（包括）的元素中查找
val a = Array(1,4,3,4,2,3,4,5)
a.lastIndexOf(4,5)
res138: Int = 3

lastIndexOfSlice

lastIndexOfSlice[B >: A](that: GenSeq[B]): Int
判断当前序列中是否包含数组，并返回最后一次出现该数组的位置处的索引
val a = Array(1, 4, 2, 3, 4, 5, 1, 4)
val b = Array(1, 4)
a.lastIndexOfSlice(b)
res140: Int = 6

lastIndexOfSlice[B >: A](that: GenSeq[B], end: Int): Int
判断当前序列中是否包含数组，并返回最后一次出现该数组的位置处的索引
可以指定在 end 之前（包括）的元素中查找
val a = Array(1, 4, 2, 3, 4, 5, 1, 4)
val b = Array(1, 4)
a.lastIndexOfSlice(b,5)
res141: Int = 0

lastIndexWhere

lastIndexWhere(p: (T) ⇒ Boolean): Int
返回当前序列中最后一个满足条件 p 的元素的索引
val a = Array(1, 4, 2, 3, 4, 5, 1, 4)
a.lastIndexWhere( _ < 2 )
res146: Int = 6

lastIndexWhere(p: (T) ⇒ Boolean, end: Int): Int
返回当前序列中最后一个满足条件 p 的元素的索引，
可以指定在 end 之前（包括）的元素中查找
val a = Array(1, 4, 2, 3, 4, 5, 1, 4)
val b = Array(1, 4)
a.lastIndexWhere({x:Int => x<2},2)
a.lastIndexWhere(x=> x<2,2)
a.lastIndexWhere(_ <2,2)
res147: Int = 0

lastOption 可以让A是空值

lastOption: Option[Int]
返回当前序列中最后一个对象
val a = Array(1, 2, 3, 4, 5)
println(a.lastOption)
Some(5)

val a = ArrayInt
a.lastOption
res143: Option[Int] = None

length

def length: Int
val a = Array(1, 3, 5, 4, 5)
a.length
res32: Int = 5

lengthCompare(len: Int): Int

val a = Array(1, 3, 5, 4, 5)
a.lengthCompare(5) 5-5=0
a.lengthCompare(3) 5-3=2
a.lengthCompare(8) 5-8=-3

lift

lift:Option[Int] =
变成Option数组
val a = Array(1, 3, 5, 4, 5)
a.lift
res43: Int => Option[Int] =

map

循环，将每个值处理一遍，把结果返回一个新的数组
val y=Array(1,2,3)
y.map(x=>x+2)
res33: Array[Int] = Array(3, 4, 5)
y.foreach(x=>x+2)循环，将每个值处理一遍，没有返回值

max

max: A
val a = Array(1, 4, 3, 4, 5)
a.max
5

maxBy

maxBy(f: Int => B): Int
返回序列中符合条件的第一个元素
val a = Array(2, 1, 3, 4, 5,4,2)
a.maxBy(_>4)
res25: Int = 5

min

min: A
val a = Array(1, 4, 3, 4, 5)
a.min
1

minBy

minBy[B](f: (A) ⇒ B): A
minBy(f: Int => B): Int
返回序列中不符合条件的第一个的元素
val a = Array(2, 1, 3, 4, 5,4,2)
a.minBy( _ >3)
res26: Int = 2

mkString

将所有元素组合成一个字符串
val a = Array(1, 2, 3, 4, 5)
a.mkString
res27: String = 12345
a.mkString("")
res28: String = 12345
a.mkString("[","-","]")
res30: String = [1-2-3-4-5]

nonEmpty

nonEmpty: Boolean
判断序列不是空
val a = Array(1, 2, 3, 4, 5)
a.nonEmpty
res31: Boolean = true

padTo

padTo(len: Int, elem: A): Array[A]
后补齐序列
val a = Array(1, 2, 3, 4, 5)
val b = a.padTo(7,9) 需要一个长度为 7 的新序列，空出的填充 9
println(b.mkString(",")) return 1,2,3,4,5,9,9

前补齐
+：或 ++

par

返回一个并行实现，产生的并行序列，不能被修改
val a=Array(1,2,3,4,5,6)
a.par
res36: scala.collection.parallel.mutable.ParArray[Int] = ParArray(1, 2, 3, 4, 5, 6)

partition

partition(p: (T) ⇒ Boolean): (Array[T], Array[T])
分区成两个
val a = Array(3, 2, 6, 1, 5)
a.partition(_>2) 结果是元组
res167: (Array[Int], Array[Int]) = (Array(3, 6, 5),Array(2, 1))

groupBy 按条件可以分成多组结果是Map
val a = Array(3, 2, 6, 1, 5,4,2)
a.groupBy(x => x match {
case x if (x < 4) => “small”
case x if (x==5) => “wu”
case _ => “other”
}
)
scala.collection.immutable.Map[String,Array[Int]] =
Map(wu -> Array(5), small -> Array(3, 2, 1, 2), other -> Array(6, 4))

patch

patch(from: Int, that: GenSeq[A], replaced: Int): Array[A]
批量替换,从原序列的 from 处开始，后面的 replaced 数量个元素,
将被替换成序列 that
val a = Array(1, 2, 3, 4, 5)
val b = Array(3, 4, 6)
val c = a.patch(1,b,2)
c: Array[Int] = Array(1, 3, 4, 6, 4, 5)
val a = Array(1, 2, 3, 4, 5)
a.patch(0,Array(222,111),2)
res36: Array[Int] = Array(222,111, 3, 4, 5)

permutations

permutations: collection.Iterator[Array[T]]
排列组合,组合中的内容可以相同，但是顺序不能相同
combinations不允许包含的内容相同，即使顺序不一样
val a = Array(1, 2, 3)
a.permutations
Iterator[Array[Int]] = non-empty iterator
a.permutations.foreach(x=> println(x.mkString(",")))
1,2,3
1,3,2
2,1,3
2,3,1
3,1,2
3,2,1

prefixLength

prefixLength(p: (T) ⇒ Boolean): Int
给定一个条件 p，返回一个满足条件的元素的长度
从左到右排直到第一个不满足条件的元素
val a = Array(1,1,3,4,1,2,3,4)
val b = a.prefixLength(_ < 3)
b: Int = 2

product

product: A
返回所有元素乘积的值
val a = Array(1,2,3)
a.product
6

val a = Array(“a”,2,3)
a: Array[Any] = Array(a, 2, 3)
a.product
error

val a = Array(‘a’,2,3)
a: Array[Int] = Array(97, 2, 3)

reduce

不需要初始值
reduce[A1 >: Int](op: (A1, A1) => A1): A1
val a = Array(1, 2, 3, 4, 5)
a.reduce(+)
res46: Int = 15
/**
seq_exp=1+2
seq_exp=3+3
seq_exp=6+4
seq_exp=10+5
*/

fold需要初始值
a.fold(1)(+)
res47: Int = 16

reduceLeft

val a = Array(1, 2, 3, 4, 5)
a.reduceLeft(+)
15

reduceRight

val a = Array(1, 2, 3, 4, 5)
a.reduceLeft(+)
15

reduceOption

option防止数组空时报错
val a=ArrayInt
a.reduceOption(+)
res49: Option[Int] = None

reduceLeftOption

option防止数组空时报错
val a=ArrayInt
a.reduceLeftOption(+)
res49: Option[Int] = None

reduceRightOption

option防止数组空时报错
val a=ArrayInt
a.reduceRightOption(+)
res49: Option[Int] = None

wordcount案例：

想到循环考虑foreach map flatMap
目前 Scala 支持的元组最大长度为 22 用 t._1 访问第一个元素， t._2 访问第二个元素
val words=Array(“hello world”,“hello scala”,“spark scala”)
words.flatMap(x=>x.split(" "))
res69: Array[String] = Array(hello, world, hello, scala, spark, scala)

words.flatMap(x=>x.split(" ")).groupBy(x=>x)
res70: scala.collection.immutable.Map[String,Array[String]] = Map(spark -> Array(spark), scala -> Array(scala, scala), world -> Array(world), hello -> Array(hello, hello))

words.flatMap(x=>x.split(" ")).groupBy(x=>x).foreach(f=> println(f._1,f._2.size))
(spark,1)
(scala,2)
(world,1)
(hello,2)

reverse

反转序列
val a = Array(1,2,3,4,5)
val b = a.reverse
b: Array[Int] = Array(5, 4, 3, 2, 1)

reverseIterator

reverseIterator: collection.Iterator[T]
反向生成迭代
val a = Array(1,2,3,4,5)
a.reverseIterator.foreach(x=> println(x*2))
10
8
6
4
2
a.reverseIterator.foreach(println)
5
4
3
2
1

reverseMap

reverseMap[B](f: (A) => B): Array[B]
同 map 方向相反
val a = Array(1,2,3,4,5)
a.reverseMap(x => x*2)
res79: Array[Int] = Array(10, 8, 6, 4, 2)

sameElements

sameElements(that: GenIterable[A]): Boolean
判断两个序列是否顺序和对应位置上的元素都一样
val a = Array(1,2,3,4,5)
val b = Array(1,2,3,4,5)
println(a.sameElements(b)) true

scan

（可以忽略）
scan会把每一步的计算结果放到一个集合中返回，
而 fold 返回的是单一的值
val a = Array(1,2,3,4,5)
a.scan(5)(+)
res187: Array[Int] = Array(5, 6, 8, 11, 15, 20)

scanLeft

val a = Array(1,2,3,4,5)
a.scanLeft(5)(+)
res189: Array[Int] = Array(5, 6, 8, 11, 15, 20)

scanRight

val a = Array(1,2,3,4,5)
a.scanRight(5)(+)
res190: Array[Int] = Array(20, 19, 17, 14, 10, 5)

segmentLength

segmentLength(p: (T) ⇒ Boolean, from: Int): Int
从序列的 from 处开始向后查找，直到遇到不满足条件的数值，返回满足 p 的连续元素的长度
val a = Array(1,2,3,1,1,1,3,1,4,5,2)
val b = a.segmentLength( x => x < 3,4)
b: Int = 2

seq

seq: collection.mutable.IndexedSeq[T]
产生一个引用当前序列的 sequential 视图
val a = Array(1,2,3,4,5)
a.seq
res81: scala.collection.mutable.IndexedSeq[Int] = WrappedArray(1, 2, 3, 4, 5)

size

size: Int
序列元素个数，同 length
val a = Array(1,2,3,4,5)
a.size
res83: Int = 5

val a=Array(1,2,3,null,null)
a.size
res83: Int = 5
a.length
res84: Int = 5

slice

重要函数
(from: Int, until: Int): Array[T]
切片
左闭右开
取出当前序列中，from 到 until 之间的片段
val a = Array(3,2,1,4,5,6)
a.slice(2,4)
res85: Array[Int] = Array(1, 4)

sliding

sliding(size: Int): collection.Iterator[Array[T]]

val a = Array(1,2,3,4,5)
a.sliding(3)
res86: Iterator[Array[Int]] = non-empty iterator
a.sliding(3).toList
res87: List[Array[Int]] = List(Array(1, 2, 3), Array(2, 3, 4), Array(3, 4, 5))

a.sliding(3,2).toList
res88: List[Array[Int]] = List(Array(1, 2, 3), Array(3, 4, 5))

sortBy

sortBy[B](f: (T) ⇒ B)(implicit ord: math.Ordering[B]): Array[T]
val a = Array(3,2,1,4,5,6,2,3)
a.sortBy(x => x)
res91: Array[Int] = Array(1, 2, 2, 3, 3, 4, 5, 6)
a.sortBy(x => -x)
res92: Array[Int] = Array(6, 5, 4, 3, 3, 2, 2, 1)

sortWith

sortWith(lt: (T, T) ⇒ Boolean): Array[T]
自定义排序
val a = Array(3,2,1,4,5,6,2,3)
a.sortWith(.compareTo() > 0)
res93: Array[Int] = Array(6, 5, 4, 3, 3, 2, 2, 1)

val a=Array((“zs”,50),(“ls”,80),(“ww”,70)) 里面是元组用x._2
a: Array[java.io.Serializable] = Array((zs,50), ls,80, (ww,70))
a.sortBy( x => x._2) 正序
res96: Array[(String, Int)] = Array((zs,50), (ww,70), (ls,80))
a.sortBy( x => -x._2) 倒序
res97: Array[(String, Int)] = Array((ls,80), (ww,70), (zs,50))

sorted

def sorted[B >: A](implicit ord: math.Ordering[B]): Array[T]]
使用默认的排序规则对序列排序
val a = Array(3, 2, 1, 4)
val b = a.sorted // 默认升序排列
println(b.mkString(",")) // 1,2,3,4

span

span(p: (T) ⇒ Boolean): (Array[T], Array[T])
分割序列为两个集合，从第一个元素开始，直到找到第一个不满足条件的元素止，
之前的元素放到第一个集合，其它的放到第二个集合
val a = Array(3,2,1,4,5)
val b = a.span( {x:Int => x > 2})
println(b._1.mkString(",")) 3
println(b._2.mkString(",")) 2,1,4,5

splitAt

从指定位置开始，把序列拆分成两个集合
左闭右开
val a = Array(3,2,1,4,5)
val b = a.splitAt(2)
索引2的元素在下一个集合
println(b._1.mkString(",")) 3,2
println(b._2.mkString(",")) 1,4,5

startsWith

startsWith[B](that: GenSeq[B], offset: Int): Boolean
从指定偏移处，是否以某个序列开始
val a = Array(2,3,1,2,3,4,5)
val b = Array(1,2)
a.startsWith(b,2)
res227: Boolean = true

startsWith[B](that: GenSeq[B]): Boolean
是否以某个序列开始
val a = Array(1,2,3,4,5)
val b = Array(1,2)
println(a.startsWith(b))
true

stringPrefix

可忽略
stringPrefix: String
返回 toString 结果的前缀
val a = Array(0,1,2,3,4,5)
println(a.toString()) [I@3daa57fb
val b = a.stringPrefix
println(b) [I

subSequence

subSequence(start: Int, end: Int): CharSequence
返回 start 和 end 间的字符序列
左闭右开
val chars = Array(‘a’,‘b’,‘c’,‘d’,‘f’,‘e’)
val b = chars.subSequence(2,4)
b: CharSequence = cd

sum

sum:A
val a = Array(1, 4, 3, 4, 5)
a.sum
res156: Int = 17

tail

除了head以外的所有值
val a = Array(1, 2, 3,4)
a.tail
2,3,4

tails

除了head以外的所有值
val a = Array(1,2,3,4)
a.tails.foreach(x=> println(“结果”+x.mkString))
结果1234
结果234
结果34
结果4
结果

take

take(n: Int): Array[T]
拿前几个
val a = Array(0,1,2,3,4,5)
a.take(2)
res99: Array[Int] = Array(0, 1)

takeRight

takeRight(n: Int): Array[T]
拿后几个
val a = Array(0,1,2,3,4,5)
a.takeRight(2)
res100: Array[Int] = Array(4, 5)

案例
取中间值
val a = Array(0,1,2,3,4,5)
a.take(4).takeRight(2)
res101: Array[Int] = Array(2, 3)
掐头去尾
a.take(a.size-1).takeRight(a.size-2)

takeWhile

takeWhile(p: (T) ⇒ Boolean): Array[T]
返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列
如果第一个元素的就不满足，直接返回空数组
val a = Array(2,2,1,1,5)
val b = a.takeWhile(_<2)
b: Array[Int] = Array()

val a = Array(1,2,3,4,5)
val b = a.takeWhile(_< 3)
b: Array[Int] = Array(1, 2)

to

1 to 3
res145: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3)
1 to 10 by 3
res146: scala.collection.immutable.Range = Range(1, 4, 7, 10)

toArray

toArray: Array[A]
转换成 Array 类型长度固定

toBuffer

toBuffer[A1 >: A]: Buffer[A1]
转换成 Buffer 类型可变长集合
val a = Array(1,2,3,4,5)
a.toBuffer
res1: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3, 4, 5)

toIndexedSeq

toIndexedSeq: collection.immutable.IndexedSeq[T]
转换成 IndexedSeq 类型

toIterable

toIterable: collection.Iterable[T]
转换成可迭代的类型
val a = Array(1,2,3,4,5)
a.toIterable
res166: Iterable[Int] = WrappedArray(1, 2, 3, 4, 5)

toIterator

toIterator: collection.Iterator[T]
同 iterator 方法
val a = Array(1,2,3,4,5)
a.toIterator
res167: Iterator[Int] = non-empty iterator 只能遍历一次

toList

toList: List[T]
同 List 类型
固定长集合
val a = Array(1,2,3,4,5)
a.toList
res0: List[Int] = List(1, 2, 3, 4, 5)

toMap

toMap[T, U]: Map[T, U]
同 Map 类型，需要被转化序列中包含的元素时 Tuple2 类型数据
(“a”,“b”)为元组，前面为键，后面为值
val chars = Array((“a”,“b”),(“c”,“d”),(“e”,“f”))
chars: Array[(String, String)] = Array((a,b), (c,d), (e,f))

println(chars.toMap)
Map(a -> b, c -> d, e -> f)

练习：
val a = Array(1,2,3,4,5)
a.map((_,1))
res3: Array[(Int, Int)] = Array((1,1), (2,1), (3,1), (4,1), (5,1))

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

toSeq

toSeq: collection.Seq[T]
同 Seq 类型

toSet

toSet[B >: A]: Set[B]
同 Set 类型

toStream

toStream: collection.immutable.Stream[T]
同 Stream 类型
val a = Array(1,2,3,4,5)
a.toStream
res6: scala.collection.immutable.Stream[Int] = Stream(1, ?)

toTraversable

toTraversable: Traversable[Int]
val a = Array(1,2,3,4,5)
a.toTraversable().foreach(println)
1
2
3
4
5

toVector
toVector: Vector[T]
同 Vector 类型

transpose

transpose[U](implicit asArray: (T) ⇒ Array[U]): Array[Array[U]]
矩阵转换，二维数组行列转换
val k = Array(Array(1,2),Array(3,4),Array(5,6))
k: Array[Array[Int]] = Array(Array(1, 2), Array(3, 4), Array(5, 6))

k.transpose
res7: Array[Array[Int]] = Array(Array(1, 3, 5), Array(2, 4, 6))

union

union(that: collection.Seq[T]): Array[T]
联合两个序列，同操作符 ++
不去重
val a = Array(1,2,3,4,5)
val b = Array(5,6,7)

val c = a.union(b)
c: Array[Int] = Array(1, 2, 3, 4, 5, 5, 6, 7)

如何去重：
c.toSet
res12: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 4)

unzip

unzip[T1, T2](implicit asPair: (T) ⇒ (T1, T2), ct1: ClassTag[T1], ct2: ClassTag[T2]): (Array[T1], Array[T2])
将含有两个元素的数组，第一个元素取出组成一个序列，
第二个元素组成一个序列
数组里面的元组数量可以有多个，每个元组里面元素必须是2个
val k =Array((1,2),(3,4))
k.unzip
res14: (Array[Int], Array[Int]) = (Array(1, 3),Array(2, 4))

val k =Array((1,2),(3,4),(5,6))
k.unzip
res15: (Array[Int], Array[Int]) = (Array(1, 3, 5),Array(2, 4, 6))

val k =Array((1,2,3),(4,5,6))
k.unzip 错误只能有两个元素数组，不能三个
error: No implicit view available from (Int, Int, Int) => (T1, T2).k.unzip

unzip3

unzip3[T1, T2, T3](implicit asTriple: (T) ⇒ (T1, T2, T3), ct1: ClassTag[T1], ct2: ClassTag[T2], ct3: ClassTag[T3]): (Array[T1], Array[T2], Array[T3])
将含有三个元素的三个数组，第一个元素取出组成一个序列，
第二个元素组成一个序列，第三个元素组成一个序列
val k =Array((1,2,3),(4,5,6),(7,8,9))
k.unzip3

res18: (Array[Int], Array[Int], Array[Int]) = (Array(1, 4, 7),Array(2, 5, 8),Array(3, 6, 9))

update

update(i: Int, x: T): Unit
将序列中 i 索引处的元素更新为 x
语法糖 … 方便调用
val a = Array(1,2,3,4,5)
a.update(1,100)
a
res148: Array[Int] = Array(1, 100, 3, 4, 5)

updated

updated(index: Int, elem: A): Array[A]
将序列中 i 索引处的元素更新为 x ,并返回替换后的数组
val a = Array(1,2,3,4,5)
val b = a.updated(1,9)
b: Array[Int] = Array(1, 9, 3, 4, 5)

view

view(from: Int, until: Int): IndexedSeqView[T, Array[T]]
返回 from 到 until 间的序列，不包括 until 处的元素左闭右开
val a = Array(1,2,3,4,5)
a.view(0,4)
res22: scala.collection.mutable.IndexedSeqView[Int,Array[Int]] = SeqViewS(…)

a.view(0,4).toArray
res24: Array[Int] = Array(1, 2, 3, 4)

a.view(0,4).foreach(x=>println(x))
1
2
3
4

withFilter

withFilter(p: (T) ⇒ Boolean): FilterMonadic[T, Array[T]]
根据条件 p 过滤元素用的少
val a = Array(1,2,3,4,5)
a.withFilter(_>3)
res26: scala.collection.generic.FilterMonadic[Int,Array[Int]] = scala.collection.TraversableLike$WithFilter@2bb42c81

a.withFilter(_>3).map(x=>x)
res28: Array[Int] = Array(4, 5)

zip

zip[B](that: GenIterable[B]): Array[(A, B)]
将两个序列对应位置上的元素组成一个pair序列
val a = Array(1,2,3,4,5)
val b = Array(5,4,3,2,1)
val c = a.zip(b)
c: Array[(Int, Int)] = Array((1,5), (2,4), (3,3), (4,2), (5,1))

zipAll

zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): Array[(A, B)]
同 zip ，但是允许两个序列长度不一样，不足的自动填充，
如果当前序列端，空出的填充为 thisElem，如果 that 短，填充为 thatElem
val a = Array(1,2,3,4,5,6,7)
val b = Array(5,4,3,2,1)
val c = a.zipAll(b,9,8) a比b长，填充8
c: Array[(Int, Int)] = Array((1,5), (2,4), (3,3), (4,2), (5,1), (6,8), (7,8))

val a = Array(1,2,3,4)
val b = Array(5,4,3,2,1)
val c = a.zipAll(b,9,8) a比b短，填充9
c: Array[(Int, Int)] = Array((1,5), (2,4), (3,3), (4,2), (9,1))

zipWithIndex: Array[(A, Int)]

序列中的每个元素和它的索引组成一个序列
val a = Array(10,20,30,40,50)
val b = a.zipWithIndex
b: Array[(Int, Int)] = Array((10,0), (20,1), (30,2), (40,3), (50,4))

数据孤岛

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Scala Array函数大全详解

++ count hasDefiniteSize maxBy sameElements toBuffer++: deep head min scan toIndexedSeq+: diff headOption
复制链接

扫一扫

专栏目录