scala数组函数合集

news2024/11/27 12:48:06

目录

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 数组的 基础操作:

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. 添加类函数 

        ++

        定义

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

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

        演示:

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

        ++:

        定义:

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

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

        示例:Array 和 List 结合,返回结果是 List 类型

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

        +:

        定义:

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

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

        示例:

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

        :+

        定义:

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

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

        示例:

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

2.生成类函数

        clone

        定义:

  override def clone() : scala.Array[T] = { /* compiled code */ }

        描述:克隆,创建一个副本

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

    var a = Array(1,2,3)
    var b = a
    var c = a.clone
    a(0) = 0
    println(b.toList)
    println(c.toList)

        collect

        定义:

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

        描述:通过执行一个并行计算(偏函数),得到一个新的数组对象

        示例:通过下面的偏函数(参数只能是偏函数),把数组中的1转换为“a”

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

        collectFirst

        定义:

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

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

        示例:

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

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

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

        combinations

        定义:

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

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

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

        permutations

        定义:

  def permutations : scala.collection.Iterator[Repr] = { /* compiled code */ }

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

        示例:

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

        copyToArray(xs)

        定义:

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

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

        示例:

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

        

        copyToArray(arr, start)

        定义:

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

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

        示例:

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

        copyToArray(arr, start, len)

        定义:

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

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

        示例:

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

        copyToBuffer

        定义:

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

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

        示例:

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

3.删除类函数

        drop

        定义:

  override def drop(n : scala.Int) : Repr = { /* compiled code */ }

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

        示例:

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

        dropRight

        定义:

  override def dropRight(n : scala.Int) : Repr = { /* compiled code */ }

        描述:功能同 drop,去掉尾部的 n 个元素

        示例:

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

        dropWhile

        定义:

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

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

        示例:

    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

        定义:

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

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

        示例:

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

        last

        定义:

  override def last : A = { /* compiled code */ }

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

        示例:

    val a = Array(1,2,3,4,5,6)
    val last: Int = a.last
    println(last)

        lastIndexOf(elem)

        定义:

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

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

        示例:

    val a = Array(1,2,3,4,5,6)
    val index: Int = a.lastIndexOf(5)
    println(index)

        lastIndexOf(elem, end)

        定义:

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

        描述:返回元素 elem 在序列中最后一次出现的索引,指定在索引 end 之前(包括)的元素中查找

        示例:

    val a = Array(1,2,3,4,5,6,2,1)
    val index: Int = a.lastIndexOf(2,5)
    println(index)

        lastIndexOfSlice(that)

        定义:

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

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

        示例:

    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) 

        定义:

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

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

        示例:

    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

        定义:

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

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

        示例:

    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)

        定义:

  def lastIndexWhere(p : scala.Function1[A, scala.Boolean], end : scala.Int) : scala.Int

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

        示例:

    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

        定义:

  def lastOption : scala.Option[A] = { /* compiled code */ }

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

        示例:

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

 

        indexOf(elem)

        定义:

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

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

        示例:

    val a = Array(1,2,3,4,5,6,3,4,2,1)
    val i: Int = a.indexOf(2)
    println(i)

 


        indexOf(elem, from)

        定义:

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

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

        示例:

    val a = Array(1,2,3,4,5,6,3,4,2,1)
    val i: Int = a.indexOf(2,3)
    println(i)


        indexOfSlice(that)

        定义:

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

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

        示例:

    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)

        定义:

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

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

        示例:

    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

        定义:

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

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

        示例:

    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)

        定义:

  def indexWhere(p : scala.Function1[A, scala.Boolean], from : scala.Int) : scala.Int

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

        示例:

    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

        定义:

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

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

        示例:

    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

        定义:

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

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

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

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


        max

        定义:

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

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

        示例:

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


        maxBy

        定义:

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

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

        示例:

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

        min

        定义:

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

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

        示例:

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


        minBy

        定义:

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

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

        示例:

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


        product

        定义:

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

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

        示例:

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


        sum

        定义:

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

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

        示例:

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

