scala——Array函数大全

初始化固定长度的数组

// 初始化长度为10的数组
val array = new Array[Int](10)
// 初始化创建含有hi与hello的数组
val s = Array("hi","hello")

创建可变的数组（提供ArrayBuilder()方法）

val a = new StringBuilder()

 Scala操作：

def ++ ：a++b

合并集合并返回一个新的数组，新数组包含左右两个集合内容

val a=Array(1,2,3)
val b=Array(2,3,4)
a++b   
 // Array[Int] = Array(1, 2, 3, 2, 3, 4)

def ++: ：a++:b

合并集合返回新数组，数组的类型为靠近:集合的类型

val a=Array(1,2,3)
val b=List(2,3)
a++:b
// List[Int] = List(1, 2, 3, 2, 3)

def +: | :+ ：a+:b or a:+b

在数组内加入一个常量元素，靠近:的为常量

val a=Array(1,2,3)
3+:a
// Array[Int] = Array(3, 1, 2, 3)

def /: | : ：n:Int /:  Array[T]　　返回Array[T]

对数组所有元素进行相同操作，foldLeft(左二叉树) | foldRight(右二叉树)简写

val a=Array(1,2,3)
(10 /: a)(_+_)
// 16

def addString：addString(a:StringBuilder())　　返回StringBuilder

将数组中的元素逐个加入到可变数组中

val a=new StringBuilder()
val b=Array(1,2,3)
b.addString(a)
// StringBuilder = 123

def addString：addString(a:StringBuilder(),sep:String)　　返回StringBuilder

同上，每个元素用sep分开

val a=new StringBuilder()
val b=Array(1,2,3)
b.addString(a,",")
// StringBuilder = 1,2,3

def addString：addString(a:StringBuilder(),start:String,sep:String,end:String)　　返回StringBuilder

同上，在首位多了两个字符串

val a=new StringBuilder()
val b=Array(1,2,3)
b.addString(a,"1",",","2")
// StringBuilder = 11,2,32

def aggregate：aggregate[z:=>B](mapper:(B,T)=>B,reduce:(B,B)=>B):B

聚合计算，aggregate为柯里化方法，两个参数，其作用相当于mapreduce

def mapper(m:Int,n:Int):Int={m+n}
def reduce(m:Int,n:Int):Int={m+n}
val a=List(1,2,3,4,5)
a.par.aggregate(5)(mapper,reduce)
// Int = 40

def apply(i:Int):T

取出指定索引的元素

val a=Array(1,2,3)
a.apply(2)
//Int=3

def canEqual　　返回boolean

判断两个对象是否可以进行比较

def charAt(index:Int)：Char

获取index索引处的字符

val a=Array('a','b','c')
a.charAt(1)
// Char = b

def clone()：Array[T]

浅拷贝，只拷贝索引，不创建新对象

val a=Array(1,2,3)
val b=a.clone()
// Array[Char] = Array(a, b, c)

def collect()：Array[T]

通过执行一个并行计算（偏函数），得到一个新的数组对象

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)
// Array[Int] = Array(2, 4, 4, 6)

def collectFirst：

对第一个执行偏函数计算

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.collectFirst(func)
// Option[Int] = Some(2)

def combinations(i:Int)　　返回一个迭代器

排列组合，列出所有的包含不同字符的组合

val a=Array(1,2,3)
a.combinations(2).foreach(x=>println(x.mkString(",")))
//1,2
  1,3
  2,3

def contains(ele:A)：boolean

判断集合中是否包含指定对象

val a=Array(1,2,3)
a.contains(3)
//Boolean = true

def containsSlice(that:Array[T])：boolean

判断当前序列中是否包含另一个序列，且序列次序一致

val a=List(1,2,3,4)
val b=List(2,3)
val c=List(2,1,3)
a.containsSlice(b) //true
a.containsSlice(c) //false

def copyToArray(Array[T],index,len)

拷贝 (Array[T],index,len)  三种方式 1#带入一个参数，代表考入的空数组 2#带入两个参数，index代表开始的下标 3#带入三个参数，len 代表拷贝的长度

