scala 数组函数大全（143个1个不漏，全面案例详解）

最新推荐文章于 2022-10-30 00:07:53 发布

BigData_Hubert

最新推荐文章于 2022-10-30 00:07:53 发布

阅读量3.9k

点赞数 6

分类专栏：大数据文章标签： scala scala array 数组函数大全数组方法大数据

本文链接：https://blog.csdn.net/BigData_Hobert/article/details/108437748

版权

scala系列

scala 数组函数大全

scala系列
前言
一、scala 数组简介
二、思维导图
三、数组函数汇总
四、数组函数详解

前言

本篇博客为大家带来的是 scala 所有（没错，没有看错，就是所有）数组函数的案例详解大全。scala的主要优势是它的表达性。没错,相比于java而言,scala可以用更少的代码"优雅"地表达出我们所想。所以,scala足以成为我们程序员必须涉猎的语言之一。scala 数组函数是 scala 能够实现代码飘逸的核心基础所在，因此在 scala 入门的时候必须强记下来，没有任何商量的余地。

相信大家在看完的数组函数汇总后，都能够代码敲的飘逸！“so easy”

在这里插入图片描述

一、scala 数组简介

数组是一种可变的、可索引的数据集合。在Scala中用Array[T]的形式来表示Java中的数组形式 T[]。

val numbers = Array(1, 2, 3, 4) //声明一个数组对象
val first = numbers(0) // 读取第一个元素
numbers(3) = 100 // 替换第四个元素为100
val biggerNumbers = numbers.map(_ * 2) // 所有元素乘2

查看方法：

在 window DOS 窗口，输入 scala 进入scala命令行
随意定义一个数组：val arr = Array(1,2,3,4)
输入： arr. + Tab 键即可显示scala所有数组、集合函数，如下图所示：

scala> val a = Array(1,2)
a: Array[Int] = Array(1, 2)

scala> a.
++              count            hasDefiniteSize      maxBy               sameElements    toBuffer
++:             deep             head                 min                 scan            toIndexedSeq
+:              diff             headOption           minBy               scanLeft        toIterable
/:              distinct         indexOf              mkString            scanRight       toIterator
:+              drop             indexOfSlice         nonEmpty            segmentLength   toList
:\              dropRight        indexWhere           orElse              seq             toMap
addString       dropWhile        indices              padTo               size            toSeq
aggregate       elemManifest     init                 par                 slice           toSet
andThen         elemTag          inits                partition           sliding         toStream
apply           endsWith         intersect            patch               sortBy          toTraversable
applyOrElse     exists           isDefinedAt          permutations        sortWith        toVector
array           filter           isEmpty              prefixLength        sorted          transform
canEqual        filterNot        isTraversableAgain   product             span            transpose
clone           find             iterator             reduce              splitAt         union
collect         flatMap          last                 reduceLeft          startsWith      unzip
collectFirst    flatten          lastIndexOf          reduceLeftOption    stringPrefix    unzip3
combinations    fold             lastIndexOfSlice     reduceOption        sum             update
companion       foldLeft         lastIndexWhere       reduceRight         tail            updated
compose         foldRight        lastOption           reduceRightOption   tails           view
contains        forall           length               repr                take            withFilter
containsSlice   foreach          lengthCompare        reverse             takeRight       zip
copyToArray     genericBuilder   lift                 reverseIterator     takeWhile       zipAll
copyToBuffer    groupBy          map                  reverseMap          to              zipWithIndex
corresponds     grouped          max                  runWith             toArray

scala> a.

数组的泛型：

[B>: A] 表示B 是A的超类
[B <: A] 表示B 是A的子类

二、思维导图

在这里插入图片描述

三、数组函数汇总

