scala数组函数合集

超爱慢2023-10-12 8:55

目录

[1. 添加类函数](#1. 添加类函数)

2.生成类函数

3.删除类函数

4.查找类函数

5.统计类函数

6.修改类函数

7.判断类函数

8.获取集合元素

9.集合操作类函数

10.转换类函数

11.工具类函数

12.集合内与集合间计算函数

在 scala 中Array数组是一种可变的、可索引的数据集合

创建数组语法为

val arr : Array[Int] = Array(1,2,3)

[ ]内为数组内的数据类型（Any 表示任何类型，如果你研究过 scala 就会明白 scala 有面向对象的特点，这里 Any 就是对象的父类，类比 java 中的 object）

Array 数组的 基础操作：

Scala 复制代码 
val arr = Array(1, 2, 3, 4) // 声明一个数组对象
val first = arr(0) // 读取第一个元素
arr(3) = 100 // 替换第四个元素为 100
val newarr = arr.map(_ * 2) // 所有元素乘 2
println(newarr.mkString(",")) // 打印数组，结果为：2,4,6,200

Array 数组的函数：

1. 添加类函数

++

定义

Scala 复制代码 
  def ++[B >: A, That](that : scala.collection.GenTraversableOnce[B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

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

演示：

Scala 复制代码 
    val a = Array(1,2,3)
    val b = Array(3,4,5)
    val ints1: Array[Int] = a ++ b
    println(ints1.toList)

++:

定义：

Scala 复制代码 
  def ++:[B >: A, That](that : scala.collection.Traversable[B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述：这个方法同上一个方法类似，两个加号后面多了一个冒号，但是不同的是右边操纵数的类型决定着返回结果的类型

示例：Array 和 List 结合，返回结果是 List 类型

Scala 复制代码 
    val a = Array(1,2,3)
    val b = List(3,4,5)
    val ints1 = a ++: b
    println(ints1.getClass.getName)

+:

定义：

Scala 复制代码 
  def +:[B >: T](elem : B)(implicit evidence$3 : scala.reflect.ClassTag[B]) : scala.Array[B] = { /* compiled code */ }

描述：在数组前面添加一个元素，并返回新的数组对象

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    val ints: Array[Int] = 0 +: a
    println(ints.toList)

:+

定义：

Scala 复制代码 
  def :+[B >: T](elem : B)(implicit evidence$2 : scala.reflect.ClassTag[B]) : scala.Array[B] = { /* compiled code */ }

描述：在数组后面添加一个元素，并返回新的数组对象

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    val ints: Array[Int] = a :+ 0
    println(ints.toList)

2.生成类函数

clone

定义：

Scala 复制代码 
  override def clone() : scala.Array[T] = { /* compiled code */ }

描述：克隆，创建一个副本

示例：clone 和 = 的区别通过下面的结果很容易就能对比出来

Scala 复制代码 
    var a = Array(1,2,3)
    var b = a
    var c = a.clone
    a(0) = 0
    println(b.toList)
    println(c.toList)

collect

定义：

Scala 复制代码 
  def collect[B, That](pf : scala.PartialFunction[A, B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

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

示例：通过下面的偏函数（参数只能是偏函数），把数组中的1转换为"a"

Scala 复制代码 
    val a = Array(1,2,3)
    def fun : PartialFunction[Int,String]={
      case 1 => "a"
      case _ => "other"
    }
    println(a.collect(fun).toList )
复制代码

collectFirst

定义：

Scala 复制代码 
  def collectFirst[B](pf : scala.PartialFunction[A, B]) : scala.Option[B] = { /* compiled code */ }

描述：在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算，返回一个 option

示例：

Scala 复制代码 
    val a = Array(1,2,3)
    def fun : PartialFunction[Int,String]={
      case 1 => "a"
      case _ => "other"
    }
    println(a.collectFirst(fun) )

偏函数也可以用匿名函数表示

Scala 复制代码 
    val a = Array(1,2,3)
    println(a.collectFirst({case x : Int if (x ==2) => x+1}) )

combinations

定义：

Scala 复制代码 
  def combinations(n : scala.Int) : scala.collection.Iterator[Repr] = { /* compiled code */ }

描述：combinations 表示组合，这个排列组合会选出所有包含元素不一样的组合，但不考虑顺序，对于 "123"、"321"，视为相同组合，参数 n 表示序列长度，就是几个元素为一组，返回的是一个迭代器，迭代器里存放的是 每一种组合的Array 数组

Scala 复制代码 
    val a = Array(1,2,3)
    val combine: Iterator[Array[Int]] = a.combinations(2)
    combine.foreach(x=>println(x.toList))

permutations

定义：

Scala 复制代码 
  def permutations : scala.collection.Iterator[Repr] = { /* compiled code */ }

描述：permutations 表示排列，这个排列组合会选出所有排列顺序不同的元素组合，permutations 与 combinations 不同的是，相同的组合考虑排列，对于 "abc"、"cba"，视为不同的组合

示例：

Scala 复制代码 
    val a = Array(1,2,3)
    val permutations: Iterator[Array[Int]] = a.permutations
    permutations.foreach(x=>println(x.toList))

copyToArray(xs)

定义：

Scala 复制代码 
  def copyToArray[B >: A](xs : scala.Array[B]) : scala.Unit = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3)
    val b = new Array[Int](5)
    a.copyToArray(b)
    println(b.toList)

copyToArray(arr, start)

定义：

Scala 复制代码 
  def copyToArray[B >: A](xs : scala.Array[B], start : scala.Int) : scala.Unit = { /* compiled code */ }

描述：将当前数组元素复制到另一个数组中，从 start 位置开始复制

示例：

Scala 复制代码 
    val a = Array(1,2,3)
    val b = new Array[Int](5)
    a.copyToArray(b,1)
    println(b.toList)

copyToArray(arr, start, len)

定义：

Scala 复制代码 
  override def copyToArray[U >: T](xs : scala.Array[U], start : scala.Int, len : scala.Int) : scala.Unit = { /* compiled code */ }

描述：将当前数组元素复制到另一个数组中，从 start 位置开始复制，长度为 len

示例：

Scala 复制代码 
    val a = Array(1,2,3)
    val b = new Array[Int](5)
    a.copyToArray(b,1,2)
    println(b.toList)

copyToBuffer

定义：

Scala 复制代码 
  def copyToBuffer[B >: A](dest : scala.collection.mutable.Buffer[B]) : scala.Unit = { /* compiled code */ }

描述：将数组中的元素复制到 Buffer 中

示例：

Scala 复制代码 
    val a = Array(1,2,3)
    val buffer: ArrayBuffer[Int] = ArrayBuffer()
    a.copyToBuffer(buffer)
    println(buffer.toList)

3.删除类函数

drop

定义：

Scala 复制代码 
  override def drop(n : scala.Int) : Repr = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,4,5,6,7)
    val ints: Array[Int] = a.drop(3)
    println(ints.toList)

dropRight

定义：

Scala 复制代码 
  override def dropRight(n : scala.Int) : Repr = { /* compiled code */ }

描述：功能同 drop，去掉尾部的 n 个元素

示例：

Scala 复制代码 
    val a = Array(1,2,3,4,5,6,7)
    val ints: Array[Int] = a.dropRight(3)
    println(ints.toList)

dropWhile

定义：

Scala 复制代码 
  override def dropWhile(p : scala.Function1[A, scala.Boolean]) : Repr = { /* compiled code */ }

描述：去除当前数组中符合条件的元素，返回剩余的数组，这个需要一个条件，就是从当前数组的第一个元素起，就要满足条件，直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），否则返回整个数组

示例：

Scala 复制代码 
    val a = Array(1,2,3,4,5,6,7,1)
    val ints: Array[Int] = a.dropWhile(x=>x<3)
    println(ints.toList)

4.查找类函数

find

定义：

Scala 复制代码 
  override def find(p : scala.Function1[A, scala.Boolean]) : scala.Option[A] = { /* compiled code */ }

描述：查找第一个符合条件的元素，返回 Option

示例：

Scala 复制代码 
    val a = Array(1,2,3,4,5,6,2,1)
    val maybeInt: Option[Int] = a.find(x => x==2)
    println(maybeInt)

last

定义：

Scala 复制代码 
  override def last : A = { /* compiled code */ }

描述：返回序列的最后一个元素，如果序列为空，将引发错误

示例：

Scala 复制代码 
    val a = Array(1,2,3,4,5,6)
    val last: Int = a.last
    println(last)

lastIndexOf(elem)

定义：

Scala 复制代码 
  def lastIndexOf[B >: A](elem : B) : scala.Int = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,4,5,6)
    val index: Int = a.lastIndexOf(5)
    println(index)

lastIndexOf(elem, end)

定义：

Scala 复制代码 
  def lastIndexOf[B >: A](elem : B, end : scala.Int) : scala.Int = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,4,5,6,2,1)
    val index: Int = a.lastIndexOf(2,5)
    println(index)

lastIndexOfSlice(that)

定义：

Scala 复制代码 
  def lastIndexOfSlice[B >: A](that : scala.collection.GenSeq[B]) : scala.Int = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,4,5,6,3,4,2,1)
    val slice = Array(3,4)
    val index: Int = a.lastIndexOfSlice(slice)
    println(index)

lastIndexOfSlice(that, end)

定义：

Scala 复制代码 
  def lastIndexOfSlice[B >: A](that : scala.collection.GenSeq[B], end : scala.Int) : scala.Int = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,4,5,6,3,4,2,1)
    val slice = Array(3,4)
    val index: Int = a.lastIndexOfSlice(slice,5)
    println(index)

lastIndexWhere

定义：

Scala 复制代码 
  def lastIndexWhere(p : scala.Function1[A, scala.Boolean]) : scala.Int = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,4,5,6,3,4,2,1)
    val index: Int = a.lastIndexWhere(x=>x>3)
    println(index)