val a:Array[Int]=new Array(5)
val b=Array(1,2,3)
b.copyToArray(a)    // Array[Int] = Array(1, 2, 3, 0, 0)
b.copyToArray(a,2)    // Array[Int] = Array(0,0,1, 2, 3)
b.copyToArray(a,2,2)    // Array[Int] = Array(0,0,1, 2, 0)

def copyToBuffer(dest:Buffer)：unit

将数组中内容拷贝到Buffer内（使用改方法需要先导包：import scala.collection.mutable.ArrayBuffer）

val a=Array(1,2,3)
val b=new ArrayBuffer[Int]()
a.copyToBuffer(b)
//scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)

def corresponds(that:GenSeq)(p=>boolean)：boolean

判断两个序列长度是否相同，对应位置的元素是否满足判定条件

val a=Array(1,2,3)
val b=Array(2,3,4)
a.corresponds(b)(_<_)
//true

def count(p:=>boolean)：Int

统计符合条件的元素的个数

val e=Array("hello","world","hadoop")
e.count(x=>x.contains("o"))
//3

def diff(Array[T])：Array[T]

返回当前数组与某一数组不同的元素,形成一个新数组

val a=Array(1,2,3,4)
val b=Array(3,4,5)
a.diff(b)
//Array[Int] = Array(1, 2)

def distinct：Array[T]

去重

val a=Array(1,1,1,1,2,2,4,4,6)
a.distinct
// Array[Int] = Array(1, 2, 4, 6)

def drop(n:Int)：Array[T]

去除当前序列前n个元素并返回一个新的序列

val a=Array(1,1,1,1,2,2,4,4,6)
a.drop(4)
// Array[Int] = Array(2, 2, 4, 4, 6)

def dropRight(n:Int)：Array[T]

从尾部开始去掉n个元素并返回

def dropWhile(p:=>boolean)：Array[T]

从第一个元素开始，删除满足条件的元素，直到遇到不满足条件元素并返回后面所有元素

val a=Array(1,2,3,4,5,6,3,2,1,8)
 a.dropWhile(_<5)
//Array[Int] = Array(5, 6, 3, 2, 1, 8)

def endsWith | startsWith(Array[T])：boolean

判断是否以某个序列结束 | 开始 

val a=Array(1,2,3,4)
a.startsWith(Array(1,2)) //true
a.endsWith(Array(3,4)) //true

def exists(p=>boolean)：boolean

判断数组是否包含符合条件的元素

val a=Array(1,2,3)
a.exists(_>2)
//Boolean = true

def find(p=>boolean)：Option[T]

查找第一个符合的元素  (Some类型) 

val a=Array(1,2,3)
a.find(_>1)
//Option[Int] = Some(2)

def filter | filterNot (p=>boolean)：Array[T]

过滤器，取出元素返回新的数组

val a=Array(1,2,3,4)
a.filter(_>2)  //Array[Int] = Array(3, 4)
a.filterNot(_>2)  // Array[Int] = Array(1, 2)

def flatten ：Array[T]

数组降维，返回一个一维数组

val a=Array(List(1,2),List(3,4))
a.flatten.mkString(",")
//String = 1,2,3,4

def flatMap()：Array[T]

先进行map,再进行降维，对序列内元素进行操作返回一个新序列

val a=Array(1,2,3)
println(a.flatMap(x=>1 to x).mkString(","))
//1,1,2,1,2,3

wordcount:
var words=Array("hello world","hello scala","spark scala")
words.flatMap(x=>x.split(" ")).groupBy(x=>x).foreach(f=>println(f._1,f._2.length))

def fold/foldLeft/foldRight ()

对元素进行二元运算(三个方法结果相同，计算顺序不同)

val a=Array(1,2,3)
a.fold(5)(_+_) 
// 11

def  forall(p:=>boolean)：boolean

元素都满足条件则返回true，只要有不满足的则返回false

val a=Array(1,2,3)
a.forall(_>1)  //false
a.forall(_>0) //true

def foreach()

遍历

val a=Array(1,2,3)
a.foreach(x=>println(x*2))
//2
  4
  6

