Scala 用法之 Array,List 大全

最新推荐文章于 2024-11-22 01:00:00 发布

原创最新推荐文章于 2024-11-22 01:00:00 发布 · 614 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

scala

本文详细介绍了Scala中Array和List的各种操作方法，包括合并、添加元素、遍历、聚合计算、过滤、映射、查找、排序等，涵盖了从基本操作到高级用法的多个方面，帮助开发者深入理解Scala集合操作。

1.++

def ++[B](that: GenTraversableOnce[B]): Array[B]

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

示例

val a =Array(1,2)
val b =Array(3,4)
val c =a ++ b
println(c.mkString(",")) //1,2,3,4

2.++:

def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Array[T], B, That]): That

也是合并两个集合,但是最终返回的集合类型取决于冒号后面的

示例:

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

3.+:

def +:(elem: A): Array[A]

在数组前面添加一个元素,并返回新的数组对象

val a =Array(1,2)
val b = 0+:a
println(b.mkString(",")) //0,1,2

4./:

def /:[B](z: B)(op: (B, T) ⇒ B): B

对数组中所有的元素从左向右进行遍历,进行相同的迭代操作,foldleft的简写

val a =Array(1,2,3,4)
val b =(10/:a)(_+_) //(((10+1)+2)+3)+4=20
val c =(10/:)(_*_) //10*1*2*3*4=120

5.:\

def :[B](z: B)(op: (T, B) ⇒ B): B

对数组中所有的元素从右向左进行遍历,进行相同的迭代操作,foldright的简写

val a =Array(1,2,3,4)
val b=(a:\10)(_-_) //1-(2-(3-(4-10)))=8

6.addString(b)

def addString(b: StringBuilder): StringBuilder

将数组中的元素逐个添加到StringBuilder中

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

7.addString(b,sep)

def addString(b: StringBuilder, sep: String): StringBuilder

将数组中的元素逐个添加到 StringBuilder 中，每个元素用 sep 分隔符分开

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

8.aggregate

def aggregate[B](z: ⇒ B)(seqop: (B, T) ⇒ B, combop: (B, B) ⇒ B): B

聚合计算，aggregate 是柯里化方法，有分区和不分区两种算法

val a =Array(1,2,3,4)
val b =a.aggregate(5)(_+_,_+_) //不分区 5+1+2+3+4=15
val c =a.par.aggregate(5)(_+_,_+_) //分区 (1+5)+(2+5)+(3+5)+(4+5)=30

9.apply

def apply(i: Int): T

获取指定索引处的元素

val a =Array(1,2,3,4)
val b =a.apply(1) //即可简写为a(1)
println(b) //2

10.canEqual

def canEqual(that: Any): Boolean

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

这个方法里所有的对象都可比较,返回的均为true 没啥意义

11.charAt

def charAt(index: Int): Char

获取 index 索引处的字符，这个方法会执行一个隐式的转换，将 Array[T] 转换为 ArrayCharSequence，只有当 T 为 Char 类型时，这个转换才会发生

val chars = Array('a','b','c')
println(chars.charAt(0)) //a

12.clone

def clone(): Array[T]

创建一个副本

 val a = Array(1, 2, 3, 4)
 val b = a.clone()
 println(b.mkString(",")) // 1,2,3,4

13.collect

def collect[B](pf: PartialFunction[A, B]): Array[B]

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

val fun: PartialFunction[Char, Char] = {
      case 'a' => 'A'
      case x => x
    }
    val a = Array('a', 'b', 'c')
    val b = a.collect(fun)
    println(b.mkString(",")) // A,b,c

14.collectFrist

def collectFirst[B](pf: PartialFunction[T, B]): Option[B]

在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算(且返回元素的类型)

val fun: PartialFunction[Any, Int] = {
      case x: Int => x * 100
    }
    val a = Array(1, 'a', "b")
    val b = arr.collectFirst(fun)
    println(b) // Some(100)