6.修改类函数

        update

        定义:

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

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

        示例:

    val a = Array(1,2,3,4)
    a.update(1,0)
    println(a.toList)

        updated

        定义:

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

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

        示例:

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


        patch

        定义:

  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

    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

        定义:

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

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

        示例:

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


        containsSlice

        定义:

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

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

        示例:

    val a = Array(1,2,3,4)
    println(a.containsSlice(List(2,1)))
    println(a.containsSlice(List(1,2)))

        endsWith

        定义:

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

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

        示例:

    val a = Array(1,2,3,4)
    println(a.endsWith(List(3,4)))


        exists

        定义:

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

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

        示例:

    val a = Array(1,2,3,4)
    println(a.exists(x=>x>5))
    println(a.exists(x=>x==3))

        isDefinedAt

        定义:

  def isDefinedAt(idx : scala.Int) : scala.Boolean = { /* compiled code */ }

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

        示例:

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


        isEmpty

        定义:

  override def isEmpty : scala.Boolean = { /* compiled code */ }

        描述:判断序列是否为空

        示例:

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


        isTraversableAgain

        定义:

  final def isTraversableAgain : scala.Boolean = { /* compiled code */ }

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

        示例:

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


        forall

        定义:

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

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

        示例:

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


        nonEmpty

        定义:

  def nonEmpty : scala.Boolean = { /* compiled code */ }

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

        示例:

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


        sameElements

        定义:

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

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

        示例:

    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)

        定义:

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

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

        示例:

    val a = Array(1,2,3,4)
    println("a开头是否有 1,2:"+a.startsWith(Array(1,2)))


        startsWith(that, offset)

        定义:

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

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

        示例:

    val a = Array(1,2,3,4)
    println("a在 1 位置是否有 2,3:"+a.startsWith(Array(2,3),1))


        hasDefiniteSize

        定义:

  override def hasDefiniteSize : scala.Boolean = { /* compiled code */ }

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

        示例:

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


        canEqual

        定义:

  override def canEqual(that : scala.Any) : scala.Boolean = { /* compiled code */ }

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

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

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

        定义:

  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 中对应位置的元素

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

8.获取集合元素

        apply

        定义:

  def apply(i : scala.Int) : T = { /* compiled code */ }

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

        示例:

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


        charAt

        定义:

    def charAt(index : scala.Int) : scala.Char = { /* compiled code */ }

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

        示例:

    val a = Array('a','b','c')
    println(a.charAt(2))

        foreach

        定义:

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

        描述:遍历序列中的元素,进行 f 操作

        示例:

    val a = Array('a','b','c')
    a.foreach(println)


        head

        定义:

  override def head : A = { /* compiled code */ }

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

        示例:

    val a = Array('a','b','c')
    println(a.head)


        headOption

        定义:

  def headOption : scala.Option[A] = { /* compiled code */ }

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

        示例:

    val a = Array('a','b','c')
    println(a.headOption)


        init

        定义:

  override def init : Repr = { /* compiled code */ }

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

        示例:

    val a = Array('a','b','c')
    println(a.init.toList)

        inits

        定义:

  def inits : scala.collection.Iterator[Repr] = { /* compiled code */ }

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

        示例:

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


        tail

        定义:

  override def tail : Repr = { /* compiled code */ }

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

        示例:

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



        tails

        定义:

  def tails : scala.collection.Iterator[Repr] = { /* compiled code */ }

        描述:同 inits,每一步都进行 tail 操作

        示例:

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


        take

        定义:

  override def take(n : scala.Int) : Repr = { /* compiled code */ }

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

        示例:

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



        takeRight

        定义:

  override def takeRight(n : scala.Int) : Repr = { /* compiled code */ }

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

        示例:

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


        takeWhile

        定义:

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

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

        示例:

    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

        定义:

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

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

        示例:

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


