Scala数组常用函数（1）

目录

前言：

一.map/foreach

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

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

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

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

六.def addString(b: StringBuilder): StringBuilder 

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

八.def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

def mkString(seq:String)

def mkString(statrt:String,seq:String,end:String)

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

十.def apply(i: Int): T 

十一.def charAt(index: Int): Char 

十二.def clone(): Array[T] 

十三.def collect[B](pf: [A, B]): Array[B] 

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

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

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

 十七.def copyToArray(xs: Array[A]): Unit 

十八.def copyToBuffer[B >: A](dest: Buffer[B]): Unit 

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

 ​编辑

二十.def count(p: (T) ⇒ Boolean): Int 

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

二十二.def distinct: Array[T] 

二十三.def drop(n: Int): Array[T] 

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

二十四.def dropWhile(p: (T) ⇒ Boolean): Array[T] 

二十五.def endsWith[B](that: GenSeq[B]): Boolean 

二十六.def exists(p: (T) ⇒ Boolean): Boolean 

二十七.def filter(p: (T) ⇒ Boolean): Array[T] 

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

二十八.def find(p: (T) ⇒ Boolean): Option[T] 

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

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

三十一.-def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1 

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

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

三十二.-def forall(p: (T) ⇒ Boolean): Boolean 

三十三.-def groupBy[K](f: (T) ⇒ K): Map[K, Array[T]] 

三十四.-def grouped(size: Int): collection.Iterator[Array[T]] 

三十五.-def hasDefiniteSize: Boolean

三十六.-def head: T

三十七.-def indexOf(elem: T): Int 

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

三十八.-def indexOfSlice[B >: A](that: GenSeq[B]): Int

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

三十九.-def indexWhere(p: (T) ⇒ Boolean): Int 

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

四十.-def indices: collection.immutable.Range

四十一.-def init: Array[T] 

四十二.-def inits: collection.Iterator[Array[T]] 

 四十三.-def intersect(that: collection.Seq[T]): Array[T] 

四十四.-def isDefinedAt(idx: Int): Boolean 

四十五.-def isEmpty: Boolean 

---

前言：

Scala数组的函数有很多个，需要熟练掌握的必要性很大，便于我们以后能想到用这个方法去完成什么功能。再初识scala的时候发现这些函数或者说是语法比java的要难很多，需要花时间去理解以及背下来。（背下来划重点！）

一.map/foreach

遍历，差别在于map有返回值，foreach没有返回值

图中是利用map将数组中的每个元素乘与2 然后返回一个新的数组给res102

foreach也可以 实际也不改变数组的值 而且还要手动输出

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

合并集合（下面的arr沿用了之前定义的1,2,3,4）

就是++就是方法 所以下面两种表达式都可以 上面那种只是简写

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

该函数是为了合并集合 但我们发现

简写情况下右边操纵数的类型决定着返回结果的类型 不简写情况下左边操纵数的类型决定返回结果的类型 这是因为在scala语法中简写的时候 如果方法是冒号结尾 那么后面才是调用方法的对象

下面的+：或者：+也是这个道理！

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

在数组前面添加一个元素，并返回新的对象，这个的话，就记住冒号永远是对着数组吧！

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

6在前面的较好理解 就是6在最前面 然后每个元素取出来执行+ - * / 操作

其实可以这么理解：每次运算都有两个参数 左边的参数是上一次运算的返回结果 右边是你这次要运算的参数 所以首先6+1 然后7+2...

6在后面的话 也是一样的道理 （这里的arr是1,2,3,4）首先取出4-6 然后3-（-2） 然后2-5

1-（-3）这样 所以减的结果是4

六.def addString(b: StringBuilder): StringBuilder 

addString就是把集合里的数字或者字符或者字符串都连接起来

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

八.def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

def mkString(seq:String)

def mkString(statrt:String,seq:String,end:String)

addString是使用指定字符串将集合分割

mkString是将字符串按照指定字符串分割成各个字符

假如a是“scala”

mkString和addString比较类似  他们都可以对集合操作 但是addString必须要有Stringbuiler这个参数 返回结果也是StringBuilder 而mkString返回结果是String

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

聚合计算，aggregate是柯里化函数，参数是两个函数，为了方便理解，我们把aggregate的两个参数，分别封装成两个函数，并把计算过程打印出来。