15.combinations

def combinations(n: Int): collection.Iterator[Array[T]]

排列组合,该方法只会选出包含字符不一样的组合,不考虑顺序,参数n表示序列的长度

val a = Array(1,2,3)
val b = a.combinations(2)
b.foreach(x=>println(x.mkString(","))) //结果如下
1,2
1,3
2,3

16.contains

def contains[A1 >: A](elem: A1): Boolean

判断序列中是否包含指定对象

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

17.containsSlice

def containsSlice[B](that: GenSeq[B]): Boolean

判断当前序列中是否包含另一个序列

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

18.copyToArray(xs)

def copyToArray(xs: Array[A]): Unit

将当前数组元素复制到另一个数组中

val a = Array(1,2,3,4)
val b = Array(5,6,7,8,9,10)
a.copyToArray(b)
println(b) //1,2,3,4,9,10

19.copyToArray(xs,start)

def copyToArray(xs: Array[A], start: Int): Unit

将当前数组元素复制到另一个数组中，从索引位置开始复制

val a = Array(1,2,3,4)
val b = Array(5,6,7,8,9,10)
a.copyToArray(b,1)
println(b) //5,1,2,3,4,10

20.corresponds

def corresponds[B](that: GenSeq[B])(p: (T, B) ⇒ Boolean): Boolean

判断两个序列的长度以及对应位置元素是否符合某个条件。如果两个序列具有相同的元素数量并且 p(x, y)=true，则返回 true

val a = Array(1, 2, 3, 4)
val b = Array(5, 6, 7, 8)
println(a.corresponds(b)(_ < _)) // true

21.count

def count(p: (T) ⇒ Boolean): Int

统计符合条件的元素个数

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

22.diff

def diff(that: collection.Seq[T]): Array[T]

求两个数组之间的差集(前面数组在后面数组中没有的元素组成的集合)

val a = Array(1, 2, 3, 4)
val b = Array(3, 4, 5, 6)
val c = a.diff(b)
println(c.mkString(",")) // 1,2

23.distinct

def distinct: Array[T]

去除当前数组中重复的元素,只保留一个元素

val a = Array(1, 2, 2, 3, 4, 4)
val b = a.distinct
println(b.mkString(",")) // 1,2,3,4

24.drop

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

将当前数组中前 n 个元素去除，返回一个新数组

val a = Array(1, 2, 3, 4)
val b = a.drop(2)
println(b.mkString(",")) // 3,4

25.dropRight

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

将当前数组后n个元素去除,返回一个新数组

val a = Array(1, 2, 3, 4)
val b = a.dropRight(2)
println(b.mkString(",")) // 1,2

26.dropWhile

def dropWhile(p: (T) ⇒ Boolean): Array[T]

去除当前数组中符合条件的元素,返回新的数组,直到碰到第一个不满足条件的元素结束,否则返回整个数组

val a = Array(1, 2, 3, 4)
val b = a.dropWhile(x => x < 2)
println(b.mkString(",")) // 2,3,4

27.endsWith

def endsWith[B](that: GenSeq[B]): Boolean

判断当前序列是否以某个序列结尾(返回布尔值)

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

28.exists

def exists(p: (T) ⇒ Boolean): Boolean

判断当前数组是否包含满足条件的元素

val a = Array(1, 2, 3, 4)
println(a.exists(x => x == 3)) // true
println(a.exists(x => x == 30)) // false

29.filter

def exists(p: (T) ⇒ Boolean): Boolean

过滤器:取得当前数组中符合条件的元素组成新的数组返回

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

30.find

def find(p: (T) ⇒ Boolean): Option[T]

查找第一个符合条件的元素，返回类型

val a = Array(1, 2, 3, 4)
val b = a.find(x => x > 2)
println(b) // Some(3)

31.flatMap

def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Array[B]

对当前序列的每个元素进行操作，结果放入新序列返回，参数要求是 GenTraversableOnce 及其子类