def groupBy(f:T=>K)：Map[K,Array[T]]

条件分组，返回键值对

val a=List(1,2,3,4)
a.groupBy(x=>x match{case x if (x%2==0) => "ou" case _ => "ji"})
res0.apply("ji")
//  List[Int] = List(1, 3)

def grouped(size:Int)：collection.Iterator

返回迭代器，按照指定的长度对当前集合分组

val a=List(1,2,3,4,5)
a.grouped(2).foreach(x=>println(x))
//List(1, 2, 3)
   List(4, 5)

def hasDefiniteSize：boolean

判断是否为流数据还是普通数据 普通数据为true

def head：T

返回序列第一个元素

def tail：T

返回序列除了第一个之外的所有元素

val a=List(1,2,3,4)
a.tail
//List[Int] = List(2, 3, 4)

def headOption：Option[T]

返回序列第一个元素，没有则返回空，解决head序列为空引发报错的问题

val a:Array[Int]=Array()
a.headOption
// Option[Int] = None

def indexOf(ele:Int)：Int

返回某值在序列中第一次出现的位置int

val a=Array(1,2,3,4)
a.indexOf(3)
// Int = 2

def indexOf(ele:Int,from:Int)：Int

从from位置开始查找某值在序列中第一次出现的位置

val a=Array(1,3,4,3,4,3)
a.indexOf(3,2)
//Int = 3

def indexOfSlice(Array[T])：Int

返回某一序列被包含于当前序列且匹配的第一个元素的索引

val a=Array(1,2,3,1,2,3,1,2,3)
a.indexOfSlice(Array(1,2,3))
// Int = 0

def indexOfSlice(Array[T],from:Int)：Int

返回某一序列从当前序列的from位置开始检索，包含且第一个匹配元素出现的索引

val a=Array(1,2,3,1,2,3,1,2,3)
a.indexOfSlice(Array(1,2,3),1)
//Int = 3

def indexWhere(T=>boolean)：Int

返回第一个满足条件的索引

val a=Array(1,2,3,2,3)
a.indexWhere(_>2)
// Int = 2

def indexWhere(T=>boolean,n:Int)：Int

从n索引开始查找，返回第一个满足条件的索引

val a=Array(1,2,3,4,5,2)
 a.indexWhere(_>1,4)
// Int = 4

def indices：Range

返回当前序列索引集合

val a=Array(1,2,3)
a.indices
//scala.collection.immutable.Range = Range(0, 1, 2)

def intersect

取两个序列中的交集

val a=Array(1,2,3)
val b=Array(2,3,4)
a.intersect(b)
//Array[Int] = Array(2, 3)

def isDefinedAt(index:Int)：boolean

判断序列中是否存在指定索引

def init：Array[T]

返回当前序列中不包含最后一个元素的序列  去尾

val a=Array(1,2,3)
a.init
// Array[Int] = Array(1, 2)

def inits

返回迭代器，foreach遍历

val a=Array(1,2,3)
a.inits
// Iterator[Array[Int]] = non-empty iterator
a.inits.foreach(x=>println(x.mkString(",")))
//1,2,3
   1,2
   1

def isEmpty

是否为空

def isTraversableAgain：boolean

判断是否可以循环遍历 （判断是否为迭代器---迭代器不能反复遍历）

def iterator：collection.Iterator[T]

迭代器，对序列中的每个元素产生一个 iterator

def last

得到序列中最后一个元素

val a=Array(1,2,3)
a.last
// Int = 3

def lastIndexOf(ele:T)：Int

得到值为T的元素最后一次出现在序列中的位置

val a=Array(1,3,3,2,3)
a.lastIndexOf(3)
// Int = 4

def lastIndexOf(ele:T,end:Int)：Int

得到值为T的元素最后一次出现在序列中的位置,查找要求为end之前（包括）的索引

val a=Array(1,2,3,2,4,5,2)
a.lastIndexOf(2,4)
// Int = 3

def lastIndexOfSlice(Array[T])：Int

当前序列包含某序列，且返回该序列最后一次出现时匹配的第一个元素的索引