lastIndexWhere(p, end)

定义：

Scala 复制代码 
  def lastIndexWhere(p : scala.Function1[A, scala.Boolean], end : scala.Int) : scala.Int

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,4,5,6,3,4,2,1)
    val index: Int = a.lastIndexWhere(x=>x>3,5)
    println(index)

lastOption

定义：

Scala 复制代码 
  def lastOption : scala.Option[A] = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,4,5,6,3,4,2,1)
    val option: Option[Int] = a.lastOption
    println(option)

indexOf(elem)

定义：

Scala 复制代码 
  def indexOf[B >: A](elem : B) : scala.Int = { /* compiled code */ }

描述：返回元素 elem 在序列中第一次出现的索引

示例：

Scala 复制代码 
    val a = Array(1,2,3,4,5,6,3,4,2,1)
    val i: Int = a.indexOf(2)
    println(i)

indexOf(elem, from)

定义：

Scala 复制代码 
  def indexOf[B >: A](elem : B, from : scala.Int) : scala.Int = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,4,5,6,3,4,2,1)
    val i: Int = a.indexOf(2,3)
    println(i)

indexOfSlice(that)

定义：

Scala 复制代码 
  def indexOfSlice[B >: A](that : scala.collection.GenSeq[B]) : scala.Int = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,1,3,4,5,6,3,4,2,1)
    val slide = Array(2,1)
    val i: Int = a.indexOfSlice(slide)
    println(i)

indexOfSlice(that, from)

定义：

Scala 复制代码 
  def indexOfSlice[B >: A](that : scala.collection.GenSeq[B], from : scala.Int) : scala.Int = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,1,3,4,5,6,3,4,2,1)
    val slide = Array(2,1)
    val i: Int = a.indexOfSlice(slide,4)
    println(i)

indexWhere

定义：

Scala 复制代码 
  def indexWhere(p : scala.Function1[A, scala.Boolean]) : scala.Int = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,1,3,4,5,6,3,4,2,1)
    val i: Int = a.indexWhere(x=>x>3)
    println(i)

indexWhere(p, from)

定义：

Scala 复制代码 
  def indexWhere(p : scala.Function1[A, scala.Boolean], from : scala.Int) : scala.Int

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

示例：

Scala 复制代码 
    val a = Array(1,2,1,3,4,5,6,3,4,2,1)
    val i: Int = a.indexWhere(x=>x>3,6)
    println(i)

segmentLength

定义：

Scala 复制代码 
  override def segmentLength(p : scala.Function1[A, scala.Boolean], from : scala.Int) : scala.Int = { /* compiled code */ }

描述：从序列的 from 开始向后查找，返回满足条件 p 的连续元素的长度，只返回第一个

示例：

Scala 复制代码 
    val a = Array(1,2,1,3,4,5,6,3,4,2,1)
    println(a.segmentLength(x=>x>3,0))
    println(a.segmentLength(x=>x>3,4))

5.统计类函数

count

定义：

Scala 复制代码 
  def count(p : scala.Function1[A, scala.Boolean]) : scala.Int = { /* compiled code */ }

描述：统计符合条件的元素个数