9.集合操作类函数

        filter

        定义:

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

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

        示例:

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


        filterNot

        定义:

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

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

        示例:

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

        withFilter

        定义:

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

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

        示例:

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


        reverse

        定义:

  override def reverse : Repr = { /* compiled code */ }

        描述:反转序列,返回一个 Array 数组

        示例:

    val a = Array(1,2,3,4)
    val reverse: Array[Int] = a.reverse
    println(reverse.toList)

        reverseIterator

        定义:

  override def reverseIterator : scala.collection.Iterator[A] = { /* compiled code */ }

        描述:生成反向迭代器

        示例:

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

        par

        定义:

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

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

        示例:

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


        partition

        定义:

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

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

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

    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

        定义:

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

    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 个元素,返回一个迭代器

        示例:

    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 */ }

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

        示例:

    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 */ }

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

        示例:

    val a = Array(1,2,4,3)
    val sorted: Array[Int] = a.sorted
    println(sorted.toList)


        slice

        定义:

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

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

        示例:

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


        sliding(size)

        定义:

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

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

        示例:

    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)

        定义:

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

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

        示例:

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

 

        span

        定义:

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

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

        示例:

    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

        定义:

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

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

        示例:

    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

        定义:

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

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

        示例:

    val a = Array('a','b','c','d')
    val sequence: CharSequence = a.subSequence(1, 2)
    println(sequence)


10.转换类函数

        flatMap

        定义:

  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 及其子类,即返回可迭代的集合

        示例:

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


        flatten

        定义:

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

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

        示例:

    val a = Array(Array(1,2,3),Array(2,3,4))
    println(a.flatten.toList)

        iterator

        定义:

  override def iterator : scala.collection.Iterator[A] = { /* compiled code */ }

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

        示例:

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

        map

        定义:

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

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

        示例:

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

        reverseMap

        定义:

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

        描述:同 map,方向相反

        示例:

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

        toArray

        定义:

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

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

        示例:

    val a = List(1,2,3,4)
    val array: Array[Int] = a.toArray

 

        toBuffer

        定义:

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

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

        示例:

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

        toIndexedSeq

        定义:

  def toIndexedSeq : scala.collection.immutable.IndexedSeq[A] = { /* compiled code */ }

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

        示例:

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

 

        toIterable

        定义:

  override def toIterable : scala.collection.Iterable[A] = { /* compiled code */ }

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

        示例:

    val a = List(1,2,3,4)
    val iterable: Iterable[Int] = a.toIterable

        toIterator

        定义:

  override def toIterator : scala.collection.Iterator[A] = { /* compiled code */ }

        描述:将序列转换成迭代器,同 iterator 方法

        示例:

    val a = List(1,2,3,4)
    val iterator: Iterator[Int] = a.toIterator

        toList

        定义:

  override def toList : scala.List[A] = { /* compiled code */ }

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

        示例:

    val a = Array(1,2,3,4)
    val list: List[Int] = a.toList

        toMap

        定义:

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

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

        示例:

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

        toSeq

        定义:

  override def toSeq : scala.collection.Seq[A] = { /* compiled code */ }

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

        示例:

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

 

        toSet

        定义:

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

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

        示例:

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

 

        toStream

        定义:

  override def toStream : scala.collection.immutable.Stream[A] = { /* compiled code */ }

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

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

        toVector

        定义:

  def toVector : scala.Vector[A] = { /* compiled code */ }

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

        示例:

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

        transpose

        定义:

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

        描述:矩阵转置,二维数组行列转换

        示例:

    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

        定义:

  def seq : scala.collection.mutable.IndexedSeq[T] = { /* compiled code */ }

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

        示例:

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

 

        unzip

        定义:

  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 */ }

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

        示例:

    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

        定义:

  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 */ }

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

        示例:

    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

        定义:

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

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

        示例:

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

 