val a = Array(1,2, 4, 2, 3, 4, 5, 1, 2,4)
val b = Array(1, 2,4)
a.lastIndexOfSlice(b) 
// Int = 7

def lastIndexOfSlice(Array[T],end:Int)：Int

当前序列包含某序列，且返回该序列最后一次出现时匹配的第一个元素的索引，查找位置在end（包含）之前

val a = Array(1,2,3,1,2)
val b = Array(1,2)
a.lastIndexOfSlice(b,2) 
// Int = 0

def lastIndexWhere(p=>boolean)：Int

返回最后一个满足条件的元素索引

val a=Array(1,2,3,1)
a.lastIndexWhere(x=>x<2)
//Int = 3

def lastIndexWhere(p=>boolean,end:Int)：Int

返回最后一个满足条件的元素索引,查找位置在end之前

val a=Array(1,2,3,1)
a.lastIndexWhere(x=>x<2,2)
//Int = 0

def lastOption：T

返回当前序列最后一个对象

val a=Array(1,2,3,1)
a.lastOption
//Option[Int] = Some(1)

def length

序列长度

def lengthCompare(len:Int)：Int

将序列长度和len相比较，返回值为：序列长度-len

val a=Array(1,2,3)
a.lengthCompare(5)
// Int = -2

def map(f:x1=>x2)：Array[T]

对序列中的元素遍历进行f操作

val a=Array(1,2,3)
a.map(x=>x+2)
// Array[Int] = Array(3, 4, 5)

def max | sum

返回序列最大元素 | 元素和

def maxBy | minBy

返回序列中第一个符合条件的元素 | 返回序列中第一个不符合条件的元素

val a=Array(1,2,3)
a.maxBy(_>1)    //Int = 2
a.minBy(_>4)    //Int = 1

def mkString：String

将所有元素组合成一个字符串，等同于addString(a:StringBuffer())

def mkString(sep:String)：String

将所有元素组合成一个字符串，等同于addString(a:StringBuffer(),sep:String)

def mkString(start:String,sep:String,end:String)：String

将所有元素组合成一个字符串，等同于addString(a:StringBuffer(),start:String,sep:String,end:String)

val a=Array(1,2,3)
a.mkString("1",",","2")
// String = 11,2,32

def nonEmpty：boolean

判断是否为空

def padTo(len:Int,ele:T)：Array[T]

后补齐序列，若 序列长度小于len，则：[序列末尾,len]之间全部填充元素ele；若 序列长度大于len，则返回当前序列

val a=Array(1,2,3)
a.padTo(5,4) // Array[Int] = Array(1, 2, 3, 4, 4)
a.padTo(3,4) //  Array[Int] = Array(1, 2, 3)

def par：ParArray[T]

返回一个并行序列且不能被修改，其作用相当于hashcode进行分区

def partition(p:=>boolean)：(Array[T],Array[T])

按条件分区，满足放第一序列，不满足放第二序列,返回的为元组

val a=List(1,2,3,4,5)
a.partition(_>2)
//(List[Int], List[Int]) = (List(3, 4, 5),List(1, 2))

def patch(from:Int,that:GenSeq[T],replaced:Int)：Array[T]

从from处开始，将原序列replaced个元素替换为序列that,that序列长度大于replaced个数，原序列扩容，相反则长度减小

val a=Array(1,2,3,4)
a.patch(2,Array(8,9,10),1)//  Array[Int] = Array(1, 2, 8, 9, 10, 4)
a.patch(0,Array(8,9),3)// Array[Int] = Array(8, 9, 4)

def permutations：collection.Iterator[Array[T]]

排列组合，内容可以相同，顺序不能一致（combinations排列内容和顺序都不一致）

val a=Array(1,2,3)
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

def prefixLength(p=>boolean)：Int

由第一个索引开始，返回序列中满足条件p的元素数量，直到有不满足的则结束

val a=Array(1,2,3,4,3,2,1)
a.prefixLength(_<3)
// Int = 2

def product：T

返回元素乘积的值

def reduce

作用和fold相似，fold需要一个初始值，而reduce不需要