示例：下面代码统计数组中所以元素个数和大于 2 的元素个数

Scala 复制代码 
    val a = Array(1,2,3,4)
    println(a.count(x=>true))
    println(a.count(x=>x>2))

max

定义：

Scala 复制代码 
  def max[B >: A](implicit cmp : scala.Ordering[B]) : A = { /* compiled code */ }

描述：返回序列中最大的元素

示例：

Scala 复制代码 
val a = Array(1, 2, 3, 4)
println(a.max) // 4

maxBy

定义：

Scala 复制代码 
  def maxBy[B](f : scala.Function1[A, B])(implicit cmp : scala.Ordering[B]) : A = { /* compiled code */ }

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

示例：

Scala 复制代码 
val a = Array(1, 2, 3, 4)
println(a.maxBy(x => x > 2)) // 3

min

定义：

Scala 复制代码 
  def min[B >: A](implicit cmp : scala.Ordering[B]) : A = { /* compiled code */ }

描述：返回序列中最小的元素

示例：

Scala 复制代码 
val a = Array(1, 2, 3, 4)
println(a.min) // 1

minBy

定义：

Scala 复制代码 
  def minBy[B](f : scala.Function1[A, B])(implicit cmp : scala.Ordering[B]) : A = { /* compiled code */ }

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

示例：

Scala 复制代码 
val a = Array(1, 2, 3, 4)
println(a.minBy(x => x < 2)) // 2

product

定义：

Scala 复制代码 
  def product[B >: A](implicit num : scala.Numeric[B]) : B = { /* compiled code */ }

描述：返回所有元素乘积的值

示例：

Scala 复制代码 
val a = Array(1, 2, 3, 4)
println(a.product) // 1*2*3*4=24

sum

定义：

Scala 复制代码 
  def sum[B >: A](implicit num : scala.Numeric[B]) : B = { /* compiled code */ }

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

示例：

Scala 复制代码 
val a = Array(1, 2, 3, 4)
println(a.sum) // 10

6.修改类函数

update

定义：

Scala 复制代码 
  def update(i : scala.Int, x : T) : scala.Unit = { /* compiled code */ }

描述：将序列中 i 索引处的元素更新为 x

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    a.update(1,0)
    println(a.toList)

updated

定义：