11.工具类函数

        addString(b)

        定义:

  def addString(b : scala.StringBuilder) : scala.StringBuilder = { /* compiled code */ }

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

        示例:

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

        addString(b, sep)

        定义:

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

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

        示例:

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

        distinct

        定义:

  def distinct : Repr = { /* compiled code */ }

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

        示例:

    val a = Array(1,2,3,2,1)
    val distinct: Array[Int] = a.distinct
    println(distinct.toList)

        indices

        定义:

  def indices : scala.collection.immutable.Range = { /* compiled code */ }

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

        示例:

    val a = Array(1,2,3,2,1)
    val indices: Range = a.indices
    println(indices)

        padTo

        定义:

  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 返回原序列

    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

        定义:

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

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

        示例:

    val a = Array(1,2,3,2,1)
    val i: Int = a.prefixLength(x => x < 3)
    println(i)


        mkString

        定义:

  def mkString : _root_.scala.Predef.String = { /* compiled code */ }

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

        示例:

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

        mkString(sep)

        定义:

  def mkString(sep : _root_.scala.Predef.String) : _root_.scala.Predef.String = { /* compiled code */ }

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

        示例:

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

        mkString(start, sep, end)

        定义:

  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 结尾

        示例:

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

        length

        定义:

  def length : scala.Int = { /* compiled code */ }

        描述:返回序列元素个数

        示例:

    val a = Array(1,2,3,2,1)
    val length: Int = a.length
    println(length)

 

        lengthCompare

        定义:

  override def lengthCompare(len : scala.Int) : scala.Int = { /* compiled code */ }

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

示例:

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

        size

        定义:

  override def size : scala.Int = { /* compiled code */ }

        描述:返回序列元素个数,同 length

        示例:

    val a = Array(1, 2, 3, 4)
    val size: Int = a.size
    println(size)

 

        stringPrefix

        定义:

  def stringPrefix : _root_.scala.Predef.String = { /* compiled code */ }

        描述:返回 toString 结果的前缀

        示例:

    val a = List(1,2,3)
    println(a.toString())
    println(a.stringPrefix)

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

        aggregate

        定义:

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

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

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

    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 进行处理。

        上面过程可以简写为

val b = a.aggregate(5)(_+_,_+_) // 不分区
val c = a.par.aggregate(5)(_+_,_+_) // 分区

        fold

        定义:

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

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

        示例:

    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 可简写为 /:

        定义:

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

        描述:从左到右计算,简写方式:

        示例:

    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 可简写为 :/

        定义:

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

        描述:从右到左计算,简写方式:

        示例:

    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

        定义:

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

        示例:

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

        reduceLeft

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

        定义:

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

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

        示例:

        reduceRight

        定义:

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

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

        示例:

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

        reduceLeftOption

        定义:

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

        描述:同 reduceLeft,返回 Option

        示例:

    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

        定义:

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

        描述:同 reduceRight,返回 Option

        示例:

    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

        定义:

  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 返回的是最后的结果

        示例:

    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

        定义:

  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,从左向右计算,每一步的计算结果放到一个新的集合中返回

        示例:

    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

        定义:

  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,从右向左计算,每一步的计算结果放到(从右向左放)一个新的集合中返回

        示例:

    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

        定义:

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

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

        示例:

    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

        定义:

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

        描述:取两个集合的交集

        示例:

    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

        定义:

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

        描述:合并两个序列,同操作符 ++

        示例:

    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

        定义:

  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 */ }

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

        示例:

    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

        定义:

  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

        示例:

    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)

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/1070326.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

C/C++ 进程间通信system V IPC对象超详细讲解(系统性学习day9)

目录 前言 一、system V IPC对象图解 1.流程图解&#xff1a; ​编辑 2.查看linux内核中的ipc对象&#xff1a; 二、消息队列 1.消息队列的原理 2.消息队列相关的API 2.1 获取或创建消息队列&#xff08;msgget&#xff09; 实例代码如下&#xff1a; 2.2 发送消息到消…