val a=Array(1,2,3)
a.reduce(_+_)
//Int = 6

def reduceLeft/reduceRigtht

作用类似于foldLeft/foldRight

def reduceLeftOption/reduceRightOption

作用于上面相同，Option为了解决元素为空时报错问题

def reverse：Array[T]

返回倒序列

val a=Array(1,2,3)
a.reverse
//Array[Int] = Array(3, 2, 1)

def reverseIterator：collection.Iterator[T]

反向迭代器

val a=Array(1,2,3)
a.reverseIterator.foreach(x=>println(x))
//3
  2
  1

def reverseMap(f:x=>x1)：Array[T]

反向map

val a=Array(1,2,3)
a.reverseMap(x=>x+2)
//Array[Int] = Array(5, 4, 3)

def sameElements(that:Array[T])：boolean

两个序列顺序与对应位置的元素是否相同

val a=Array(1,2,3)
val b=Array(1,2,3)
val c=Array(3,2,1)
a.sameElements(b) //true
a.sameElements(c)  //false

def scan/scanLeft/scanRight

用法同 fold，scan会把每一步的计算结果放到一个新的集合中返回，而 fold 返回的是单一的值,reduce不带参数,返回单一值

val a=Array(1,2,3)
a.scan(5)(_+_)
// Array[Int] = Array(5, 6, 8, 11)

def segmentLength(p=>boolean,from:Int)：Int

从序列的 from 处开始向后查找，所有满足 p 的连续元素的长度

val a=Array(1,2,3,4,5,6)
a.segmentLength(_>2,0) //Int = 0
a.segmentLength(_<5,0) //Int = 4

def seq：collection.mutable.IndexedSeq[T]

产生一个引用当前序列的 sequential 视图

val a=Array(1,2,3)
a.seq
// scala.collection.mutable.IndexedSeq[Int] = WrappedArray(1, 2, 3, 4, 5, 6)

def size：Int

统计长度，碰到空也统计（不同与java）

def slice(from:Int,until:Int)：Array[T]

取出当前序列中，from 到 until 之间的片段(前包后不包)

val a=Array(1,2,3,4,5)
a.slice(1,3)
//Array[Int] = Array(2, 3)

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

由第一个元素开始，每size个元素组成一个数组，直到当前序列长度不够

val a=Array(1,2,3,4)
a.sliding(2).foreach(x=>println(x.mkString(",")))
//1,2
  2,3
  3,4

def sortBy(f:T=>B)：Array[T]

按指定的排序规则排序

val a=Array(1,4,2,5,6,3)
a.sortBy(x=>x) //正序
//Array[Int] = Array(1, 2, 3, 4, 5, 6)
a.sortBy(x=>(-x)) //倒序
//Array[Int] = Array(6, 5, 4, 3, 2, 1)

def sortWith(t:(T,T)=>boolean)：Array[T]

自定义排序方法 t

val a=Array(2,3,4,1,5,6,3)
a.sortWith(_.compareTo(_)>0)//倒序
// Array[Int] = Array(6, 5, 4, 3, 3, 2, 1)

def sorted：Array[T]

默认排序

val a=Array(2,3,4,1,5,6,3)
a.sorted
//Array[Int] = Array(1, 2, 3, 3, 4, 5, 6)

def span(p=>boolean)：(Array[T],Array[T])

分割序列为两个集合，从第一个元素开始，直到找到第一个不满足条件的元素止，之前的元素放到第一个集合，其它的放到第二个集合

val a=Array(1,2,3,4,5)
a.span(_>2)
// (Array[Int], Array[Int]) = (Array(),Array(1, 2, 3, 4, 5))

def splitAt(n:Int)：(Array[T],Array[T])

从指定位置(位于后一个Array[T])开始，把序列拆分成两个集合

val a=Array(1,2,3,4,5)
a.splitAt(2)
// (Array[Int], Array[Int]) = (Array(1, 2),Array(3, 4, 5))

def toString

返回toString结果前缀

def subSequence(start:Int,end:Int)：CharSequence