++	count	hasDefiniteSize	maxBy	sameElements	toBuffer
++:	deep	head	min	scan	toIndexedSeq
+:	diff	headOption	minBy	scanLeft	toIterable
/:	distinct	indexOf	mkString	scanRight	toIterator
:+	drop	indexOfSlice	nonEmpty	segmentLength	toList
:\	dropRight	indexWhere	orElse	seq	toMap
addString	dropWhile	indices	padTo	size	toSeq
aggregate	elemManifest	init	par	slice	toSet
andThen	elemTag	inits	partition	sliding	toStream
apply	endsWith	intersect	patch	sortBy	toTraversable
applyOrElse	exists	isDefinedAt	permutations	sortWith	toVector
array	filter	isEmpty	prefixLength	sorted	transform
canEqual	filterNot	isTraversableAgain	product	span	transpose
clone	find	iterator	reduce	splitAt	union
collect	flatMap	last	reduceLeft	startsWith	unzip
collectFirst	flatten	lastIndexOf	reduceLeftOption	stringPrefix	unzip3
combinations	fold	lastIndexOfSlice	reduceOption	sum	update
companion	foldLeft	lastIndexWhere	reduceRight	tail	updated
compose	foldRight	lastOption	reduceRightOption	tails	view
contains	forall	length	repr	take	withFilter
containsSlice	foreach	lengthCompare	reverse	takeRight	zip
copyToArray	genericBuilder	lift	reverseIterator	takeWhile	zipAll
copyToBuffer	groupBy	map	reverseMap	to	zipWithIndex
corresponds	grouped	max	runWith	toArray	subSequence

四、数组函数详解

方法名：++
源码定义：

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

描述：合并两个序列(序列为空，必须指定泛型)，若序列类型不同以左边序列类型为主；若泛型类型不同以两个序列共同的最小父类为结果类型；结果元素是在A序列元素后面添加B序列的元素。

返回值：左边序列类型，最小父类序列泛型类型

示例：

scala> val a = Array(1,2)
a: Array[Int] = Array(1, 2)

scala> val b = Array("a",1)
b: Array[Any] = Array(a, 1)

scala> a ++ b
res103: Array[Any] = Array(1, 2, a, 1)

// 若泛型类型不同以两个序列共同的最小父类为结果类型
scala> val c = Array(1.0,2.3)
c: Array[Double] = Array(1.0, 2.3)

scala> a ++ c
res104: Array[AnyVal] = Array(1, 2, 1.0, 2.3)

scala> val d = List(1,2)
d: List[Int] = List(1, 2)

// 若序列类型不同以左边序列类型为主
scala> a ++ d
res1: Array[Int] = Array(1, 2, 1, 2)

scala> d ++ a
res2: List[Int] = List(1, 2, 1, 2)

方法名：++:
源码定义：

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

描述：合并两个序列，若类型不同以右边类型为主。其他和 ++ 一样。
返回值：右边序列类型
示例：

scala> val a = Array(1,2,3)
a: Array[Int] = Array(1, 2, 3)

scala> val b = Array(4,5,6)
b: Array[Int] = Array(4, 5, 6)

scala> val c = List(7,8,9)
c: List[Int] = List(7, 8, 9)

scala> val d = a ++: b
d: Array[Int] = Array(1, 2, 3, 4, 5, 6)

scala> val d = a ++: c
d: List[Int] = List(1, 2, 3, 7, 8, 9)

scala> val d = c ++: a
d: Array[Int] = Array(7, 8, 9, 1, 2, 3)

方法名：+:
源码定义：

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

描述：在数组前面添加一个元素(添加的元素在前，就在数组头部添加，冒号要离数组近)，结果泛型类型取元素类型和数组类型的共同最小父类。
返回值：数组
示例：

scala> val a = Array(1,2,3)
a: Array[Int] = Array(1, 2, 3)

scala> val b = 1 +: a
b: Array[Int] = Array(1, 1, 2, 3)

scala> val b = "a" +: a
b: Array[Any] = Array(a, 1, 2, 3)

方法名：/:
源码定义：

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

描述：对数组中所有的元素从左向右遍历，进行相同的迭代操作，foldLeft 的简写(冒号要离数组近)；相当于左二叉树。
返回值：计算结果
示例：