Scala 复制代码 
  def updated[B >: A, That](index : scala.Int, elem : B)(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述：将序列中 i 索引处的元素更新为 x，并返回替换后的数组

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    val ints: Array[Int] = a.updated(1, 0)
    println(ints.toList)

patch

定义：

Scala 复制代码 
  def patch[B >: A, That](from : scala.Int, patch : scala.collection.GenSeq[B], replaced : scala.Int)(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述：批量替换，从原序列的 from 处开始，后面的 replaced 个元素，将被替换成序列 that,返回替换后的数组

示例：从 a 的第二个元素开始，取两个元素，即 2 和 3 ，将这两个元素替换为序列 b

Scala 复制代码 
    val a = Array(1,2,3,4)
    val b = Array(9,8,7)
    val ints: Array[Int] = a.patch(1, b, 2)
    println(ints.toList)

7.判断类函数

contains

定义：

Scala 复制代码 
  def contains[A1 >: A](elem : A1) : scala.Boolean = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    println(a.contains(4))

containsSlice

定义：

Scala 复制代码 
  def containsSlice[B](that : scala.collection.GenSeq[B]) : scala.Boolean = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    println(a.containsSlice(List(2,1)))
    println(a.containsSlice(List(1,2)))

endsWith

定义：

Scala 复制代码 
  override def endsWith[B](that : scala.collection.GenSeq[B]) : scala.Boolean = { /* compiled code */ }

描述：判断当前序列是否以某个序列结尾

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    println(a.endsWith(List(3,4)))

exists

定义：

Scala 复制代码 
  override def exists(p : scala.Function1[A, scala.Boolean]) : scala.Boolean = { /* compiled code */ }

描述：判断当前数组是否包含符合条件的元素

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    println(a.exists(x=>x>5))
    println(a.exists(x=>x==3))

isDefinedAt

定义：

Scala 复制代码 
  def isDefinedAt(idx : scala.Int) : scala.Boolean = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    println(a.isDefinedAt(3))

isEmpty

定义：

Scala 复制代码 
  override def isEmpty : scala.Boolean = { /* compiled code */ }

描述：判断序列是否为空

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    val b = new Array[Any](0)
    println(a.isEmpty)
    println(b.isEmpty)

isTraversableAgain

定义：

Scala 复制代码 
  final def isTraversableAgain : scala.Boolean = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    val b = a.iterator
    println(a.isTraversableAgain)
    println(b.isTraversableAgain)

forall

定义：

Scala 复制代码 
  override def forall(p : scala.Function1[A, scala.Boolean]) : scala.Boolean = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    println(a.forall(x=>x>2))
    println(a.forall(x=>x>0))

nonEmpty

定义：

Scala 复制代码 
  def nonEmpty : scala.Boolean = { /* compiled code */ }

描述：判断序列是否不为空

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    val b = new Array[Any](0)
    println(a.nonEmpty)
    println(b.nonEmpty)

sameElements

定义：

Scala 复制代码 
  override def sameElements[B >: A](that : scala.collection.GenIterable[B]) : scala.Boolean = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    val b = Array(1,2,3,4)
    val c = Array(1,4,3,2)
    println("a 和 b："+a.sameElements(b))
    println("a 和 c："+a.sameElements(c))

startsWith(that)

定义：

Scala 复制代码 
  def startsWith[B](that : scala.collection.GenSeq[B]) : scala.Boolean = { /* compiled code */ }

描述：判断序列是否以某个序列开始

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    println("a开头是否有 1，2："+a.startsWith(Array(1,2)))

startsWith(that, offset)

定义：

Scala 复制代码 
  def startsWith[B](that : scala.collection.GenSeq[B], offset : scala.Int) : scala.Boolean

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    println("a在 1 位置是否有 2，3："+a.startsWith(Array(2,3),1))

hasDefiniteSize

定义：

Scala 复制代码 
  override def hasDefiniteSize : scala.Boolean = { /* compiled code */ }

描述：检测序列是否存在有限的长度，对应 Stream 这样的流数据则返回 false

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    val b =  1 #:: 2 #:: 3 #:: Stream.empty
    println("array数组是否存在有限的长度"+a.hasDefiniteSize)
    println("stream流是否存在有限的长度"+b.hasDefiniteSize)

canEqual

定义：

Scala 复制代码 
  override def canEqual(that : scala.Any) : scala.Boolean = { /* compiled code */ }

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

示例：基本上所有对象都可以进行比较，我不知道这个方法的意义何在

Scala 复制代码 
val a = List(1, 2, 3, 4)
val b = Array('a', 'b', 'c')
println(a.canEqual(b)) // true
val chars = Array('a', 'b', 'c')
println(chars.charAt(0)) // a

corresponds

定义：

Scala 复制代码 
  def corresponds[B](that : scala.collection.GenSeq[B])(p : scala.Function2[A, B, scala.Boolean]) : scala.Boolean = { /* compiled code */ }

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

示例：下面代码检查 a 和 b 长度是否相等，并且 a 中元素是否小于 b 中对应位置的元素

Scala 复制代码 
    val a = Array(1, 2, 3, 4)
    val b = Array(5, 6, 7, 8)
    println(a.corresponds(b)(_ < _))

8.获取集合元素

apply

定义：

Scala 复制代码 
  def apply(i : scala.Int) : T = { /* compiled code */ }

描述：获取指定索引处的元素,与a(0)的取值方法很像，但是当数组中有不同类型的时候，用 apply 取值则会报错

示例：

Scala 复制代码 
    //val a: Array[Any] = Array(1,2, "a", "b")
    val a: Array[Any] = Array( "a", "b")
    println(a.apply(0))
    println(a(1))

charAt

定义：

Scala 复制代码 
    def charAt(index : scala.Int) : scala.Char = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array('a','b','c')
    println(a.charAt(2))

foreach

定义：

Scala 复制代码 
  override def foreach[U](f : scala.Function1[A, U]) : scala.Unit = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array('a','b','c')
    a.foreach(println)

head

定义：

Scala 复制代码 
  override def head : A = { /* compiled code */ }

描述：返回序列的第一个元素，如果序列为空，将引发错误

示例：

Scala 复制代码 
    val a = Array('a','b','c')
    println(a.head)

headOption

定义：

Scala 复制代码 
  def headOption : scala.Option[A] = { /* compiled code */ }

描述：返回序列的第一个元素的 Option 类型对象，如果序列为空，则返回 None

示例：

Scala 复制代码 
    val a = Array('a','b','c')
    println(a.headOption)

init

定义：

Scala 复制代码 
  override def init : Repr = { /* compiled code */ }

描述：返回当前序列中不包含最后一个元素的序列

示例：

Scala 复制代码 
    val a = Array('a','b','c')
    println(a.init.toList)

inits

定义：

Scala 复制代码 
  def inits : scala.collection.Iterator[Repr] = { /* compiled code */ }

描述：对集合中的元素进行 init 迭代操作，该操作的返回值中， 第一个值是当前序列的副本，最后一个值为空，每一步都进行 init 操作，上一步的结果作为下一步的操作对象

示例：

Scala 复制代码 
    val a = Array('a','b','c','d')
    val inits: Iterator[Array[Char]] = a.inits
    inits.foreach(x=>println(x.toList))

tail

定义：

Scala 复制代码 
  override def tail : Repr = { /* compiled code */ }

描述：同 init，返回当前序列中不包含第一个元素的序列

示例：

Scala 复制代码 
val a = Array(1, 2, 3, 4)
val b = a.tail
println(b.mkString(",")) // 2,3,4

tails

定义：

Scala 复制代码 
  def tails : scala.collection.Iterator[Repr] = { /* compiled code */ }

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

示例：

Scala 复制代码 
        val a = Array('a','b','c','d')
        val inits: Iterator[Array[Char]] = a.tails
        inits.foreach(x=>println(x.toList))

take

定义：

Scala 复制代码 
  override def take(n : scala.Int) : Repr = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array('a','b','c','d')
    val b: Array[Char] = a.take(2)
    println(b.toList)

takeRight

定义：

Scala 复制代码 
  override def takeRight(n : scala.Int) : Repr = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array('a','b','c','d')
    val b: Array[Char] = a.takeRight(2)
    println(b.toList)

takeWhile

定义：

Scala 复制代码 
  override def takeWhile(p : scala.Function1[A, scala.Boolean]) : Repr = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array('a','b','c','d')
    val b: Array[Char] = a.takeWhile(x=>x<'c')
    println(b.toList)
    println(a.takeWhile(x=>x=='b').toList)

view

定义：

Scala 复制代码 
  override def view(from : scala.Int, until : scala.Int) : scala.collection.mutable.IndexedSeqView[A, Repr] = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array('a','b','c','d')
    val value: mutable.IndexedSeqView[Char, Array[Char]] = a.view(1, 3)
    println(value.toList)

9.集合操作类函数

filter

定义：

Scala 复制代码 
  def filter(p : scala.Function1[A, scala.Boolean]) : Repr = { /* compiled code */ }

描述：取得当前数组中符合条件的元素，组成新的数组返回

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    val ints: Array[Int] = a.filter(_ > 2)
    println(ints.toList)

filterNot

定义：

Scala 复制代码 
  def filterNot(p : scala.Function1[A, scala.Boolean]) : Repr = { /* compiled code */ }

描述：取得当前数组中不符合条件的元素，组成新的数组返回

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    val ints: Array[Int] = a.filterNot(_ > 2)
    println(ints.toList)

withFilter

定义：

Scala 复制代码 
  def withFilter(p : scala.Function1[A, scala.Boolean]) : scala.collection.generic.FilterMonadic[A, Repr] = { /* compiled code */ }

描述：根据条件 p 过滤元素，如果后续的操作需要使用到map/flatMap/withFilter，推荐使用，这样可以减少filter产生的中间collection，使得执行更加高效

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    val ints: Array[Int] = a.withFilter(_ > 2).map(x => x+1)
    println(ints.toList)

reverse

定义：

Scala 复制代码 
  override def reverse : Repr = { /* compiled code */ }

描述：反转序列，返回一个 Array 数组

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    val reverse: Array[Int] = a.reverse
    println(reverse.toList)

reverseIterator

定义：

Scala 复制代码 
  override def reverseIterator : scala.collection.Iterator[A] = { /* compiled code */ }

描述：生成反向迭代器

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    val iterator: Iterator[Int] = a.reverseIterator
    println(iterator.toList)

par

定义：

Scala 复制代码 
  override def par : scala.collection.parallel.mutable.ParArray[T] = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,4,21)
    val par: ParArray[Int] = a.par
    println(par)

partition

定义：

Scala 复制代码 
  def partition(p : scala.Function1[A, scala.Boolean]) : scala.Tuple2[Repr, Repr] = { /* compiled code */ }

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

示例：下面以序列元素是否是偶数来拆分

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

groupBy

定义：

Scala 复制代码 
  def groupBy[K](f : scala.Function1[A, K]) : scala.collection.immutable.Map[K, Repr] = { /* compiled code */ }

描述：按条件分组，条件由 f 匹配，返回值是 Map 类型，每个 key 对应一个数组

示例：把数组中元素分为小于 2、大于 2 和其他，返回 Map[String, Array[Int]]

Scala 复制代码 
    val a = Array(1,2,3,4)
    val stringToInts: Map[String, Array[Int]] = a.groupBy(x => x match {
      case x if (x > 2) => "big"
      case x if (x < 2) => "small"
      case _ => "none"
    })
    stringToInts.foreach(x=>println(x._1+" : "+x._2.toList))

grouped

定义：

  def grouped(size : scala.Int) : scala.collection.Iterator[Repr] = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    val b: Iterator[Array[Int]] = a.grouped(2)
    b.foreach(x=>println(x.toList))

sortBy

定义：

  def sortBy[B](f : scala.Function1[A, B])(implicit ord : scala.math.Ordering[B]) : Repr = { /* compiled code */ }

描述：按指定的排序规则对序列排序

示例：

Scala 复制代码 
    val a = Array(1,3,2,4)
    val ints: Array[Int] = a.sortBy(x => x)
    println("升序排列："+ints.toList)
    println("倒序排列："+a.sortBy(x => 0 - x).toList)

sorted

定义：

  def sorted[B >: A](implicit ord : scala.math.Ordering[B]) : Repr = { /* compiled code */ }

描述：使用默认的排序规则对序列排序

示例：

Scala 复制代码 
    val a = Array(1,2,4,3)
    val sorted: Array[Int] = a.sorted
    println(sorted.toList)

slice

定义：

Scala 复制代码 
  override def slice(from : scala.Int, until : scala.Int) : scala.Array[T] = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,4,5)
    val ints: Array[Int] = a.slice(2, 4)
    println(ints.toList)