返回 start 和 end 间的字符序列 左包又不包 只针对char类型(前包后不包)

val a=Array('a','b','c')
a.subSequence(0,2)
// CharSequence = ab

def take(n:Int)：Array[T]

返回当前序列中前 n 个元素组成的序列

val a=Array(1,2,3,4)
a.take(3)
// Array[Int] = Array(1, 2, 3)

def takeRight(n:Int)：Array[T]

返回当前序列中，从右边开始，选择 n 个元素组成的序列

val a=Array(1,2,3)
a.takeRight(1)
// Array[Int] = Array(3)

//返回中间元素
a.take(2).takeRight(1)
// Array[Int] = Array(2)

def takeWhile(p=>boolean)：Array[T]

返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列

val a=Array(1,2,3,2,1)
a.takeWhile(_<3)
// Array[Int] = Array(1, 2)

def toArray /toBuffer /toIndexedSeq /toIterable /toIterator /toList /toMap /toSeq /toSet /toStream /toVector

转换为对应的类型

def transpose(imlicit asArray=>Array[U])：Array[Array[U]]

矩阵转换，二维数组的行列转换

val a=Array(Array(1,2),Array(3,4),Array(5,6))
a.transpose
// Array[Array[Int]] = Array(Array(1, 3, 5), Array(2, 4, 6))

def union(that:Seq[T])：Array[T]

联合两个序列，同++

val a=Array(1,2,3)
val b=Array(4,5)
a.union(b)
// Array[Int] = Array(1, 2, 3, 4, 5)

def unzip[T1,T2](implicit asPair=>(T1,T2),ct1,ct2)：(Array[T1],Array[T2])

将含有两个元素的数组，第一个元素取出组成一个序列，第二个元素组成一个序列,元组序列可以有多个，但每一个内只能两个元素

val a=Array((1,2),(3,4),(5,6),(7,8))
a.unzip
//(Array[Int], Array[Int]) = (Array(1, 3, 5, 7),Array(2, 4, 6, 8))

def unzip3

同上，但是每个序列要求元素为3

val a=Array((1,2,3),(4,5,6))
a.unzip3
// (Array[Int], Array[Int], Array[Int]) = (Array(1, 4),Array(2, 5),Array(3, 6))

def update(i:Int,ele:T)：Array[T]

修改i索引位置的值为ele

val a=Array(1,2,3)
a.update(1,4)
// Array[Int] = Array(1, 4, 3)

def updated(i:Int,ele:T)：Array[T]

修改i索引位置的值为ele,并返回替换后的数组

def view(from: Int, until: Int)

取出当前序列中，from 到 until 之间的片段

def withFilter(p=>boolean)：FilterMonadic[T,Array[T]]

根据条件p过滤

val a=Array(1,2,3,4)
a.withFilter(_>2) //scala.collection.generic.FilterMonadic[Int,Array[Int]] = scala.collection.TraversableLike$WithFilter@24032706
a.withFilter(_>2).foreach(println) //3  4

def zip(that:GenIterable)：Array[(A,B)]

将两个序列对应位置上的元素组成一个pair序列

val a=Array(1,2,3)
val b=Array(4,5)
a.zip(b)
//Array[(Int, Int)] = Array((1,4), (2,5))

def zipAll(B:collection.Iterable,elethis,elethat)：Array[(A,B)]

作用同上，出现序列长短不同，不会去除，若当前序列短，则填充elethis，若B序列短，则填充elethat

val a=Array(1,2,3,4)
val b=Array(5,6,7)
a.zipAll(b,8,9)     //Array[(Int, Int)] = Array((1,5), (2,6), (3,7), (4,9))

val a=Array(1,2,3)
val b=Array(4,5,6,7,8)
a.zipAll(b,8,9)     // Array[(Int, Int)] = Array((1,4), (2,5), (3,6), (8,7), (8,8))

def zipWithIndex：Array[(A,int)]

序列中的每个元素和它的索引组成一个序列

val a=Array(1,2,3,4,5)
a.zipWithIndex
// Array[(Int, Int)] = Array((1,0), (2,1), (3,2), (4,3), (5,4))