scala> val a = List(1, 2, 3, 4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = (10 /: a) (_ + _) 		// (((10+1)+2)+3)+4
b: Int = 20

scala> val c = (10 /: a) (_ * _) 		// (((10*1)*2)*3)*4
c: Int = 240

scala> val d = ("a" /: a) (_ * _) 		// 1*2*3*4个a
d: String = aaaaaaaaaaaaaaaaaaaaaaaa

方法名：:+
源码定义：

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

描述：在数组后面添加一个元素(添加的元素在后，就在数组尾部添加，冒号要离数组近)；和 +: 相反
返回值：数组
示例：

scala> val a = Array(1,2,3)
a: Array[Int] = Array(1, 2, 3)

scala> val b = a :+ 1
b: Array[Int] = Array(1, 2, 3, 1)

方法名：:\
源码定义：

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

描述：对数组中所有的元素从右向左遍历，进行相同的迭代操作，foldRight 的简写(冒号要离数组近)；相当于右二叉树。
返回值：计算结果
示例：

scala> val a = List(1, 2, 3, 4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = (a :\ 10) (_ - _) 		// 1-(2-(3-(4-10)))
b: Int = 8

scala> val c = (a :\ 10) (_ * _) 		// 1*(2*(3*(4*10)))
c: Int = 240

scala> val d = (a \: "a") (_ + _) 		// 注意和 val d = ("a" /: a) (_ + _) 的区别
<console>:12: error: value \: is not a member of String
       val d = (a \: "a") (_ + _) // (((10*1)*2)*3)*4

方法名：addString
源码定义：

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

描述：将数组中的元素逐个添加到StringBuilder中
返回值： StringBuilder
示例：

scala> var a = new StringBuilder()
a: StringBuilder =

scala> val b = Array(1,2,3)
b: Array[Int] = Array(1, 2, 3)

//def addString(b: StringBuilder): StringBuilder 		将数组中的元素逐个添加到b中
scala> b.addString(a)
res3: StringBuilder = 123

scala> var a = new StringBuilder()
a: StringBuilder =

//def addString(b: StringBuilder, sep: String): StringBuilder 		将数组中的元素逐个添加到b中，每个元素用sep分隔符分开
scala> b.addString(a,",")
res5: StringBuilder = 1,2,3

scala> var a = new StringBuilder()
a: StringBuilder =

//def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder 		将数组中的元素逐个添加到b中，在首尾各加一个字符串，并指定sep分隔符
scala> b.addString(a,"{",",","}")
res6: StringBuilder = {
   1,2,3}

方法名：aggregate
源码定义：

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

描述：aggregate是柯里化方法（将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数）， aggregate 方法是一个聚合函数，接受多个输入，并按照一定的规则运算以后输出一个结果值
返回值：
示例：

def seqno(m: Int, n: Int): Int = {
   
  val s = "seq_exp = %d + %d"
  println(s.format(m, n))
  m + n
}

def combine(m: Int, n: Int): Int = {
   
  val s = "com_exp = %d + %d"
  println(s.format(m, n))
  m + n
}

def main(args: Array[String]) {
   
  val a = List(1, 2, 3, 4)

  val b = a.aggregate(5)(seqno, combine) 		// 不分区
  println("b = " + b)
  /*
   * seq_exp = 5 + 1
   * seq_exp = 6 + 2
   * seq_exp = 8 + 3
   * seq_exp = 11 + 4
   * b = 15
   */
   
   // List元素数量为偶数
  val c = a.par.aggregate(5)(seqno, combine) 		// 分区
  println("c = " + c)
  /*
   * 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 d = List(1, 2, 3)
  // List元素数量为奇数
  val e = a.par.aggregate(5)(seqno, combine) 		// 分区
  println("c = " + c)
  /*
   * seq_exp = 5 + 3
   * seq_exp = 5 + 2
   * seq_exp = 5 + 1
   * com_exp = 6 + 7
   * com_exp = 8 + 13
   * c = 21
   */
}

方法名：andThen
源码定义：

override def andThen[C](k : scala.Function1[B, C]) : scala.PartialFunction[A, C] = {
    /* compiled code */ }

描述：表示方法的连续调用，相当于嵌套函数 g(f(x)) （需满足第一个函数的返回值类型是第二个函数的输入值类型），与 compose 相反。
返回值：
示例：

def f(a:Int) = {
   
 println("2*"+a)
 2*a
}

def g(b:Int) = {
   
 println("3*"+b)
 3*b
}

def  result1 = f _ andThen g _
println(result1(1))
/*
2*1
3*2
6
*/
def  result2 = f _ compose  g _
println(result2(1))
/*
3*1
2*3
6
*/

方法名：apply
源码定义：

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

描述：按下标取数组数据
返回值：数组中的元素类型
示例：

scala> val a = Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> a.apply(2)  				//等同于直接写a(2)
res14: Int = 3

scala> a(2)
res15: Int = 3

方法名：applyOrElse
源码定义：

 def applyOrElse[A1 <: A, B1 >: B](x : A1, default : scala.Function1[A1, B1]) : B1 = {
    /* compiled code */ }

描述：接收2个参数，第一个是调用的参数，第二个是个回调函数。如果第一个调用的参数匹配，返回匹配的值，否则调用回调函数。（回调函数的输入类型需与调用参数类型一致），就相当于if-else分支调用函数。
返回值：
示例：

scala> val pf1:PartialFunction[Int,String] = {
      		//定义一个偏函数，输入 1 返回 "one"
     | case i if i == 1 => "One"
     | }
pf1: PartialFunction[Int,String] = <function1>

scala> pf1.applyOrElse(1,{
   num:Int=>"two"})  		//输入1匹配到"one"
res16: String = One

scala> pf1.applyOrElse(2,{
   num:Int=>"two"})  		//输入2匹配失败则触发回调函数，返回 "Two" 字符串
res17: String = two

方法名：array
描述： Array是scala中数组是用来存储同类型的元素结构，数组中本身size不可变，但是数组中元素可变，可重新赋值
返回值：
示例：

//声明一个String类型的数组
scala> var arr:Array[String] = new Array[String](3)  		//长度为3，未赋值：null  null null
arr: Array[String] = Array(null, null, null)

scala> var arr = new Array[String](3)  						//长度为3，未赋值：null  null null
arr: Array[String] = Array(null, null, null)

scala> var arr1 = Array("java","scala","python")   			//长度为3，赋值："java","scala","python"
arr1: Array[String] = Array(java, scala, python)

//添加、修改元素
scala> arr(0) = "java"

scala> arr(1) = "scala"

scala> arr(2) = "python"

//索引
scala> arr(0)
res21: String = java

scala> arr(1)
res22: String = scala

scala> arr(2)
res23: String = python

//遍历打印
scala> arr.foreach(println)
java
scala
python

方法名：canEqual
源码定义：

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

描述：判断两个对象是否可以进行比较(基本上都可以比较)
返回值： boolean
示例：

scala> val a = Array(1,2,3)
a: Array[Int] = Array(1, 2, 3)

scala> val b = List(4,5,6)
b: List[Int] = List(4, 5, 6)

scala> val c = "hello"
c: String = hello

scala> val d = 5
d: Int = 5

scala> a.canEqual(b)
res25: Boolean = true

scala> a.canEqual(c)
res26: Boolean = true

scala> a.canEqual(d)
res27: Boolean = true

方法名：clone
源码定义：

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

描述：创建一个数组的副本，复制数组的值,但不会引用地址；就是说是浅克隆，不是深克隆。
返回值：数组
示例：

scala> val a = Array(1,2,3)
a: Array[Int] = Array(1, 2, 3)

scala> val b = Array(4,5,a)
b: Array[Any] = Array(4, 5, Array(1, 2, 3))

scala> val c = b.clone()
c: Array[Any] = Array(4, 5, Array(1, 2, 3))

scala> c(2).asInstanceOf[Array[Int]](0) = 5

scala> a
res43: Array[Int] = Array(5, 2, 3)

scala> c
res44: Array[Any] = Array(4, 5, Array(5, 2, 3))

方法名：collect
源码定义：

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

描述：输入参数类型为偏函数，对序列中的元素进行转换（通过执行一个并行计算（偏函数），得到一个新的数组对象）
返回值：
示例：

scala> val a = Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> val fun:PartialFunction[Int,Int]={
   
     | case x if x%2==0 => x+2
     | case x => x+1
     | }
fun: PartialFunction[Int,Int] = <function1>

scala> a.collect(fun)
res45: Array[Int] = Array(2, 4, 4, 6)

scala> val fun:PartialFunction[Int,Int]={
   
     | case x if x%2==0 => x+2
     | case _ => 1
     | }
fun: PartialFunction[Int,Int] = <function1>

scala> a.collect(fun)
res46: Array[Int] = Array(1, 4, 1, 6)

方法名：collectFirst
源码定义：

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

描述：查找序列中第一个符合偏函数的元素执行相应操作
返回值： Option类型
示例：定义一个偏函数，当被执行对象为 int类型时，执行+1

// 方法一
scala> val fun: PartialFunction[Any, Int] = {
   
     |   case x: Int => x + 1
     | }
fun: PartialFunction[Any,Int] = <function1>

scala> val a = Array('a',1,3, "A")
a: Array[Any] = Array(a, 1, 3, A)

scala> val b = a.collectFirst(fun)
b: Option[Int] = Some(2)

scala> b.get
res48: Int = 2

// 方法二
scala> a.collectFirst({
   case x: Int => x + 1}).get
res49: Int = 2

方法名：combinations
源码定义：

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

描述：排列组合l列出所有包含字符不一样的组合，不考虑顺序，参数n表示每个组合的序列长度。(如对于 “ab”、“ba”，视为相同组合)
返回值：
示例：

scala

最低0.47元/天解锁文章