sliding(size)

定义：

Scala 复制代码 
  def sliding(size : scala.Int) : scala.collection.Iterator[Repr] = { /* compiled code */ }

描述：滑动，从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素个数不够 size 时，则结束

示例：

Scala 复制代码 
    val a = Array(1,2,3,4,5)
    val iterator: Iterator[Array[Int]] = a.sliding(3)
    iterator.foreach(x=>println(x.toList))

sliding(size, step)

定义：

Scala 复制代码 
  def sliding(size : scala.Int, step : scala.Int) : scala.collection.Iterator[Repr] = { /* compiled code */ }

描述：从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素个数不够 size 时，则结束。该方法可以设置步长 step，每一组元素组合完后，下一组从上一组起始元素位置 + step 后的位置处开始

示例：

Scala 复制代码 
    val a = Array(1,2,3,4,5)
    val iterator: Iterator[Array[Int]] = a.sliding(3,2)
    iterator.foreach(x=>println(x.toList))

span

定义：

Scala 复制代码 
  override def span(p : scala.Function1[A, scala.Boolean]) : scala.Tuple2[Repr, Repr] = { /* compiled code */ }

描述：将序列拆分成两个数组，从第一个元素开始，直到第一个不满足条件的元素为止，其中的元素放到第一个数组，其余的放到第二个数组，返回的是包含这两个数组的元组

示例：

Scala 复制代码 
    val a = Array(1,2,3,4,5,4,3,2,1)
    val tuple: (Array[Int], Array[Int]) = a.span(x => x < 3)
    println(tuple._1.toList)
    println(tuple._2.toList)

splitAt

定义：

Scala 复制代码 
  override def splitAt(n : scala.Int) : scala.Tuple2[Repr, Repr] = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,4,5,4,3,2,1)
    val tuple: (Array[Int], Array[Int]) = a.splitAt(4)
    println("第一组："+tuple._1.toList)
    println("第二组："+tuple._2.toList)

subSequence

定义：

Scala 复制代码 
    def subSequence(start : scala.Int, end : scala.Int) : java.lang.CharSequence = { /* compiled code */ }

描述：类比 slice，slice 是对于数组的，subSequence是对于字符数组，返回 start 和 end 间的字符序列，不包含 end 处的元素

示例：

Scala 复制代码 
    val a = Array('a','b','c','d')
    val sequence: CharSequence = a.subSequence(1, 2)
    println(sequence)

10.转换类函数

flatMap

定义：

Scala 复制代码 
  def flatMap[B, That](f : scala.Function1[A, scala.collection.GenTraversableOnce[B]])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述：对当前序列的每个元素进行操作,可以理解成降维，最低到一维，也可以对一维数组操作，但每一个元素应该都返回一个序列，结果放入新序列返回，参数要求是 GenTraversableOnce 及其子类，即返回可迭代的集合

示例：

Scala 复制代码 
    val a = Array(Array(1,2,3),Array(2,3,4))
    val ints: Array[Int] = a.flatMap(x=>x)
    println(ints.toList)

flatten

定义：

Scala 复制代码 
  def flatten[U](implicit asTrav : scala.Function1[T, scala.collection.Traversable[U]], m : scala.reflect.ClassTag[U]) : scala.Array[U] = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(Array(1,2,3),Array(2,3,4))
    println(a.flatten.toList)

iterator

定义：

Scala 复制代码 
  override def iterator : scala.collection.Iterator[A] = { /* compiled code */ }

描述：生成当前序列的迭代器

示例：

Scala 复制代码 
    val a = Array(1,2,3)
    val iterator: Iterator[Int] = a.iterator
    println(iterator.getClass.getName+" ; "+iterator.toList)

map

定义：

