Scala Array常用方法（二）
我们在上一篇博客Scala Array常用方法（一）中已经介绍了很多Scala中Array的常见的方法，下面我们就将Array的方法给大家介绍完。
indexOf
- def indexOf(elem: T): Int
- 返回elem在序列中的索引，找到第一个就返回
- def indexOf(elem: T, from: Int): Int
- 返回elem在序列中的索引，可以指定从某个索引处（from）开始查找，找到第一个就返回
val a = Array(1,3,2,3,4)
println(a.indexOf(3)) // 1
println(a.indexOf(3,2)) // 3
indexOfSlice
- def indexOfSlice[B >: A](that: GenSeq[B]): Int
- 检测当前序列中是否包含另一个序列（that），并返回第一个匹配出现的元素的索引
- def indexOfSlice[B >: A](that: GenSeq[B], from: Int): Int
- 检测当前序列中是否包含另一个序列（that），并返回第一个匹配出现的元素的索引，指定从 from 索引处开始
val a = Array(1, 3, 2, 3, 2, 3, 4)
val b = Array(2,3)
println(a.indexOfSlice(b)) // return 2
println(a.indexOfSlice(b,3)) // return 4
indexWhere
- def indexWhere(p: (T) ⇒ Boolean): Int
- 返回当前序列中第一个满足 p 条件的元素的索引
- def indexWhere(p: (T) ⇒ Boolean, from: Int): Int
- 返回当前序列中第一个满足 p 条件的元素的索引，可以指定从 from 索引处开始
val a = Array(1, 2, 3, 4, 5, 6)
println(a.indexWhere( {x:Int => x>3})) // return 3
println(a.indexWhere( {x:Int => x>3},4)) // return 4
indices
- def indices: collection.immutable.Range
- 返回当前序列索引集合
val a = Array(1,2,3,3,1,2,3)
val b = a.indies
println(b.mkString(",")) //0,1,2,3,4,5,6
init
- def init: Array[T]
- 返回当前序列中不包含最后一个元素的序列
val a = Array(1,2,3,3,1,2,3)
val b = a.init
println(b.mkString) //1,2,3,3,1,2
inits
- def inits: collection.Iterator[Array[T]]
- 对集合中的元素进行 init 操作，该操作的返回值中， 第一个值是当前序列的副本，包含当前序列所有的元素，最后一个值是空的，对头尾之间的值进行init操作，上一步的结果作为下一步的操作对象
val a = Array(1,2,3,4,5)
val b = a.inits.toList
//b: List[Array[Int]] = List(Array(1, 2, 3, 4, 5), Array(1, 2, 3, 4), Array(1, 2, 3), Array(1, 2), Array(1), Array())
intersect
- def intersect(that: collection.Seq[T]): Array[T]
- 取两个集合的交集
val a = Array(1, 2, 3, 4, 5)
val b = Array(3, 4, 6)
val c = a.intersect(b)
println(c.mkString(",")) //return 3,4
isDefinedAt
- def isDefinedAt(idx: Int): Boolean
- 判断序列中是否存在指定索引
val a = Array(1, 2, 3, 4, 5)
println(a.isDefinedAt(1)) // true
println(a.isDefinedAt(10)) // false
isEmpty
- def isEmpty: Boolean
- 判断当前序列是否为空
val a = Array(1,2,3)
a.isEmpty //false
val b:Array[Int] = Array()
b.isEmpty //true
isTraversableAgain
- def isTraversableAgain: Boolean
- 判断序列是否可以反复遍历，该方法是GenTraversableOnce中的方法，对于 Traversables 一般返回true，对于 Iterators 返回 false，除非被复写
val a = Array(1,2,3)
a.isTraversableAgain //true
a.toIterator.isTraversableAgain //false
iterator
- def iterator: collection.Iterator[T]
- 对序列中的每个元素产生一个 iterator
val a = Array(1,2,3,4)
a.iterator.toList //List(1, 2, 3, 4, 5)
last
- def last: T
- 取得序列中最后一个元素
val a = Array(1,2,3,4)
a.last //4
lastIndexOf
- def lastIndexOf(elem: T): Int
- 取得序列中最后一个等于 elem 的元素的位置
- def lastIndexOf(elem: T, end: Int): Int
- 取得序列中最后一个等于 elem 的元素的位置，可以指定在 end 之前（包括）的元素中查找
val a =Array(1,2,3,4,5,2)
a.lastIndexOf(2) //5
a.lastIndexOf(2,3) //1
lastIndexOfSlice
- def lastIndexOfSlice[B >: A](that: GenSeq[B]): Int
- 判断当前序列中是否包含序列 that，并返回最后一次出现该序列的位置处的索引
- def lastIndexOfSlice[B >: A](that: GenSeq[B], end: Int): Int
- 判断当前序列中是否包含序列 that，并返回最后一次出现该序列的位置处的索引，可以指定在 end 之前（包括）的元素中查找
val a = Array(1, 4, 2, 3, 4, 5, 1, 4)
val b = Array(1, 4)
a.lastIndexOfSlice(b) //6
a.lastIndexOfSlice(b,4) //0
lastIndexWhere
- def lastIndexWhere(p: (T) ⇒ Boolean): Int
- 返回当前序列中最后一个满足条件 p 的元素的索引
- def 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}) //6
a.lastIndexWhere( {x:Int => x<2},2) //0
lastOption
- def lastOption: Option[T]
- 返回当前序列中最后一个对象
val a = Array(1,2,3,4,5)
a.lastOption //some(5)
length
- def length: Int
- 返回当前序列中元素个数
val a = Array(1,2,3,4,5)
a.length //5
lenghtCompare
- def lengthCompare(len: Int): Int
- 比较序列的长度和参数 len，返回序列长度和参数len的差值
val a = Array(1,2,3,4,5)
a.lengthCompare(9) //-4
a.lengthCompare(5) //0
a.lengthCompare(3) //2
map
- def map[B](f: (A) ⇒ B): Array[B]
- 对序列中的元素进行 f 操作
val a = Array(1,2,3,4,5)
a.map(x=>x*10) //10,20,30,40,50
max
- def max: A
- 返回序列中最大的元素
val a = Array(1,2,3,4,5)
a.max //5
maxBy
- def maxBy[B](f: (A) ⇒ B): A
- 返回序列中第一个满足条件的元素，若是都不满足，则返回数组的第一个元素
val a = Array(1,2,3,4,5)
a.maxBy(x=>x>2) //3
a.maxBy(x=>x>50) //1 数组都不满足，返回第一个元素1
下面的是maxBy的源码。
min
- def min: A
- 返回序列中最小的元素
val a = Array(6,2,4,5,1,3,7)
a.min //1
minBy
- def minBy[B](f: (A) ⇒ B): A
- 返回序列中第一个不满足条件的元素，若是都满足或是都不满足，则返回数组的第一个元素
val a = Array(6,2,4,5,1,3,7)
a.minBy(x=>x>3) //2
a.minBy(x=>x<0) //6
mkString
- def mkString: String
- def mkString(sep: String): String
- 将所有元素组合成一个字符串，以 sep 作为元素间的分隔符
val a = Array(1, 2, 3, 4, 5)
println(a.mkString("_")) // return 1_2_3_4_5
nonEmpty
- def nonEmpty: Boolean
- 判断序列不是空
val a = Array(1,2,3)
a.isEmpty //true
val b:Array[Int] = Array()
b.isEmpty //false
padTo
- def padTo(len: Int, elem: A): Array[A]
- 后补齐序列，如果当前序列长度小于 len，那么新产生的序列长度是 len，多出的几个位值填充 elem，如果当前序列大于等于 len ，则返回当前序列
val a = Array(1,2,3,4)
a.padTo(6,100) //新序列长度为6，不足的地方用100补充，即1,2,3,4,100,100
par
- def par: ParArray[T]
- 返回一个并行实现，产生的并行序列，不能被修改
- 可以理解为多线程
val a = Array(1, 2, 3, 4, 5)
val b = a.par // "ParArray" size = 5
partition
- def partition(p: (T) ⇒ Boolean): (Array[T], Array[T])
- 按条件将序列拆分成两个新的序列，满足条件的放到第一个序列中，其余的放到第二个序列，下面以序列元素是否是 2 的倍数来拆分
val a = Array(1, 2, 3, 4, 5)
val b:(Array[Int],Array[Int]) = a.partition( {x:Int => x % 2 == 0})
b._1.mkString(",") //2,4
b._2.mkString(",") //1,3,5
patch
- def patch(from: Int, that: GenSeq[A], replaced: Int): Array[A]
- 批量替换，从原序列的 from 处开始，后面的 replaced 数量个元素，将被替换成序列 that
val a = Array(1,2,3,4,5,6,7,8)
val b = Array(100,200,300)
a.patch(3,b,2) //1, 2, 3, 100, 200, 300, 6, 7, 8
//序列a下标为3的元素开始，一共2个元素，被替换成b的内容
permutations
- def permutations: collection.Iterator[Array[T]]
- 排列组合，他与combinations不同的是，组合中的内容可以相同，但是顺序不能相同，combinations不允许包含的内容相同，即使顺序不一样
val a = Array(1, 2, 3, 4, 5)
val b = a.permutations.toList
// b 中将有120个结果，知道排列组合公式的，应该不难理解吧
/**如果是combinations*/
val b = a.combinations(5).toList
// b 中只有一个，因为不管怎样排列，都是这5个数字组成，所以只能保留第一个
prefixLength
- def prefixLength(p: (T) ⇒ Boolean): Int
- 给定一个条件 p，返回一个前置数列的长度，这个数列中的元素都满足 p
val a = Array(1,2,3,4,1,2,3,4)
val b = a.prefixLength( {x:Int => x<3}) // b = 2
product
- def product: A
- 返回所有元素乘积的值
val a = Array(1,2,3,4,5)
val b = a.product // b = 120 （1*2*3*4*5）
reduce
- def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1
- 同 fold，不需要初始值
val a = Array(1,2,3,4,5)
a.reduce((x,y)=>{ println(x,y);x+y }) //15
/**
1,2
3,3
6,4
10,5
*/
reduceLeft
- -def reduceLeft[B >: A](op: (B, T) ⇒ B): B
- 从左向右计算
reduceRight
- def reduceRight[B >: A](op: (T, B) ⇒ B): B
- 从右向左计算
reduceLeftOption
- def reduceLeftOption[B >: A](op: (B, T) ⇒ B): Option[B]
- 计算Option，参考reduceLeft
reduceRightOption
- def reduceRightOption[B >: A](op: (T, B) ⇒ B): Option[B]
- 计算Option，参考reduceRight
reverse
- def reverse:Array[T]
- 反转序列
val a = Array(1,2,3,4,5)
a.reverse //5,4,3,2,1
reverseIterator
- def reverseIterator: collection.Iterator[T]
- 反向生成迭代
reverseMap
- def reverseMap[B](f: (A) ⇒ B): Array[B]
- 同 map 方向相反
val a = Array(1,2,3,4,5)
a.reverseMap( {x:Int => x*10} ) // 50,40,30,20,10
sameElements
- def 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
val c = Array(1,2,3,5,4)
println(a.sameElements(c)) // false
scan
- def scan[B >: A, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Array[T], B, That]): That
- 用法同 fold，scan会把每一步的计算结果放到一个新的集合中返回，而 fold 返回的是单一的值
def seqop(m:Int,n:Int): Int ={
println("seqop,"+m+","+n)
}
val a = Array(1, 2, 3,4)
val b = a.scan(5)(seqop)
/** 运算过程
seqop,5,1
seqop,6,2
seqop,8,3
seqop,11,4
最终结果为 5,6,8,11,15
*/
scanLeft
- def scanLeft[B, That](z: B)(op: (B, T) ⇒ B)(implicit bf:CanBuildFrom[Array[T], B, That]):
- That 从左向右计算，同scan
scanRight
- def scanRight[B, That](z: B)(op: (T, B) ⇒ B)(implicit bf:CanBuildFrom[Array[T], B, That]): That
- 从右向左计算
segmentLength
- def segmentLength(p: (T) ⇒ Boolean, from: Int): Int
- 从序列的 from处开始向后查找，所有满足 p 的连续元素的长度
val a = Array(1,2,3,1,1,1,1,1,4,5)
a.segmentLength( {x:Int => x < 3},3) // 5
size
- def size: Int
- 序列元素个数，同 length
val a = Array(1,2,3,4,5)
a.size //5
slice
- def slice(from: Int, until: Int): Array[T]
- 取出当前序列中，from 到 until 之间的片段
val a = Array(1,2,3,4,5,6)
a.slice(2,5) //3,4,5
sliding
- def sliding(size: Int): collection.Iterator[Array[T]]
- 从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止
- def sliding(size: Int, step: Int): collection.Iterator[Array[T]]
- 从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止
该方法，可以设置步进 step，第一个元素组合完后，下一个从 上一个元素位置+step后的位置处的元素开始
- 从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止
val a = Array(1,2,3,4,5,6,7,8,9)
a.sliding(3).toList // List(Array(1, 2, 3), Array(2, 3, 4), Array(3, 4, 5), Array(4, 5, 6), Array(5, 6, 7), Array(6, 7, 8), Array(7, 8, 9))
a.sliding(3,2).toList //List[Array[Int]] = List(Array(1, 2, 3), Array(3, 4, 5), Array(5, 6, 7), Array(7, 8, 9))
sortBy
- def sortBy[B](f: (T) ⇒ B)(implicit ord: math.Ordering[B]): Array[T]
- 按指定的排序规则排序
- 默认升序，降序加’-'号
val a = Array(3,2,6,4,1,8,5,4)
a.sortBy(x=>x) //1,2,3,4,4,5,6,8
a.sortBy(x=>{-x}) //8,6,5,4,4,3,2,1
sortWith
- def sortWith(lt: (T, T) ⇒ Boolean): Array[T]
- 自定义排序方法 lt
val a = Array(3,2,6,4,1,8,5,4)
a.sortWith((x,y)=>{println(x,y);x.compareTo(y)>0})
/**
(2,3)
(3,2)
(6,2)
(6,2)
(6,3)
(4,3)
(4,6)
(6,4)
(1,3)
(3,1)
(1,2)
(2,1)
(8,3)
(8,4)
(8,6)
(5,3)
(5,6)
(6,5)
(5,4)
(4,4)
(4,4)
(4,2)
(4,3)
res15: Array[Int] = Array(8, 6, 5, 4, 4, 3, 2, 1)
*/
sorted
- def sorted[B >: A](implicit ord: math.Ordering[B]): Array[T]
- 使用默认的排序规则对序列排序,升序
val a = Array(3,2,6,4,1,8,5,4)
a.sorted //1, 2, 3, 4, 4, 5, 6, 8
span
- def span(p: (T) ⇒ Boolean): (Array[T], Array[T])
- 分割序列为两个集合，从第一个元素开始，直到找到第一个不满足条件的元素止，之前的元素放到第一个集合，其它的放到第二个集合
val a = Array(9,7,4,2,1,8)
a.span(_>4) //Array(9, 7),Array(4, 2, 1, 8)
splitAt
- def splitAt(n: Int): (Array[T], Array[T])
- 从指定位置开始，把序列拆分成两个集合
val a = Array(9,7,4,2,1,8)
a.splitAt(3) //Array(9, 7, 4),Array(2, 1, 8)
startsWith
- def startsWith[B](that: GenSeq[B]): Boolean
- 是否以某个序列开始
- def startsWith[B](that: GenSeq[B], offset: Int): Boolean
- 从指定偏移处，是否以某个序列开始
val a = Array(1,2,3,4,5,6,7,8)
val b = Array(4,5,6,7)
a.startsWith(b) //false
a.startsWith(b,3) //true
stringPrefix
- def 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
- def subSequence(start: Int, end: Int): CharSequence
- 返回 start 和 end 间的字符序列
val chars = Array('a','b','c')
chars.subSequence(1,2) //b
sum
- def sum: A
- 序列求和，元素需为Numeric[T]类型
val a = Array(1,2,3,4,5,6,7,8)
a.sum //36
take
- def take(n: Int): Array[T]
- 返回当前序列中前 n 个元素组成的序列
val a = Array(1,2,3,4,5)
val b = a.take(3) // 1,2,3
takeRight
- def takeRight(n: Int): Array[T]
- 返回当前序列中，从右边开始，选择 n 个元素组成的序列
val a = Array(1,2,3,4,5)
val b = a.takeRight(3) // 3,4,5
takeWhile
- def takeWhile(p: (T) ⇒ Boolean): Array[T]
- 返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列
val a = Array(1,2,3,4,5,6,4,3,2,1)
a.takeWhile(x=>x<5) //1, 2, 3, 4
toArray
- def toArray: Array[A]
- 转换成 Array 类型
toBuffer
- def toBuffer[A1 >: A]: Buffer[A1]
- 转换成 Buffer 类型
toIndexedSeq
- def toIndexedSeq: collection.immutable.IndexedSeq[T]
- 转换成 IndexedSeq类型
toInterable
- def toIterable: collection.Iterable[T]
- 转换成可迭代的类型
toIterator
- def toIterator: collection.Iterator[T]
- 同 iterator 方法
toList
- def toList: List[T]
- 同 List 类型
toMap
- def toMap[T, U]: Map[T, U]
- 同 Map 类型，需要被转化序列中包含的元素时 Tuple2 类型数据
toSeq
- def toSeq: collection.Seq[T]
- 同 Seq 类型
toSet
- def toSet[B >: A]: Set[B]
- 同 Set 类型
toStream
- def toStream: collection.immutable.Stream[T]
- 同 Stream 类型
toVector
- def toVector: Vector[T]
- 同 Vector 类型
transpose
- def transpose[U](implicit asArray: (T) ⇒ Array[U]): Array[Array[U]]
- 矩阵转换，二维数组行列转换
val arr = Array(Array("a","b"),Array("c","d"),Array("e","f"),Array("g","h"))
arr.transpose //Array(a, c, e, g), Array(b, d, f, h)
union
- def union(that: collection.Seq[T]): Array[T]
- 联合两个序列，同操作符 ++
val a = Array(1,2,3,4,5)
val b = Array(6,7)
a.union(b) // 1,2,3,4,5,6,7
unzip
- def unzip[T1, T2](implicit asPair: (T) ⇒ (T1, T2), ct1: ClassTag[T1], ct2: ClassTag[T2]): (Array[T1], Array[T2])
- 将含有两个元素的数组，第一个元素取出组成一个序列，第二个元素组成一个序列
val chars = Array(("a","b"),("c","d"))
chars.unzip //Array(a, c),Array(b, d)
unzip3
- def 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 chars3 = Array(("a","b",1),("c","d",2),("e","f",3))
chars3.unzip3 //Array(a, c, e),Array(b, d, f),Array(1, 2, 3)
update
- def update(i: Int, x: T): Unit
- 将序列中 i 索引处的元素更新为 x
val a = Array(1,2,3,4,5,6,7,8)
a.update(5,100) //1, 2, 3, 4, 5, 100, 7, 8
view
- def view(from: Int, until: Int): IndexedSeqView[T, Array[T]]
- 返回 from 到 until 间的序列，不包括 until 处的元素
val a = Array(1,2,3,4,5,6,7,8)
a.view(0,3).toList //1, 2, 3
withFilter
- def withFilter(p: (T) ⇒ Boolean): FilterMonadic[T, Array[T]]
- 根据条件 p 过滤元素
val a = Array(1,2,3,4,5,6,7,8)
a.withFilter(x=>x>5).map(x=>x) //6, 7, 8
zip
- def zip[B](that: GenIterable[B]): Array[(A, B)]
- 将两个序列对应位置上的元素组成一个pair序列
val a = Array(1,2,3,4,5)
val b = Array(6,7,8,9,10)
a.zip(b) //(1,6), (2,7), (3,8), (4,9), (5,10)
zipAll
- def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): Array[(A, B)]
- 同 zip ，但是允许两个序列长度不一样，不足的自动填充，如果当前序列端，空出的填充为 thisElem，如果 that 短，填充为 thatElem
- 补充的规则可以理解为，左边短用左边补，右边短用右边补
val b = Array(6,7,8,9,10)
val c = Array(1,2)
c.zipAll(b,100,200) //(1,6), (2,7), (100,8), (100,9), (100,10)
b.zipAll(c,100,200) //(6,1), (7,2), (8,200), (9,200), (10,200)
zipWithIndex
- def zipWithIndex: Array[(A, Int)]
- 序列中的每个元素和它的索引组成一个序列
val a = Array(10,20,30,40)
a.zipWithIndex //(10,0),(20,1),(30,2),(40,3)
395
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