val a = Array(1, 2, 3, 4)
val b = a.flatMap(x => 1 to x)
println(b.mkString(","))
/**
 * 1,1,2,1,2,3,1,2,3,4
 * 从 1 开始，分别对集合 a 中的每个元素生成一个递增序列，过程如下
 * 1
 * 1,2
 * 1,2,3
 * 1,2,3,4

32.flatten

def flatten[U](implicit asTrav: (T) ⇒ collection.Traversable[U], m: ClassTag[U]): Array[U]

扁平化，将二维数组的所有元素组合在一起，形成一个一维数组返回

val a = Array(Array(1, 2, 3), Array(4, 5, 6))
val b = a.flatten
println(b.mkString(",")) // 1,2,3,4,5,6

33.fold

def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1ClassTag[U]): Array[U]

对序列中的每个元素进行二元运算，和 aggregate 有类似的语义

34.foldLeft

def foldLeft[B](z: B)(op: (B, T) ⇒ B): BClassTag[U]): Array[U]

从左到右计算，简写方式：def /:[B](z: B)(op: (B, T) ⇒ B): B

35.foldRight

foldRight[B](z: B)(op: (B, T) ⇒ B): B

从右到左计算，简写方式：def :\[B](z: B)(op: (T, B) ⇒ B): B

36.forall

def forall(p: (T) ⇒ Boolean): Boolean

检测序列中的元素是否都满足条件 p，如果序列为空，则返回 true

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

37.foreach

def foreach(f: (A) ⇒ Unit): Unit

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

val a = Array(1, 2, 3, 4)
a.foreach(x => println(x * 10))
/**
 * 10
 * 20
 * 30
 * 40
 */

38.groupBy

def 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.foreach(x => println(x._1 + ": " + x._2.mkString(",")))
/**
 * small: 1,2
 * big: 3,4
 */

39.grouped

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

按指定数量分组，每组有 size 个元素，返回一个迭代器

val a = Array(1, 2, 3, 4, 5)
val b = a.grouped(3).toList
b.foreach(x => println("第 " + (b.indexOf(x) + 1) + " 组: " + x.mkString(",")))
/**
 * 第 1 组: 1,2,3
 * 第 2 组: 4,5
 */

40.hasDefiniteSize

def hasDefiniteSize: Boolean

检测序列是否存在有序的长度,Stream这样的流数据返回false

val a = Array(1, 2, 3, 4)
println(a.hasDefiniteSize) // true

41.head

def headOption: Option[T]

返回序列的一个元素的类型,序列为空则返回null

 val a = Array(1, 2, 3, 4)
 println(a.headOption) // Some(1)

42.indexOf(elem)

def indexOf(elem: T): Int

返回序列elem第一次出现的索引

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

43.indexOf(elem,from)

def indexOf(elem: T, from: Int): Int

返回元素 elem 在序列中第一次出现的索引，指定从索引 from 开始查找

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

43.indexOfSlice(that)

def indexOfSlice[B >: A](that: GenSeq[B]): Int

检测当前序列中是否包含序列 that，并返回第一次出现该序列的索引

val a = Array(1, 2, 3, 2, 3, 4)
val b = Array(2, 3)
println(a.indexOfSlice(b)) // 1

44.indexOfSlice(that,from)

def indexOfSlice[B >: A](that: GenSeq[B], from: Int): Int

检测当前序列中是否包含另一个序列 that，指定从索引 from 开始查找，并返回第一次出现该序列的索引

val a = Array(1, 2, 3, 2, 3, 4)
val b = Array(2, 3)
println(a.indexOfSlice(b, 2)) // 3

45.indexWhere(p)

def indexWhere(p: (T) ⇒ Boolean): Int

返回当前序列中第一个满足条件 p 的元素的索引

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

46.indexWhere(p,from)

def indexWhere(p: (T) ⇒ Boolean, from: Int): Int