Scala 复制代码 
  def map[B, That](f : scala.Function1[A, B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述：对序列中的元素进行 f 操作，返回生成的新序列，并且能够对结构进行调整

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    val ints: Array[Int] = a.map(x => x + 2)
    println(ints.toList)

reverseMap

定义：

Scala 复制代码 
  def reverseMap[B, That](f : scala.Function1[A, B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述：同 map，方向相反

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    val ints: Array[Int] = a.reverseMap(x => x + 2)
    println(ints.toList)

toArray

定义：

Scala 复制代码 
  def toArray[B >: A](implicit evidence$1 : scala.reflect.ClassTag[B]) : scala.Array[B] = { /* compiled code */ }

描述：将序列转换成 Array 类型

示例：

Scala 复制代码 
    val a = List(1,2,3,4)
    val array: Array[Int] = a.toArray

toBuffer

定义：

Scala 复制代码 
  def toBuffer[B >: A] : scala.collection.mutable.Buffer[B] = { /* compiled code */ }

描述：将序列转换成 Buffer 类型

示例：

Scala 复制代码 
    val a = List(1,2,3,4)
    val buffer: mutable.Buffer[Int] = a.toBuffer

toIndexedSeq

定义：

Scala 复制代码 
  def toIndexedSeq : scala.collection.immutable.IndexedSeq[A] = { /* compiled code */ }

描述：将序列转换成 IndexedSeq 类型

示例：

Scala 复制代码 
    val a = List(1,2,3,4)
    val seq: immutable.IndexedSeq[Int] = a.toIndexedSeq

toIterable

定义：

Scala 复制代码 
  override def toIterable : scala.collection.Iterable[A] = { /* compiled code */ }

描述：将序列转换成【可重复迭代】的类型

示例：

Scala 复制代码 
    val a = List(1,2,3,4)
    val iterable: Iterable[Int] = a.toIterable

toIterator

定义：

Scala 复制代码 
  override def toIterator : scala.collection.Iterator[A] = { /* compiled code */ }

描述：将序列转换成迭代器，同 iterator 方法

示例：

Scala 复制代码 
    val a = List(1,2,3,4)
    val iterator: Iterator[Int] = a.toIterator

toList

定义：

Scala 复制代码 
  override def toList : scala.List[A] = { /* compiled code */ }

描述：将序列转换成 List 类型

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    val list: List[Int] = a.toList

toMap

定义：

Scala 复制代码 
  def toMap[T, U](implicit ev : _root_.scala.Predef.<:<[A, scala.Tuple2[T, U]]) : scala.collection.immutable.Map[T, U] = { /* compiled code */ }

描述：将序列转转换成 Map 类型，需要被转化序列中包含的元素是 Tuple2 类型

示例：

Scala 复制代码 
    val a = Array((1,"a"),(2,"b"),(3,"c"),(4,"d"))
    val map: Map[Int, String] = a.toMap

toSeq

定义：

Scala 复制代码 
  override def toSeq : scala.collection.Seq[A] = { /* compiled code */ }

描述：将序列转换成 Seq 类型

示例：

Scala 复制代码 
    val a = Array((1,"a"),(2,"b"),(3,"c"),(4,"d"))
    val seq: Seq[(Int, String)] = a.toSeq

toSet

定义：

Scala 复制代码 
  def toSet[B >: A] : scala.collection.immutable.Set[B] = { /* compiled code */ }

描述：将序列转换成 Set 类型

示例：

Scala 复制代码 
    val a = Array((1,"a"),(2,"b"),(3,"c"),(4,"d"))
    val set: Set[(Int, String)] = a.toSet

toStream

定义：

Scala 复制代码 
  override def toStream : scala.collection.immutable.Stream[A] = { /* compiled code */ }

描述：将序列转换成 Stream 类型

Scala 复制代码 
    val a = Array((1,"a"),(2,"b"),(3,"c"),(4,"d"))
    val stream: Stream[(Int, String)] = a.toStream

toVector

定义：

Scala 复制代码 
  def toVector : scala.Vector[A] = { /* compiled code */ }

描述：将序列转换成 Vector 类型

示例：

Scala 复制代码 
    val a = Array((1,"a"),(2,"b"),(3,"c"),(4,"d"))
    val vector: Vector[(Int, String)] = a.toVector

transpose

定义：

Scala 复制代码 
  def transpose[U](implicit asArray : scala.Function1[T, scala.Array[U]]) : scala.Array[scala.Array[U]] = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(Array(11,12,13),Array(21,22,23))
    val transpose: Array[Array[Int]] = a.transpose
    transpose.foreach(x=>println(x.mkString(",")))

seq

定义：

Scala 复制代码 
  def seq : scala.collection.mutable.IndexedSeq[T] = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    val seq: mutable.IndexedSeq[Int] = a.seq
    println(seq)

unzip

定义：

Scala 复制代码 
  def unzip[T1, T2](implicit asPair : scala.Function1[T, scala.Tuple2[T1, T2]], ct1 : scala.reflect.ClassTag[T1], ct2 : scala.reflect.ClassTag[T2]) : scala.Tuple2[scala.Array[T1], scala.Array[T2]] = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array((1,2),(3,4),(5,6))
    val unzip: (Array[Int], Array[Int]) = a.unzip
    println("元组的_1 : "+unzip._1.toList)
    println("元组的_2 : "+unzip._2.toList)

unzip3

定义：

Scala 复制代码 
  def unzip3[T1, T2, T3](implicit asTriple : scala.Function1[T, scala.Tuple3[T1, T2, T3]], ct1 : scala.reflect.ClassTag[T1], ct2 : scala.reflect.ClassTag[T2], ct3 : scala.reflect.ClassTag[T3]) : scala.Tuple3[scala.Array[T1], scala.Array[T2], scala.Array[T3]] = { /* compiled code */ }

描述：将含有三个三元组的数组，每个元组的第一个元素组成一个数组，第二个元素组成一个数组，第三个元素组成一个数组，返回包含这三个数组的元组

示例：

Scala 复制代码 
    val a = Array((1,2,3),(4,5,6),(7,8,9))
    val unzip: (Array[Int], Array[Int], Array[Int]) = a.unzip3
    println("元组的_1 : "+unzip._1.toList)
    println("元组的_2 : "+unzip._2.toList)
    println("元组的_3 : "+unzip._3.toList)

zipWithIndex

定义：

Scala 复制代码 
  override def zipWithIndex[A1 >: A, That](implicit bf : scala.collection.generic.CanBuildFrom[Repr, scala.Tuple2[A1, scala.Int], That]) : That = { /* compiled code */ }

描述：序列中的每个元素和它的索引组成一个元组数组

示例：

Scala 复制代码 
    val a = Array('a','b','c')
    val index: Array[(Char, Int)] = a.zipWithIndex
    println(index.mkString(","))

11.工具类函数

addString(b)

定义：

Scala 复制代码 
  def addString(b : scala.StringBuilder) : scala.StringBuilder = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3)
    val b = new StringBuilder
    a.addString(b)
    println(b)

addString(b, sep)

定义：

Scala 复制代码 
  def addString(b : scala.StringBuilder, sep : _root_.scala.Predef.String) : scala.StringBuilder = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3)
    val b = new StringBuilder
    a.addString(b,",")
    println(b)

distinct

定义：

Scala 复制代码 
  def distinct : Repr = { /* compiled code */ }

描述：去除当前集合中重复的元素，只保留一个,返回去重后的集合

示例：

Scala 复制代码 
    val a = Array(1,2,3,2,1)
    val distinct: Array[Int] = a.distinct
    println(distinct.toList)

indices

定义：

Scala 复制代码 
  def indices : scala.collection.immutable.Range = { /* compiled code */ }

描述：返回当前序列索引集合

示例：

Scala 复制代码 
    val a = Array(1,2,3,2,1)
    val indices: Range = a.indices
    println(indices)

padTo

定义：

Scala 复制代码 
  def padTo[B >: A, That](len : scala.Int, elem : B)(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

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

示例：填充一个长度为 7 的序列，不足位补 0，填充长度为 2 返回原序列

Scala 复制代码 
    val a = Array(1,2,3)
    val ints: Array[Int] = a.padTo(7, 0)
    val ints1: Array[Int] = a.padTo(2, 0)
    println(ints.toList)
    println(ints1.toList)

prefixLength

定义：

Scala 复制代码 
  def prefixLength(p : scala.Function1[A, scala.Boolean]) : scala.Int = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,2,1)
    val i: Int = a.prefixLength(x => x < 3)
    println(i)

mkString

定义：

Scala 复制代码 
  def mkString : _root_.scala.Predef.String = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,2,1)
    println(a.mkString)

mkString(sep)

定义：

Scala 复制代码 
  def mkString(sep : _root_.scala.Predef.String) : _root_.scala.Predef.String = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,2,1)
    println(a.mkString(","))

