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))