返回当前序列中第一个满足条件 p 的元素的索引，指定从索引 from 开始查找

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

47.indices

def indices: collection.immutable.Range

返回当前序列索引集合

 val a = Array(1, 2, 3, 4)
 val b = a.indices
 println(b.mkString(",")) // 0,1,2,3

48.init

def init: Array[T]

去除序列中的最后一个元素并返回

val a = Array(1, 2, 3, 4)
val b = a.init
println(b.mkString(",")) // 1,2,3

49.inits

def inits: collection.Iterator[Array[T]]

对集合中的元素进行 init 迭代操作

val a = Array(1,2,3,4)
val b = a.inits.ToList
println(b) //List(Array(1,2,3,4),Array(1,2,3),Array(1,2),Array(1),Array())

50.intersect

def intersect(that: collection.Seq[T]): Array[T]

取两个集合的交集

val a = Array(1, 2, 3, 4)
val b = Array(3, 4, 5, 6)
val c = a.intersect(b)
println(c.mkString(",")) // 3,4

51.isDefindAt

def isDefinedAt(idx: Int): Boolean

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

val a = Array(1, 2, 3, 4)
println(a.isDefinedAt(1)) // true
println(a.isDefinedAt(10)) // false

52.isEmpty

def isEmpty: Boolean

判断序列是否为空

val a = Array(1, 2, 3, 4)
val b = new Array[Int](0)
println(a.isEmpty) // false
println(b.isEmpty) // true

53.isTraversableAgain

def isTraversableAgain: Boolean

判断序列是否可以反复遍历，该方法是 GenTraversableOnce 中的方法，对于 Traversables 一般返回 true，对于 Iterators 返回 false，除非被复写

val a = Array(1, 2, 3, 4)
val b = a.iterator
println(a.isTraversableAgain) // false
println(b.isTraversableAgain) // true

54.iterator

def iterator: collection.Iterator[T]

生成当前序列的迭代器

val a = Array(1, 2, 3, 4)
val b = a.iterator
println(b.mkString(",")) // 1,2,3,4

55.last

def last: T

返回序列中的最后一个元素,如果序列为空,则报错

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

56.lastIndexOf(elem)

def lastIndexOf(elem: T): Int

返回元素elem在序列中最后一次出现的索引

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

57.lastIndexOf(elem,end)

def lastIndexOf(elem: T, end: Int): Int

返回元素 elem 在序列中最后一次出现的索引，指定在索引 end 之前（包括）的元素中查找

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

58.lastIndexOfSlice(that)
def lastIndexOfSlice[B >: A](that: GenSeq[B]): Int

检测当前序列中是否包含序列 that，并返回最后一次出现该序列的索引

val a = Array(1, 2, 3, 2, 3, 4)
val b = Array(2, 3)
println(a.lastIndexOfSlice(b)) // 3

59.lastIndexOfSlice(that,end)

def lastIndexOfSlice[B >: A](that: GenSeq[B], end: Int): Int

检测当前序列中是否包含序列 that，并返回最后一次出现该序列的索引，指定在索引 end 之前（包括）的元素中查找

val a = Array(1, 2, 3, 2, 3, 4)
val b = Array(2, 3)
println(a.lastIndexOfSlice(b, 2)) // 1

60.lastIndexWhere(p)

ef lastIndexWhere(p: (T) ⇒ Boolean): Int

返回当前序列中最后一个满足条件 p 的元素的索引

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

61.lastIndexWhere(p,end)

def lastIndexWhere(p: (T) ⇒ Boolean, end: Int): Int

返回当前序列中最后一个满足条件 p 的元素的索引，指定在索引 end 之前（包括）的元素中查找

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

62.lastOption

def lastOption: Option[T]

返回序列的最后一个元素的 Option 类型对象，如果序列为空，则返回 None

val a = Array(1, 2, 3, 4)
println(a.lastOption) // Some(4)