关于Jupyter markdown的使用

一级标题 #空格 标题1 二级标题 ## 空格 标题2 三级标题 ###空格 标题3 无序&#xff1b; 有序&#xff1a; 数学符号&#xff1a;

MySQL:主从复制-基础复制(6)

环境 主服务器 192.168.254.1 从服务器&#xff08;1&#xff09;192.168.254.2 从服务器&#xff08;2&#xff09;192.168.253.3 我在主服务器上执行的操作会同步至从服务器 主服务器 yum -y install ntp 我们去配置ntp是需要让从服务器和我们主服务器时间同步 sed -i /…

1.Linux入门基本指令

个人主页&#xff1a;Lei宝啊 愿所有美好如期而遇 目录 01.ls指令 02.pwd指令 03.cd指令 04.touch指令 05.mkdir指令(重要) 06.rmdir&&rm指令(重要) 07.man指令(重要) 08.cp指令(重要) 09.mv指令(重要) 10.cat指令 nano指令 echo指令 输出重定向 追加重…

day25--JS进阶(递归函数,深浅拷贝,异常处理,改变this指向,防抖及节流)

目录 浅拷贝 1.拷贝对象①Object.assgin() ②展开运算符newObj {...obj}拷贝对象 2.拷贝数组 ①Array.prototype.concat() ② newArr [...arr] 深拷贝 1.通过递归实现深拷贝 2.lodash/cloneDeep实现 3.通过JSON.stringify()实现 异常处理 throw抛异常 try/catch捕获…

强化学习------DQN算法

简介 DQN&#xff0c;即深度Q网络&#xff08;Deep Q-network&#xff09;&#xff0c;是指基于深度学习的Q-Learing算法。Q-Learing算法维护一个Q-table&#xff0c;使用表格存储每个状态s下采取动作a获得的奖励&#xff0c;即状态-价值函数Q(s,a)&#xff0c;这种算法存在很…

数据结构:链式二叉树

上一章讲了堆,堆是完全二叉树的顺序存储结构,本章将要全面讲解一下二叉树的链式存储结构即链式二叉树 我们已经学习了二叉树的概念和性质了,本章重点学习二叉树相关操作,可以更好的理解分治算法思想;也需要对递归有更深次的理解. 其实普通的链式二叉树的增删查改没有什么意义,…

COLLABORATIVE DESIGNER FOR SOLIDWORKS® 新功能

共享和标注 优点&#xff1a;收件人在浏览器中访问共享文 件&#xff0c;无需安装3DEXPERIENCE 平台应用程序。 • 与 SOLIDWORKS 中来自您组织内部或外部的任何人无缝 共享您的设计。 • 直接将评论和标注附加到您的设计作品中&#xff0c;便于立即获得 反馈。 支持 SOLIDWO…

深入理解强化学习——强化学习的基础知识

分类目录&#xff1a;《深入理解强化学习》总目录 在机器学习领域&#xff0c;有一类任务和人的选择很相似&#xff0c;即序贯决策&#xff08;Sequential Decision Making&#xff09;任务。决策和预测任务不同&#xff0c;决策往往会带来“后果”&#xff0c;因此决策者需要为…

Centos7安装MongoDB7.xxNoSQL数据库|设置开机启动(骨灰级+保姆级)

一: mongodb下载 MongoDB 社区免费下载版 MongoDB社区下载版 [rootwww tools]# wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-rhel70-7.1.0-rc4.tgz 二: 解压到指定目录 [rootwww tools]# mkdir -p /usr/local/mongodb [rootwww tools]# tar -zxvf mongodb-…

Linux目录和文件查看命令

一、Linux 的目录结构 Linux 的目录结构是一个树状结构&#xff0c;以根目录&#xff08;/&#xff09;为起点&#xff0c;以下是常见的 Linux 目录结构的主要内容&#xff1a; / 根路径 ├── bin: 存放系统指令&#xff08;命令&#xff09;&#xff0c;如ls、cp、mv等&…