mkString(start, sep, end)

定义：

Scala 复制代码 
  def mkString(start : _root_.scala.Predef.String, sep : _root_.scala.Predef.String, end : _root_.scala.Predef.String) : _root_.scala.Predef.String = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,2,1)
    println(a.mkString("(",",",")"))

length

定义：

Scala 复制代码 
  def length : scala.Int = { /* compiled code */ }

描述：返回序列元素个数

示例：

Scala 复制代码 
    val a = Array(1,2,3,2,1)
    val length: Int = a.length
    println(length)

lengthCompare

定义：

Scala 复制代码 
  override def lengthCompare(len : scala.Int) : scala.Int = { /* compiled code */ }

描述：比较序列的长度和参数 len，返回：序列的长度 length- 参数len

示例：

Scala 复制代码 
val a = Array(1, 2, 3, 4)
println(a.lengthCompare(3)) // 1
println(a.lengthCompare(4)) // 0
println(a.lengthCompare(5)) // -1

size

定义：

Scala 复制代码 
  override def size : scala.Int = { /* compiled code */ }

描述：返回序列元素个数，同 length

示例：

Scala 复制代码 
    val a = Array(1, 2, 3, 4)
    val size: Int = a.size
    println(size)

stringPrefix

定义：

Scala 复制代码 
  def stringPrefix : _root_.scala.Predef.String = { /* compiled code */ }

描述：返回 toString 结果的前缀

示例：

Scala 复制代码 
    val a = List(1,2,3)
    println(a.toString())
    println(a.stringPrefix)

12.集合内与集合间计算函数

aggregate

定义：

Scala 复制代码 
  def aggregate[B](z : => B)(seqop : scala.Function2[B, A, B], combop : scala.Function2[B, B, B]) : B = { /* compiled code */ }

描述：聚合计算，aggregate 是柯里化方法，参数是两个方法

示例：为了方便理解，把 aggregate 的两个参数分别封装成两个方法，并把分区和不分区的计算过程分别打印出来

Scala 复制代码 
    def seq(m:Int,n:Int):Int={
      println("seq:"+m+"+"+n)
      m+n
    }
    def combine(m:Int,n:Int):Int={
      println("combine:"+m+"+"+n)
      m+n
    }
    val a = Array(1,2,3,4)
    println("不分区情形：")
    val i: Int = a.aggregate(5)(seq, combine) //不分区
    println("不分区的 i = "+i)
    println("===================================")
    println("分区情形：")
    val i1: Int = a.par.aggregate(5)(seq, combine) //分区
    println("分区的 i1 = "+i1)

通过上面的运算不难发现，不分区时，seqno 是把初始值顺序和每个元素相加，把得到的结果与下一个元素进行运算。

分区时，seqno 是把初始值与每个元素相加，但结果不参与下一步运算，而是放到另一个序列中，由第二个方法 combine 进行处理。

上面过程可以简写为

Scala 复制代码 
val b = a.aggregate(5)(_+_,_+_) // 不分区
val c = a.par.aggregate(5)(_+_,_+_) // 分区

fold

定义：

Scala 复制代码 
  def fold[U >: T](z : U)(op : scala.Function2[U, U, U]) : U = { /* compiled code */ }

描述：对序列中的每个元素进行二元运算，和 aggregate 有类似的语义，但执行过程有所不同，fold类的函数，分区内的计算逻辑就是分区间的计算逻辑，而aggregate却可以指定分区内的计算逻辑与分区间的计算逻辑，此外，fold方法要求聚合的两者类型相同【map聚合时会被当做元组】，而foldLeft和foldRight则不必

示例：

Scala 复制代码 
    def seq(m:Int,n:Int):Int={
      println("seq:"+m+"+"+n)
      m+n
    }
    val a = Array(1,2,3,4)
    println("不分区情形：")
    val i: Int = a.fold(5)(seq) //不分区
    println("不分区的 i = "+i)
    println("===================================")
    println("分区情形：")
    val i1: Int = a.par.fold(5)(seq) //分区
    println("分区的 i1 = "+i1)

foldLeft 可简写为 /:

定义：

Scala 复制代码 
  def foldLeft[S](z : S)(op : scala.Function2[S, T, S]) : S = { /* compiled code */ }

描述：从左到右计算，简写方式：

示例：

Scala 复制代码 
    def seq(m:Int,n:Int):Int={
      println("seq:"+m+"+"+n)
      m+n
    }
    val a = Array(1,2,3,4)
    val i: Int = a.foldLeft(5)(seq) // 也可简写：(5 /: a)(_ + _)
    println("i = "+i)

foldRight 可简写为 :/

定义：

Scala 复制代码 
  override def foldRight[B](z : B)(op : scala.Function2[A, B, B]) : B = { /* compiled code */ }

描述：从右到左计算，简写方式：

示例：

Scala 复制代码 
    def seq(m:Int,n:Int):Int={
      println("seq:"+m+"+"+n)
      m+n
    }
    val a = Array(1,2,3,4)
    val i: Int = a.foldRight(5)(seq) // 也可简写：(a :/ 5)(_ + _)
    println("i = "+i)