63.length

def length: Int

返回序列元素个数

val a = Array(1, 2, 3, 4)
println(a.length) // 4

64.lengthCompare

def lengthCompare(len: Int): Int

比较序列的长度和参数 len，返回序列的长度 - len

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

65.map

def map[B](f: (A) ⇒ B): Array[B]

对序列中的元素进行 f 操作，返回生成的新序列

val a = Array(1, 2, 3, 4)
val b = a.map(x => x * 10)
println(b.mkString(",")) // 10,20,30,40

66.max

def max: A

返回序列中最大的元素

val a = Array(1, 2, 3, 4)
println(a.max) // 4

67.maxBy

def maxBy[B](f: (A) ⇒ B): A

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

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

68.min

def max: A

返回序列中最小的元素

val a = Array(1, 2, 3, 4)
println(a.min) // 1

69.minBy

def minBy[B](f: (A) ⇒ B): A

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

val a = Array(1, 2, 3, 4)
println(a.minBy(x => x < 2)) // 2

70.mkString

def mkString: String

将序列中所有元素拼接成一个字符串

val a = Array(1, 2, 3, 4)
println(a.mkString) // 1234

71.mkString(sep)

def mkString: String

将序列中所有元素拼接成一个字符串，以 sep 作为元素间的分隔符

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

72.mkString(start,sep,end)

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

将序列中所有元素拼接成一个字符串，以 start 开头，以 sep 作为元素间的分隔符，以 end 结尾

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

73.nonEmpty

def nonEmpty: Boolean

判断序列是否不为空

val a = Array(1, 2, 3, 4)
val b = new Array[Int](0)
println(a.nonEmpty) // true
println(b.nonEmpty) // false

74.padTo

def padTo(len: Int, elem: A): Array[A]

填充序列，如果当前序列长度小于 len，那么新产生的序列长度是 len，多出的几个位值填充 elem，如果当前序列大于等于 len ，则返回当前序列

val a = Array(1, 2, 3, 4)
val b = a.padTo(7, 8)
println(b.mkString(",")) // 1,2,3,4,8,8,8

75.par

def par: ParArray[T]

返回一个并行实现，产生的并行序列不能被修改

val a = Array(1, 2, 3, 4)
val b = a.par
println(b.mkString(",")) // 1,2,3,4

76.partition

def partition(p: (T) ⇒ Boolean): (Array[T], Array[T])

按条件将序列拆分成两个数组，满足条件的放到第一个数组，其余的放到第二个数组，返回的是包含这两个数组的元组

val a = Array(1, 2, 3, 4)
    val b: (Array[Int], Array[Int]) = a.partition(x => x % 2 == 0)
    println("偶数: " + b._1.mkString(",")) // 偶数: 2,4
    println("奇数: " + b._2.mkString(",")) // 奇数: 1,3

77.patch

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

批量替换，从原序列的 from 处开始，后面的 replaced 个元素，将被替换成序列 that

val a = Array(1, 2, 3, 4)
val b = Array(7, 8, 9)
val c = a.patch(1, b, 2)
println(c.mkString(",")) // 1,7,8,9,4

78.permutations

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

表示排列,会选出所有排列顺序不同的字符(字符相同,顺序不同也视为不同的组合)

val a = Array("a", "b", "c")
val b = a.permutations.toList
b.foreach( x => println(x.mkString(",")))
/**
 * a,b,c
 * a,c,b
 * b,a,c
 * b,c,a
 * c,a,b
 * c,b,a
 */

79.prefixLength

def prefixLength(p: (T) ⇒ Boolean): Int

给定一个条件 p，返回一个前置数列的长度，这个数列中的元素都满足 p

val a = Array(1, 2, 3, 4)
println(a.prefixLength(x => x < 3)) // 2

80.product

def product: A

返回所有元素乘积的值

val a = Array(1, 2, 3, 4)
println(a.product) // 1*2*3*4=24