可以这么理解，par开启了多个线程：首先seqno让a的每个参数和5相加

  def main(args: Array[String]) {
    val a = List(1,2,3,4)
    val c = a.par.aggregate(5)(seqno,combine)
    println("c:"+c)
  }
  def seqno(m:Int,n:Int): Int ={
    val s = "seq_exp=%d+%d"
    println(s.format(m,n))
    return m+n
  }
  def combine(m:Int,n:Int): Int ={
    val s = "com_exp=%d+%d"
    println(s.format(m,n))
    return m+n
  }
  /**
    seq_exp=5+3
    seq_exp=5+2
    seq_exp=5+4
    seq_exp=5+1
    com_exp=6+7
    com_exp=8+9
    com_exp=13+17
    c:30
    可以直接简化成val c = a.par.aggregate(5)(_+_,_+_)
  */

十.def apply(i: Int): T 

和arr（2）一样 取出指定索引处元素

但是用在Array.apply上意义又不一样 其实我们的创建数组就是调用了apply 只不过省略了apply：

 所以 var a=Array(1,2,3) 其实是简写了apply

十一.def charAt(index: Int): Char 

也是指定索引处元素 但是只能应用于字符型的集合或者数组

就比如arr（1，2，3，4）调用charAt就会报错

十二.def clone(): Array[T] 

整体克隆 把arr全部赋值到res149上

十三.def collect[B](pf: [A, B]): Array[B] 

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

   val chars = Array('a','b','c')
   val newchars = chars.collect(fun)
   println("newchars:"+newchars.mkString(","))
  //我们通过下面的偏函数，把chars数组的小写a转换为大写的A
  val fun:PartialFunction[Char,Char] = {
    case 'a' => 'A'
    case x => x
  }
  /**输出结果是 newchars:A,b,c */

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

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

val arr = Array(1,'a',"b")
//定义一个偏函数，要求当被执行对象为Int类型时，进行乘100的操作，对于上面定义的对象arr来说，只有第一个元素符合要求
  val fun:PartialFunction[Any,Int] = {
    case x:Int => x*100
  }
//计算
  val value = arr.collectFirst(fun)
  println("value:"+value)
//另一种写法
val value = arr.collectFirst({case x:Int => x*100})

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

排列组合，这个排列组合会选出所有包含字符不一样的组合，对于 “abc”、“cba”，只选择一个，参数n表示序列长度，就是几个字符为一组

    val arr = Array("a","b","c")
    val newarr = arr.combinations(2)
    newarr.foreach((item) => println(item.mkString(",")))
    /**
    a,b
    a,c
    b,c
    */

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

序列中是否包含指定对象

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

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

 十七.def copyToArray(xs: Array[A]): Unit 

先新建一个相同类型数组（这里不能为空 要指定类型创建 就会有默认值！）

a的元素复制到b数组 有多少复制多少 首先是只有一个参数的：

 两个参数的，第二参数是复制到数组的什么位置，有多少个复制多少个：

三个参数的，第二个参数是复制到数组的什么位置，第三个参数是复制几个的意思

 

十八.def copyToBuffer[B >: A](dest: Buffer[B]): Unit 

将数组中的内容拷贝到Buffer中

    val a = Array('a', 'b', 'c')
    val b:ArrayBuffer[Char]  = ArrayBuffer()
    a.copyToBuffer(b)
    println(b.mkString(","))

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

判断两个序列长度是否相等并且每个对应位置元素是否符合某个条件。

下面就是判断arr和b的数组长度是否相等和arr对应位置的元素是否都小于b的

有一者不满足就返回false

 

二十.def count(p: (T) ⇒ Boolean): Int 

统计符合条件的元素个数

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

就是返回差集，我有的你没有

arr是1,2,3 arr2是2,3,4所以1是arr独有的 返回一个数组 元素为1

 

二十二.def distinct: Array[T] 

去除当前集合中重复的元素，只保留一个（distinct后面没有括号，不然就会报错）

二十三.def drop(n: Int): Array[T] 

将当前序列中前 n 个元素去除后，作为一个新序列返回

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

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

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

二十四.def dropWhile(p: (T) ⇒ Boolean): Array[T] 

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

//下面去除大于2的，第一个元素 3 满足，它后面的元素 2 不满足，所以返回 2,3,4
val a = Array(3, 2, 3,4)
val c = a.dropWhile( {x:Int => x > 2} )
println(c.mkString(","))
 
//如果数组 a 是下面这样，第一个元素就不满足，所以返回整个数组 1, 2, 3,4
val a = Array(1, 2, 3,4) 

二十五.def endsWith[B](that: GenSeq[B]): Boolean 

判断是否以某个序列结尾