reduce

定义：

描述：不需要初始值，在集合内部进行聚合运算

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    val i: Int = a.reduce((x,y)=>{
      println("seq:"+x+"+"+y)
      x+y
    })
    println("i = "+i)

reduceLeft

Scala 复制代码 
    val a = Array(1,2,3,4)
    val i: Int = a.reduceLeft((x,y)=>{
      println("seq:"+x+"+"+y)
      x+y
    })
    println("i = "+i)

定义：

Scala 复制代码 
  override def reduceLeft[B >: A](op : scala.Function2[B, A, B]) : B = { /* compiled code */ }

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

示例：

reduceRight

定义：

Scala 复制代码 
  override def reduceRight[B >: A](op : scala.Function2[A, B, B]) : B = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    val i: Int = a.reduceRight((x,y)=>{
      println("seq:"+x+"+"+y)
      x+y
    })
    println("i = "+i)

reduceLeftOption

定义：

Scala 复制代码 
  def reduceLeftOption[B >: A](op : scala.Function2[B, A, B]) : scala.Option[B] = { /* compiled code */ }

描述：同 reduceLeft，返回 Option

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    val i: Option[Int] = a.reduceLeftOption((x, y) => {
      println("seq:" + x + "+" + y)
      x + y
    })
    println("i = "+i)

reduceRightOption

定义：

Scala 复制代码 
  def reduceRightOption[B >: A](op : scala.Function2[A, B, B]) : scala.Option[B] = { /* compiled code */ }

描述：同 reduceRight，返回 Option

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    val i: Option[Int] = a.reduceRightOption((x, y) => {
      println("seq:" + x + "+" + y)
      x + y
    })
    println("i = "+i)

scan

定义：

Scala 复制代码 
  def scan[B >: A, That](z : B)(op : scala.Function2[B, B, B])(implicit cbf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    val i: Array[Int] = a.scan(5)((x, y) => {
      println("seq:" + x + "+" + y)
      x + y
    })
    println("i = "+i.mkString("(",",",")"))

scanLeft

定义：

Scala 复制代码 
  def scanLeft[B, That](z : B)(op : scala.Function2[B, A, B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    val i: Array[Int] = a.scanLeft(5)((x, y) => {
      println("seq:" + x + "+" + y)
      x + y
    })
    println("i = "+i.mkString("(",",",")"))

scanRight

定义：

Scala 复制代码 
  def scanRight[B, That](z : B)(op : scala.Function2[A, B, B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3,4)
    val i: Array[Int] = a.scanRight(5)((x, y) => {
      println("seq:" + x + "+" + y)
      x + y
    })
    println("i = "+i.mkString("(",",",")"))

diff

定义：

Scala 复制代码 
  def diff[B >: A](that : scala.collection.GenSeq[B]) : Repr = { /* compiled code */ }

描述：计算当前数组与另一个数组的差集，即将当前数组中没有在另一个数组中出现的元素返回

示例：

Scala 复制代码 
    val a = Array(1,2,3)
    val b = Array(2,3,4)
    val a_diff_b: Array[Int] = a.diff(b)
    println(a_diff_b.toList)

intersect

定义：

Scala 复制代码 
  def intersect[B >: A](that : scala.collection.GenSeq[B]) : Repr = { /* compiled code */ }

描述：取两个集合的交集

示例：

Scala 复制代码 
    val a = Array(1,2,3)
    val b = Array(2,3,4)
    val a_intersect_b: Array[Int] = a.intersect(b)
    println(a_intersect_b.toList)

union

定义：

Scala 复制代码 
  override def union[B >: A, That](that : scala.collection.GenSeq[B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3)
    val b = Array(2,3,4)
    val a_union_b: Array[Int] = a.union(b)
    println(a_union_b.toList)

zip

定义：

Scala 复制代码 
  override def zip[A1 >: A, B, That](that : scala.collection.GenIterable[B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, scala.Tuple2[A1, B], That]) : That = { /* compiled code */ }

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

示例：

Scala 复制代码 
    val a = Array(1,2,3)
    val b = Array(2,3,4)
    val a_zip_b: Array[(Int, Int)] = a.zip(b)
    println(a_zip_b.toList)

zipAll

定义：

Scala 复制代码 
  def zipAll[B, A1 >: A, That](that : scala.collection.GenIterable[B], thisElem : A1, thatElem : B)(implicit bf : scala.collection.generic.CanBuildFrom[Repr, scala.Tuple2[A1, B], That]) : That = { /* compiled code */ }

描述：同 zip ，但是允许两个序列长度不同，不足的自动填充，如果当前序列短，不足的元素填充为 thisElem，如果 that 序列短，填充为 thatElem

示例：

Scala 复制代码 
    val a = Array(1,2,3,4,5)
    val b = Array(2,3,4)
    val a_zipAll_b: Array[(Int, Int)] = a.zipAll(b,1,0)
    println(a_zipAll_b.toList)
    val b_zipAll_a: Array[(Int, Int)] = b.zipAll(a,1,0)
    println(b_zipAll_a.toList)
相关推荐
万物得其道者成几秒前
React Zustand状态管理库的使用
开发语言·javascript·ecmascript
学步_技术6 分钟前
Python编码系列—Python抽象工厂模式：构建复杂对象家族的蓝图
开发语言·python·抽象工厂模式
wn53130 分钟前
【Go - 类型断言】
服务器·开发语言·后端·golang
Hello-Mr.Wang42 分钟前
vue3中开发引导页的方法
开发语言·前端·javascript
救救孩子把1 小时前
Java基础之IO流
java·开发语言
WG_171 小时前
C++多态
开发语言·c++·面试
宇卿.1 小时前
Java键盘输入语句
java·开发语言
希冀1231 小时前
【操作系统】1.2操作系统的发展与分类
后端
Amo Xiang1 小时前
2024 Python3.10 系统入门+进阶（十五）：文件及目录操作
开发语言·python
friklogff1 小时前
【C#生态园】提升C#开发效率：深入了解自然语言处理库与工具
开发语言·c#·区块链
热门推荐
01RAG 实践- Ollama+RagFlow 部署本地知识库02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）032024年高教社杯数学建模国赛C题超详细解题思路分析04Coze扣子平台完整体验和实践（附国内和国际版对比）05苍穹外卖面试总结06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）08CCF-CSP认证考试 202406-3 文本分词 100分题解09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10浏览器插件——ModHeader 的分享和学习