81.reduce

def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1

同 fold，不需要初始值

val a = Array(1,2,3,4)
a.reduce(_+_) //1+2+3+4=10

82.reduceLeft

def reduceLeft[B >: A](op: (B, T) ⇒ B): B

同 foldLeft，从左向右计算，不需要初始值

83.reduceRight

def reduceRight[B >: A](op: (B, T) ⇒ B): B

同 foldRight，从右向左计算，不需要初始值

84.reduceLeftOption

def reduceLeftOption[B >: A](op: (B, T) ⇒ B): Option[B]

同 reduceLeft，返回 Option

85.reduceRightOption

def reduceRight[B >: A](op: (B, T) ⇒ B): B

同 foldRight，从右向左计算，不需要初始值

86.reverse

def reverse: Array[T]

反转序列

val a = Array(1, 2, 3, 4)
val b = a.reverse
println(b.mkString(",")) // 4,3,2,1

87.reverseIterator

def reverseIterator: collection.Iterator[T]

生成反向迭代器

val a = Array(1, 2, 3, 4)
val b = a.reverseIterator
b.foreach(x => print(x + " ")) // 4 3 2 1

88.reverseMap

def reverseMap[B](f: (A) ⇒ B): Array[B]

同 map，方向相反

val a = Array(1, 2, 3, 4)
val b = a.reverseMap(x => x * 10)
println(b.mkString(",")) // 40,30,20,10

89.sameElements

def sameElements(that: GenIterable[A]): Boolean

判断两个序列是否顺序和对应位置上的元素都一样

val a = Array(1, 2, 3, 4)

val b = Array(1, 2, 3, 4)
println(a.sameElements(b)) // true

val c = Array(1, 3, 2, 4)
println(a.sameElements(c)) // false

90.scan

def scan[B >: A, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Array[T], B, That]): That

同 fold，scan 会把每一步的计算结果放到一个新的集合中返回，而 fold 返回的是最后的结果

val a = Array(1, 2, 3, 4)
val b = a.scan(5)(_ + _)
println(b.mkString(",")) // 5,6,8,11,15

91.scanLeft