ARM-流水灯

.text .global _start _start: 1、设置GPIOE寄存器的时钟使能 RCC_MP_AHB$ENSETR[4]->1 0x50000a28LDR R0,0X50000A28 LDR R1,[R0] 从R0起始地址的4字节数据取出放在R1 ORR R1,R1,#(0X3<<4) 第4位设置为1 STR R1,[R0] 写回2、设置PE10、PE8、PF10管脚为输出模式 …

Observability:使用 OpenTelemetry 对 Node.js 应用程序进行自动检测

作者&#xff1a;Bahubali Shetti DevOps 和 SRE 团队正在改变软件开发的流程。 DevOps 工程师专注于高效的软件应用程序和服务交付&#xff0c;而 SRE 团队是确保可靠性、可扩展性和性能的关键。 这些团队必须依赖全栈可观察性解决方案&#xff0c;使他们能够管理和监控系统&a…

学习记忆——数学篇——案例——算术——记忆100内质数

文章目录 质数表歌诀记忆法100以内的质数歌谣质数口决一百以内质数口诀100以内素数歌 规律记忆法100以内6的倍数前、后位置上的两个数&#xff0c;只要不是5或7的倍数&#xff0c;就一定是质数个数没有用该数除以包括7在内的质数 分类记忆法数字编码法谐音记忆法 100以内的质数…

Matlab随机变量的数字特征

目录 1、均值&#xff08;数学期望&#xff09; 2、中位数 3、几何平均数 4、调和平均数 5、数据排序 6、众数 7、极差&#xff08;最大值和最小值之差&#xff09; 8、方差与均方差&#xff08;标准差&#xff09; 9、变异系数 10、常见分布的期望与方差的计算 11、协方…

ElasticSearch 学习8 :ik分词器的扩展,及java调用ik分词器的analyzer

1.前言&#xff1a; 上篇已经说过ik的集成&#xff0c;这篇说下ik的实际使用 2.2、IK分词器测试 IK提供了两个分词算法ik_smart 和 ik_max_word ik_smart&#xff1a;为最少切分ik_max_word&#xff1a;为最细粒度划分。 2.2.1、最小切分示例 #分词器测试ik_smart POST _…

互联网项目有哪些值得做的

互联网已经融入了我们生活的方方面面&#xff0c;从电商巨头到科技创新&#xff0c;互联网带来的变革和便利无处不在。而在这个信息广泛的时代&#xff0c;越来越多的人开始思考如何利用互联网去创造价值。现如今&#xff0c;互联网项目的形式多种多样&#xff0c;有些让我们的…

剑指offer——JZ79 判断是不是平衡二叉树 解题思路与具体代码【C++】

一、题目描述与要求 判断是不是平衡二叉树_牛客题霸_牛客网 (nowcoder.com) 题目描述 输入一棵节点数为 n 二叉树&#xff0c;判断该二叉树是否是平衡二叉树。 在这里&#xff0c;我们只需要考虑其平衡性&#xff0c;不需要考虑其是不是排序二叉树 平衡二叉树&#xff08;…

【Java 进阶篇】深入了解HTML表单标签

HTML&#xff08;Hypertext Markup Language&#xff09;表单标签是网页开发中的重要组成部分&#xff0c;用于创建各种交互式元素&#xff0c;允许用户输入、提交和处理数据。本文将深入探讨HTML表单标签&#xff0c;包括如何创建表单、各种输入元素、表单属性以及一些最佳实践…

C++学习day2

作业&#xff1a; 1> 思维导图 2>自己封装一个矩形类(Rect)&#xff0c;拥有私有属性:宽度(width)、高度(height)&#xff0c; 定义公有成员函数: 初始化函数:void init(int w, int h) 更改宽度的函数:set_w(int w) 更改高度的函数:set_h(int h) 输出该矩形的周长和…