二十六.def exists(p: (T) ⇒ Boolean): Boolean 

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

二十七.def filter(p: (T) ⇒ Boolean): Array[T] 

过滤出来符合条件的元素组成新的数组

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

和上面filter相反 过滤掉符合条件的

二十八.def find(p: (T) ⇒ Boolean): Option[T] 

查找第一个符合条件的元素

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

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

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

每次取数组的一个元素作为函数的参数 最后把得到的数组压平 也就是全部展开成一维

比如下面的res45：把1,2,3分别加1 加2然后把三个数组压成一个数组输出

res46：把1到1,1到2,1到3的所有数都取出来

1     1 2      1 2 3 然后展开成一个数组输出

三十一.-def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1 

对序列中的每个元素进行二元运算，和aggregate有类似的语义，但执行过程有所不同，我们来对比一下他们的执行过程。 
因为aggregate需要两个处理方法，所以我们定义一个combine方法

  def seqno(m:Int,n:Int): Int ={
    val s = "seq_exp=%d+%d"
    println(s.format(m,n))
    return m+n
  }
  def combine(m:Int,n:Int): Int ={
    val s = "com_exp=%d+%d"
    println(s.format(m,n))
    return m+n
  }
    val a = Array(1, 2, 3,4)
    val b = a.fold(5)(seqno)
    /** 运算过程
    seq_exp=5+1
    seq_exp=6+2
    seq_exp=8+3
    seq_exp=11+4
    */
    val c = a.par.aggregate(5)(seqno,combine)
    /** 运算过程
    seq_exp=5+1
    seq_exp=5+4
    seq_exp=5+3
    com_exp=8+9
    seq_exp=5+2
    com_exp=6+7
    com_exp=13+17
    */

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

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

  def seqno(m:Int,n:Int): Int ={
    val s = "seq_exp=%d+%d"
    println(s.format(m,n))
    return m+n
  }
    val a = Array(1, 2, 3,4)
    val b = a.foldLeft(5)(seqno)
    /** 运算过程
    seq_exp=5+1
    seq_exp=6+2
    seq_exp=8+3
    seq_exp=11+4
    */
    /**
    简写 (5 /: a)(_+_)
    */

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

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

  def seqno(m:Int,n:Int): Int ={
    val s = "seq_exp=%d+%d"
    println(s.format(m,n))
    return m+n
  }
    val a = Array(1, 2, 3,4)
    val b = a.foldRight(5)(seqno)
    /** 运算过程
    seq_exp=4+5
    seq_exp=3+9
    seq_exp=2+12
    seq_exp=1+14
    */
    /**
    简写 (a :\ 5)(_+_)
    */

三十二.-def forall(p: (T) ⇒ Boolean): Boolean 

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

三十三.-def groupBy[K](f: (T) ⇒ K): Map[K, Array[T]] 

按条件分组，条件由 f 匹配，返回值是Map类型，每个key对应一个序列，下面代码实现的是，把小于3的数字放到一组，大于3的放到一组，返回Map[String,Array[Int]]

    val a = Array(1, 2, 3,4)
    val b = a.groupBy( x => x match {
      case x if (x < 3) => "small"
      case _ => "big"
    })

三十四.-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
*/

三十五.-def hasDefiniteSize: Boolean

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

三十六.-def head: T

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

三十七.-def indexOf(elem: T): Int 

返回elem在序列中的索引，找到第一个就返回

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

返回elem在序列中的索引，可以指定从某个索引处（from）开始查找，找到第一个就返回

没找到就返回-1

三十八.-def indexOfSlice[B >: A](that: GenSeq[B]): Int

检测当前序列中是否包含另一个序列（that），并返回第一个匹配出现的元素的索引

类型也要匹配

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

检测当前序列中是否包含另一个序列（that），并返回第一个匹配出现的元素的索引，指定从 from 索引处开始

三十九.-def indexWhere(p: (T) ⇒ Boolean): Int 

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

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

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

四十.-def indices: collection.immutable.Range

返回当前序列索引集合

四十一.-def init: Array[T] 

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

    val a = Array(10, 2, 3, 40, 5)
    val b = a.init
    println(b.mkString(","))    // 10, 2, 3, 40

四十二.-def inits: collection.Iterator[Array[T]] 

 每次init把它作为新数组 最后全部放入List

 四十三.-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

四十四.-def isDefinedAt(idx: Int): Boolean 

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

四十五.-def isEmpty: Boolean 

判断当前序列是否为空

函数（2）：Scala数组常用函数（2）_后季暖的博客-CSDN博客