def scanLeft[B, That](z: B)(op: (B, T) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That

同 foldLeft，从左向右计算，每一步的计算结果放到一个新的集合中返回

val a = Array(1, 2, 3, 4)
val b = a.scanLeft(5)(_ + _)
println(b.mkString(",")) // 5,6,8,11,15

92.scanRight

def scanRight[B, That](z: B)(op: (T, B) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That

同 foldRight，从右向左计算，每一步的计算结果放到（从右向左放）一个新的集合中返回

val a = Array(1, 2, 3, 4)
val b = a.scanRight(5)(_ + _)
println(b.mkString(",")) // 15,14,12,9,5

93.segmentLength

def segmentLength(p: (T) ⇒ Boolean, from: Int): Int

从序列的from开始查找第一个满足条件p的连续元素的长度

val a = Array(1, 2, 3, 1, 1, 1, 4)
println(a.segmentLength(x => x < 3, 3)) // 3

94.seq

def seq: collection.mutable.IndexedSeq[T]

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

val a = Array(1, 2, 3, 4)
val b = a.seq
println(b.mkString(",")) // 1,2,3,4

95.size

def size: Int

返回序列元素个数，同 length

96.slice

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

返回当前序列中从 from 到 until 之间的序列，不包括 until 处的元素

val a = Array(1, 2, 3, 4)
val b = a.slice(1, 3)
println(b.mkString(",")) // 2,3

97.sliding(size)

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

表示滑动,每个元素和他后面的元素总共组成size个元素的数组,最终组成一个新的集合返回,剩余元素不够size时结束

val a = Array(1,2,3,4,5)
a.sliding(3).toList //List(Array(1,2,3),Array(2,3,4),Array(3,4,5))

98.sliding(size,step)

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

表示滑动,每个元素和他后面的元素总共组成size个元素的数组,最终组成一个新的集合返回,剩余元素不够size时结束.

该方法可设置步长为step,下一组起始元素从上一组起始元素的+step位置开始

val a = Array(1,2,3,4,5)
a.sliding(3,2).toList //List(Array(1,2,3),Array(3,4,5))

99.sortBy

def sortBy[B](f: (T) ⇒ B)(implicit ord: math.Ordering[B]): Array[T]

按指定的排序规则对序列排序

val a = Array(1,2,3,4)
val b = a.sortBy(x=>x)//升序排列
println(b) //1,2,3,4,5
val c = a.sortBy(x=>0 -x)//降序排列
println(c) //5,4,3,2,1

100.sorted

def sorted[B >: A](implicit ord: math.Ordering[B]): Array[T]]

使用默认的排序规则对序列排序

al a = Array(3, 2, 1, 4)
val b = a.sorted // 默认升序排列
println(b.mkString(",")) // 1,2,3,4

101.span

def span(p: (T) ⇒ Boolean): (Array[T], Array[T])

将序列分成两个数组,从第一个元素到第一个不满足条件的元素为第一个数组,其余的放入第二个数组

返回的是包含着2个数组的元组

val a = Array(1,2,3,4)
val b = a.span(x=>x<3) //(Array(1,2),Array(3,4))
b._1 //Array(1,2)
b._2 //Array(3,4)

102.splitAt

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

从指定位置开始，把序列拆分成两个数组

val a = Array(1, 2, 3, 4)
val b = a.splitAt(2)
println(b._1.mkString(",")) //  1,2
println(b._2.mkString(",")) //  3,4

103.startsWith(that)

def startsWith[B](that: GenSeq[B]): Boolean

判断序列是否以某个序列开始

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

104.startsWith(that,offset)

def startsWith[B](that: GenSeq[B], offset: Int): Boolean

判断序列从指定偏移处是否以某个序列开始

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

105.stringPrefix

def stringPrefix: String

返回 toString 结果的前缀

val a = Array(1, 2, 3, 4)
println(a.toString()) // [I@3ab39c39
println(a.stringPrefix) // [I

106.subSequence

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

返回 start 和 end 间的字符序列(必须是字符)，不包含 end 处的元素

val a = Array('a','b','c','d')
a.subSequence(1,3) //bc

107.sum

def sum: A

序列求和，元素需为 Numeric[T] 类型

val a = Array(1, 2, 3, 4)
println(a.sum) // 10

108.tail

def tail: Array[T]

去头,返回当前元素中不包含第一个元素的序列

val a = Array(1, 2, 3, 4)
val b = a.tail
println(b.mkString(",")) // 2,3,4

109.tails

def tails: collection.Iterator[Array[T]]

同 inits，每一步都进行 tail 操作

val a =Array(1,2,3,4)
a.tails.toList //List(Array(1,2,3,4),Array(2,3,4),Array(3,4),Array(4),Array())

110.take

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

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

val a = Array(1, 2, 3, 4)
val b = a.takeRight(3)
println(b.mkString(",")) // 1,2,3

111.takeRight

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

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

 val a = Array(1, 2, 3, 4)
 val b = a.takeRight(3)
 println(b.mkString(",")) // 2,3,4

112.takeWhile

def takeWhile(p: (T) ⇒ Boolean): Array[T]

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

val a = Array(1, 2, 3, 4)
val b = a.takeWhile(x => x < 3)
print(b.mkString(",")) // 1,2

113.toArray

def toArray: Array[A]

将序列转换成 Array 类型

114.toBuffer

def toBuffer[A1 >: A]: Buffer[A1]

将序列转换成 Buffer 类型

115.toIndexedSeq

def toIndexedSeq: collection.immutable.IndexedSeq[T]

将序列转换成 IndexedSeq 类型

116.tolterable

def toIterable: collection.Iterable[T]

将序列转换为可迭代的类型

117.tolterator

def toIterator: collection.Iterator[T]

将序列转换为迭代器

118.toList

def toList: List[T]

将序列转换成 List 类型

119.toMap

def toMap[T, U]: Map[T, U]

将序列转转换成 Map 类型

120.toSeq

def toSeq: collection.Seq[T]

将序列转换成 Seq 类型

121.toSet

def toSet[B >: A]: Set[B]

将序列转换成 Set 类型

122.toStream

def toStream: collection.immutable.Stream[T]

将序列转换成 Stream 类型

123.toVector

def toVector: Vector[T]

将序列转换成 Vector 类型

124.transpose

def transpose[U](implicit asArray: (T) ⇒ Array[U]): Array[Array[U]]

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

val a = Array(Array("a","b"),Array("c","d"),Array("e","f"))
a.transpose //Array(Array(a,c,e),Array(b,d,f))

125.union

def union(that: collection.Seq[T]): Array[T]

合并两个序列，同操作符 ++

126.unzip

def unzip[T1, T2](implicit asPair: (T) ⇒ (T1, T2), ct1: ClassTag[T1], ct2: ClassTag[T2]): (Array[T1], Array[T2])

将含有两个二元组的数组，每个元组的第一个元素组成一个数组，第二个元素组成一个数组，返回包含这两个数组的元组

val a = Array(("a", "b"), ("c", "d"))
val b = a.unzip
println(b._1.mkString(",")) // a,c
println(b._2.mkString(",")) // b,d

127.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 chars = Array(("a", "b", "x"), ("c", "d", "y"), ("e", "f", "z"))
val b = chars.unzip3
println(b._1.mkString(",")) // a,c,e
println(b._2.mkString(",")) // b,d,f
println(b._3.mkString(",")) // x,y,z

128.update

def update(i: Int, x: T): Unit

将序列索引i处的元素替换成x(改变原数组)

val a = Array(1, 2, 3, 4)
a.update(1, 7)
println(a.mkString(",")) //1,7,3,4

129.updated

def updated(index: Int, elem: A): Array[A]

将序列中 i 索引处的元素更新为 x，并返回替换后的数组(不改变原数组)

val a = Array(1, 2, 3, 4)
val b = a.updated(1, 7)
println(b.mkString(",")) //1,7,3,4

130.view

def view(from: Int, until: Int): IndexedSeqView[T, Array[T]]

返回当前序列中从 from 到 until 之间的序列，不包括 until 处的元素

val a = Array(1, 2, 3, 4)
val b = a.view(1, 3)
println(b.mkString(",")) // 2,3

131.withFilter

def withFilter(p: (T) ⇒ Boolean): FilterMonadic[T, Array[T]]

根据条件 p 过滤元素

 val a = Array(1, 2, 3, 4)
 val b = a.withFilter(x => x > 2).map(x => x)
 println(b.mkString(",")) // 3,4

132.zip

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

将两个序列对应位置上的元素组成一个元组数组，要求两个序列长度相同

val a = Array(1, 2, 3, 4)
val b = Array(4, 3, 2, 1)
val c = a.zip(b)
println(c.mkString(",")) // (1,4),(2,3),(3,2),(4,1)

133.zipAll

def 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, 8, 9) // (1,5),(2,4),(3,3),(4,2),(5,1),(6,9),(7,9)
println(c.mkString(","))

val x = Array(1, 2, 3, 4)
val y = Array(6, 5, 4, 3, 2, 1)
val z = x.zipAll(y, 8, 9) // (1,6),(2,5),(3,4),(4,3),(8,2),(8,1)
println(z.mkString(","))

134.zipWithIndex

def zipWithIndex: Array[(A, Int)]

val a = Array('a', 'b', 'c', 'd')
val b = a.zipWithIndex
println(b.mkString(",")) // (a,0),(b,1),(c,2),(d,3)

标签

#spark