Scala---Array方法

创始人

2025-05-31 06:48:24

Scala之Array的方法

文章目录

Scala之Array的方法
数组
- 声明一个数组
- 1.元素操作
- - 替换数组元素
  - +:前添加元素
  - :+尾添加元素
  - combinations排列组合
  - distinct去重
  - drop删除
  - dropRight从右删除
  - dropWhile符合条件删除
  - max返回最大元素
  - min返回最小元素
  - maxBy返回符合条件的第一个
  - minBy返回不符合条件的第一个
  - padTo填充序列
  - patch批量替换
  - permutations排列
  - prefixLength返回元素数量
  - transform转换
  - update更新(改变原数组)
  - updated更新（不改变原数组）
- 2.元素取头尾
- - head返回第一个元素
  - headOption返回Option
  - last返回最后一个元素
  - lastOption返回Option
  - tail去除第一个元素
  - tails tail迭代操作
  - init去除尾元素
  - inits init 迭代操作
  - take按个数返回当前序列
  - takeRight从右开始返回当前序列
  - takeWhile按条件返回当前序列
- 3.下标索引操作
- - apply按数组下标访问
  - applyOrElse按数组下标返回
  - charAt获取索引处字符
  - indexOf(elem)返回元素索引
  - indexOfSlice(that)返回序列索引
  - indexWhere返回元素索引
  - lastIndexOf(elem: T)返回元素最后一次出现的索引
  - lastIndexOfSlice(that)返回序列索引
  - lastIndexWhere返回元素索引
  - indices返回索引集合
  - slice返回指定序列（前包后不包）
  - subSequence返回字符序列（前包后不包）
  - view返回序列（前包后不包）
- 4. 数组中的计算
- - fold折叠计算
  - /:foldLeft左到右方式计算
  - :\foldRigh右到左方式计算
  - product乘积
  - reduce二元计算
  - reduceLeft从左向右计算
  - reduceRight从右向左计算
  - reduceOption二元计算返回option
  - reduceLeftOption从左向右计算返回option
  - reduceRightOption从右向左计算返回option
  - scan折叠计算返回新集合
  - scanLeft从左向右计算返回新集合
  - scanRight从右向左计算返回新集合
  - sum求和
- 5.数组拆分排序
- - groupBy按条件分组
  - grouped分组
  - par并行计算
  - partition分组
  - span拆分数组
  - splitAt按序列拆分成两个数组
  - sliding(size)滑动
  - sortBy按规则排序
  - sorted排序
  - sortWith自定义排序
- 6. 数组长度
- - length返回元素个数
  - size返回元素个数
  - lengthCompare长度比较
  - segmentLength查找返回
- 7.两数组操作
- - ++合并数组操作
  - ++：合并数组操作
  - canEqual两数比较
  - corresponds元素比较
  - diff计算两数组差集
  - intersect计算两数组交集
  - union合并
  - sameElements值比较
- 8.数组克隆和复制
- - clone创建副本
  - copyToBuffer复制数组
  - seq序列
- 9.数组反转
- - reverse反转序列
  - reverseIterator反向迭代器
  - reverseMap反向操作
- 10.数组的行列操作
- - flatMap扁平化映射
  - flatten扁平化
  - transpose矩阵转置
  - unzip二元数组
  - unzip3三元数组
  - zip数组组合
  - zipAll数组组合
  - zipWithIndex元素和索引组成数组
- 11.字符串相关操作
- - addString 逐个添加元素
  - mkString拼接成字符串
  - stringPrefix返回前缀
- 12.方法操作
- - aggregate聚合操作
  - andThen方法连续调用（与 compose 相反）
  - collect 并行计算（偏函数）
  - collectFirst偏函数计算
  - compose方法连续调用（与 andThen 相反）
  - elemManifest返回集合元素的类型
  - elemTag返回集合元素的类型
  - foreach 遍历
  - iterator迭代
  - map操作返回新序列
  - runWith执行偏函数
- 13.指定条件判断
- - contains包含
  - containsSlice包含序列
  - count统计
  - endsWith判断结尾
  - startsWith判断开头
  - exists判断符合条件
  - filter过滤
  - filterNot过滤
  - withFilter条件过滤
  - find查找
  - forall全部满足
  - hasDefiniteSize检测有限长度
  - isDefinedAt判断指定索引
  - isEmpty判断为空
  - nonEmpty判断不为空
  - isTraversableAgain判断可以反复遍历
- 14.类型转换
- - toArray
  - toBuffer
  - toIndexedSeq
  - toIterable
  - toIterator
  - toList
  - toMap
  - toSeq
  - toSet
  - toStream
  - toVector

数组

第一种方式定义数组

val arr = new Array[Int](10)

（1）new 是关键字
（2）[Int]是指定可以存放的数据类型，如果希望存放任意数据类型，则指定 Any
（3）(10)，表示数组的大小，确定后就不可以变化

第二种方式定义数组

val arr = Array(1, 2)

（1）在定义数组时，直接赋初始值
（2）使用 apply 方法创建数组对象

声明一个数组

val a=Array(1,2,3)

1.元素操作

替换数组元素

a(0)=99 //替换第1个元素为99

在这里插入图片描述

+:前添加元素

def +:(elem: A): Array[A]
在数组前面添加一个元素，并返回新的对象，下面添加一个元素 0

    val a = List(1,2)val c = 0 +: ac.foreach(print) //0 1 2

在这里插入图片描述

:+尾添加元素

def :+(elem: A): Array[A]
同上面的方法想法，在数组末尾添加一个元素，并返回新对象

    val d = a :+ 66d.foreach(print)//1266

在这里插入图片描述

combinations排列组合

def combinations(n: Int): collection.Iterator[Array[T]]
排列组合，这个排列组合会选出所有包含字符不一样的组合
对于 “abc”、“cba”，只选择一个，参数n表示序列长度，就是几个字符为一组

    val arr = Array("a","b","c")val newarr = arr.combinations(2)/*a,ba,cb,c*///迭代器只能遍历一次newarr.foreach((item) => println(item.mkString(",")))//示例2val a1 =Array(1,2,3,4)a1.foreach(x=>print(x+"\t"));println()a1.combinations(4).foreach(x => {println(x.mkString("(", "-", ")"))})

在这里插入图片描述

distinct去重

def distinct: Array[T]
去除当前集合中重复的元素

    var a= Array(1,1,2)a.foreach(x=>print(x+"\t"))println()println("========去重后")a.distinct.foreach(x=>print(x+"\t"))

在这里插入图片描述

drop删除

def drop(n: Int): Array[T]
删掉前n个元素，返回一个新数组

    var a= Array(1,1,2)a.foreach(x=>print(x+"\t"))println()println("========删除前两个后")a.drop(2).foreach(x=>print(x+"\t"))

在这里插入图片描述

dropRight从右删除

def dropRight(n: Int): Array[T]
删掉后n个元素，返回一个新数组

    var a= Array(1,1,2)a.foreach(x=>print(x+"\t"))println()println("========删除后一个")a.drop(1).foreach(x=>print(x+"\t"))

在这里插入图片描述

dropWhile符合条件删除

def dropWhile(p: (T) ⇒ Boolean): Array[T]
从第一个符合的元素开始删除满足条件的元素，若第一个元素就不符合条件则不做任何删除操作，即返回整个数组

 //下面去除大于2的，第一个元素 3 满足，它后面的元素 2 不满足，所以返回 2,3,4val 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)

在这里插入图片描述

max返回最大元素

def max: A
返回序列中最大的元素

    var array = Array(1, 2, 3, 5, 7)array.foreach(x=>print(x+"\t"));println()println(array.max)

在这里插入图片描述

min返回最小元素

def min: A
返回序列中最小的元素

    var array = Array(1, 2, 3, 5, 7)array.foreach(x=>print(x+"\t"));println()println(array.min)

在这里插入图片描述

maxBy返回符合条件的第一个

def maxBy[B](f: (A) ⇒ B): A
返回序列中符合条件的第一个元素

    var array = Array(1, 2, 3, 5, 7)array.foreach(x=>print(x+"\t"));println()println(array.maxBy(_>4))

在这里插入图片描述

minBy返回不符合条件的第一个

def minBy[B](f: (A) ⇒ B): A
返回序列中不符合条件的第一个元素

    var array = Array(1, 2, 3, 5, 7)array.foreach(x=>print(x+"\t"));println()println(array.minBy(_>4))

在这里插入图片描述

padTo填充序列

def padTo(len: Int, elem: A): Array[A]
填充序列，如果当前序列长度小于 len，那么新产生的序列长度是 len，多出的几个位值填充 elem，如果当前序列大于等于 len ，则返回当前序列

    var array = Array(1, 2, 3, 5, 7)array.foreach(x=>print(x+"\t"));println()//序列为8位，不满足用*替代array.padTo(8,"*").foreach(x=>print(x+"\t"))println()//当前序列大于len,返回当前序列array.padTo(4,"*").foreach(x=>print(x+"\t"))

在这里插入图片描述

patch批量替换

def patch(from: Int, that: GenSeq[A], replaced: Int): Array[A]
批量替换，从原序列的 from 处开始，后面的 replaced 个元素，将被替换成序列 that；如果替换的为空集合或双引号，则为删除操作

    var b1 = Array(1, 2, 3, 5, 7)b1.foreach(x => print(x + "\t"));println()var i: Array[Int] = Array() //空集合会报错，用这种形式b1.patch(0, Array(12, 13, 14), 3).foreach(x => print(x + "\t"));println()b1.patch(2, Array(12, 13, 14), 2).foreach(x => print(x + "\t"));println()b1.patch(3, i, 1).foreach(x => print(x + "\t"));println()b1.patch(3, i, 2).foreach(x => print(x + "\t"));println()b1.patch(3, "", 2).foreach(x => print(x + "\t"));println()

在这里插入图片描述

permutations排列

def permutations: collection.Iterator[Array[T]]
permutations 表示排列，这个排列组合会选出所有排列顺序不同的字符组合，permutations 与 combinations 不同的是，相同的组合考虑排列，对于 “abc”、“cba”，视为不同的组合

    val a1 =Array(1,2,3,4)a1.foreach(x=>print(x+"\t"));println()a1.permutations.foreach(x => {println(x.mkString("(", "-", ")"))})

在这里插入图片描述

prefixLength返回元素数量

def prefixLength(p: (T) ⇒ Boolean): Int
由第一个索引开始，返回序列中满足条件p的元素数量，直到有不满足的则结束

    val a1 =Array(6,7,8,34,89,32)a1.foreach(x=>print(x+"\t"));println()println(a1.prefixLength(_<2))println(a1.prefixLength(_<30))

在这里插入图片描述

transform转换

def transform(f: Int => Int): scala.collection.mutable.WrappedArray[Int]
将序列中的元素转换成指定的元素（同类型），原数组会被改变

    val a1 =Array(6,7,5,8,10,11)a1.foreach(x => print(x + "\t"));println()//排序，并求平方a1.sorted.transform(Math.pow(_,2).toInt).foreach(x => print(x + "\t"));println()

在这里插入图片描述

update更新(改变原数组)

def update(i: Int, x: T): Unit
将序列中 i 索引处的元素更新为 x，改变原数组，返回更改后的新数组

    val a1 =Array(6,7,8,34,89,32)a1.foreach(x=>print(x+"\t"));println()a1.update(3,10)a1.foreach(x=>print(x+"\t"));println()

在这里插入图片描述

updated更新（不改变原数组）

def updated(index: Int, elem: A): Array[A]
将序列中 i 索引处的元素更新为 x，不改变原数组

    val a1 =Array(6,7,8,34,89,32)//更新后a1.updated(3,10).foreach(x=>print(x+"\t"))println()//原数组a1.foreach(x=>print(x+"\t"))

在这里插入图片描述

2.元素取头尾

head返回第一个元素

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

    val a1 =Array(6,7,5,8,10,11)println(a1.head)//6

headOption返回Option

def headOption: Option[T]
返回序列的第一个元素的 Option 类型对象，如果序列为空，则返回 None

    val a:Array[Int] = Array()val a1 =Array(6,7,5,8,10,11)a1.foreach(x => print(x + "\t"));println()println(a1.headOption)println(a.headOption)

在这里插入图片描述

last返回最后一个元素

def last: T
返回序列的最后一个元素，如果序列为空，将引发错误

    val a1 =Array(6,7,5,8,10,11)a1.foreach(x => print(x + "\t"));println()println(a1.last)

在这里插入图片描述

lastOption返回Option

def lastOption: Option[T]
返回序列的最后一个元素的 Option 类型对象，如果序列为空，则返回 None

    val a:Array[Int] = Array()val a1 =Array(6,7,5,8,10,11)a1.foreach(x => print(x + "\t"));println()println(a1.lastOption)println(a.lastOption)

在这里插入图片描述

tail去除第一个元素

def tail: Array[T]
返回当前序列中不包含第一个元素的序列，除了头都是尾

    val a1 =Array(6,7,5,8,10,11)a1.foreach(x => print(x + "\t"));println()a1.tail.foreach(x=>print(x+"\t"));println()

在这里插入图片描述

tails tail迭代操作

def tails: collection.Iterator[Array[T]]
和inits类似，只不过每一步都是取尾部进行 tail 操作

    val a1 =Array(6,7,5,8,10,11)a1.foreach(x => print(x + "\t"));println()a1.tails.foreach(x=>{x.foreach(y=>print(s"$y "));println()})

在这里插入图片描述

init去除尾元素

def init: Array[T]
返回当前序列中不包含最后一个元素的序列

    val a1 =Array(6,7,5,8,10,11)a1.foreach(x => print(x + "\t"));println()a1.init.foreach(x => print(x + "\t"));println()

在这里插入图片描述

inits init 迭代操作

def inits: collection.Iterator[Array[T]]
对集合中的元素进行 init 迭代操作，该操作的返回值中，第一个值是当前序列的副本，最后一个值为空，每一步都进行 init 操作，上一步的结果作为下一步的操作对象；返回一个二维数组

    val a1 =Array(6,7,5,8,10,11)a1.foreach(x => print(x + "\t"));println()a1.inits.foreach(x=>{x.foreach(y=>print(s"$y "));println()})

在这里插入图片描述

take按个数返回当前序列

def take(n: Int): Array[T]
返回当前序列中，前 n 个元素组成的序列

    val a1 =Array(6,7,5,8,10,11)a1.foreach(x => print(x + "\t"));println()a1.take(3).foreach(x => print(x + "\t"));println()

在这里插入图片描述

takeRight从右开始返回当前序列

def takeRight(n: Int): Array[T]
返回当前序列中，从右边开始，后 n 个元素组成的序列

    val a1 =Array(6,7,5,8,10,11)a1.foreach(x => print(x + "\t"));println()a1.takeRight(3).foreach(x => print(x + "\t"))

在这里插入图片描述

takeWhile按条件返回当前序列

def takeWhile(p: (T) ⇒ Boolean): Array[T]
返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列，如果第一个值不满足，则返回空，不管后面的元素了

    val a1 =Array(6,7,5,8,10,11)a1.foreach(x => print(x + "\t"));println()println("第一个元素不满足==========")a1.takeWhile(_>9).foreach(x => print(x + "\t"));println()println("==========")a1.takeWhile(_>5).foreach(x => print(x + "\t"));println()

在这里插入图片描述

3.下标索引操作

apply按数组下标访问

def apply(i: Int): T
按下标取数组数据同a(i)
注意：数组越界

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

在这里插入图片描述

applyOrElse按数组下标返回

定义：def applyOrElse[A1 <: A, B1 >: B](x : A1, default : scala.Function1[A1, B1]) : B1 = { /* compiled code */ }
如果第一个调用的参数能匹配，返回匹配的值，否则调用参数二的回调函数
根据下标提取,若下标越界默认返回参数2函数的返回值

//数组1-4var a1=Array.range(1,5) //1	2	3	4a1.foreach(x=>print(x+"\t"))println()//数组下标为10 数组越界 返回200println(a1.applyOrElse(10, { i: Int => 200 }))//数组下标为4 返回数组下标相应的数 4println(a1.applyOrElse(3, { i: Int => 200 }))

在这里插入图片描述

charAt获取索引处字符

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

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

在这里插入图片描述

indexOf(elem)返回元素索引

def indexOf(elem: T): Int
def indexOf(elem: T, from: Int): Int
返回元素 elem 在序列中第一次出现的索引，【指定从索引 from 开始查找】

    val a1 =Array(6,7,5,8,10,11)a1.foreach(x => print(x + "\t"));println()println(a1.indexOf(2))println(a1.indexOf(8))

在这里插入图片描述

indexOfSlice(that)返回序列索引

def indexOfSlice[B >: A](that: GenSeq[B]): Int
def indexOfSlice[B >: A](that: GenSeq[B], from: Int): Int
检测当前序列中是否包含序列 that，并返回第一次出现该序列的索引，找不到返回-1；并且指定索引可以超出元素索引的范围，【指定从索引 from 开始查找，并返回第一次出现该序列】

    val a1 =Array(6,7,5,8,10,11)a1.foreach(x => print(x + "\t"));println()println(a1.indexOfSlice(Array(5,8)))println(a1.indexOfSlice(Array(1,2)))

在这里插入图片描述

indexWhere返回元素索引

def indexWhere(p: (T) ⇒ Boolean): Int
def indexWhere(p: (T) ⇒ Boolean, from: Int): Int
返回当前序列中第一个满足条件 p 的元素的索引【，指定从索引 from 开始查找】

    val a1 =Array(6,7,5,8,10,11)a1.foreach(x => print(x + "\t"));println()println(a1.indexWhere(_==6))println(a1.indexWhere(_>9))println(a1.indexWhere(_>9,5))

在这里插入图片描述

lastIndexOf(elem: T)返回元素最后一次出现的索引

def lastIndexOf(elem: T): Int
def lastIndexOf(elem: T, end: Int): Int
返回元素 elem 在序列中最后一次出现的索引【，指定在索引 end 之前（包括）的元素中查找】

    val a1 =Array(6,7,5,8,8,10,11)a1.foreach(x => print(x + "\t"));println()println(a1.lastIndexOf(8))

在这里插入图片描述

lastIndexOfSlice(that)返回序列索引

def lastIndexOfSlice[B >: A](that: GenSeq[B]): Int
检测当前序列中是否包含序列 that，并返回最后一次出现该序列的索引【，指定在索引 end 之前（包括）的元素中查找】

    val a1 =Array(6,7,5,8,5,8,10,11)a1.foreach(x => print(x + "\t"));println()println(a1.lastIndexOfSlice(Array(5,8)))

在这里插入图片描述

lastIndexWhere返回元素索引

def lastIndexWhere(p: (T) ⇒ Boolean, end: Int): Int
返回当前序列中最后一个满足条件 p 的元素的索引，指定在索引 end 之前（包括）的元素中查找

    val a1 =Array(6,7,5,8,5,8,10,11)a1.foreach(x => print(x + "\t"));println()println(a1.lastIndexWhere(_>5))

在这里插入图片描述

indices返回索引集合

def indices: collection.immutable.Range
返回当前序列索引集合

    val a1 =Array(6,7,5,8,5,8,10,11)a1.foreach(x => print(x + "\t"));println()a1.indices.foreach(x=>print(x+"\t"));println()

在这里插入图片描述

slice返回指定序列（前包后不包）

def slice(from: Int, until: Int): Array[T]
返回当前序列中从 from 到 until 之间的序列，不包括 until 处的元素

    val a1 =Array(6,7,5,8,5,8,10,11)a1.foreach(x => print(x + "\t"));println()a1.slice(2,4).foreach(x => print(x + "\t"));println()

在这里插入图片描述

subSequence返回字符序列（前包后不包）

def subSequence(start: Int, end: Int): CharSequence
返回 start 和 end 间的字符序列，不包含 end 处的元素，(返回 start 和 end 间的字符序列只针对char类型(前包后不包))

    val a =Array('a','b','c','d')a.foreach(x => print(x + "\t"));println()println(a.subSequence(1,3))

在这里插入图片描述

view返回序列（前包后不包）

def view(from: Int, until: Int): IndexedSeqView[T, Array[T]]
返回当前序列中从 from 到 until 之间的序列，不包括 until 处的元素。对于数组的操作有点像slice，前包后不包

    val a1 =Array(6,7,5,8,5,8,10,11)a1.foreach(x => print(x + "\t"));println()a1.view(2,4).foreach(x => print(x + "\t"));println()println(a1.view(2,4))

在这里插入图片描述

4. 数组中的计算

fold折叠计算

def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1ClassTag[U]): Array[U]
对序列中的每个元素进行二元运算，和 aggregate 有类似的语义，但执行过程有所不同
aggregate的简化版

    var a2 = Array(1,1,2)a2.foreach(x=>print(x+"\t"))println()val add = (x:Int,y:Int)=>{var z=x+yprintln(s"$x+$y=$z")z}println(a2.fold(0)(add))

在这里插入图片描述

/:foldLeft左到右方式计算

def /:[B](z: B)(op: (B, T) ⇒ B): B
对数组中所有的元素进行相同的操作，foldLeft的简写

    val a = List(1,2,3,4)val c = (5 /: a)(_+_)  println("c:"+c)//过程---完整写法val d =(5 /:a)((x,y)=>{println(x,y);x+y})println("d:"+d)

在这里插入图片描述

:\foldRigh右到左方式计算

def :[B](z: B)(op: (T, B) ⇒ B): B
foldRight的简写

    val e = (a :\ 5)(_+_)  // 1+2+3+4+10println("e:"+e)val f =(a :\ 5)((x,y)=>{println(x,y);x+y})println("f:"+f)

在这里插入图片描述

product乘积

def product: A
返回所有元素乘积的值

    var a=Array(1,2,3)a.foreach(x=>print(x+"\t"));println()println(a.product)

在这里插入图片描述

reduce二元计算

def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1
对序列中的每个元素进行二元运算，不需要初始值，其他的和fold一样

    var a=Array(1,2,3)a.foreach(x=>print(x+"\t"));println()println(a.reduce((x, y) => {var z = x + yprintln(s"$x+$y=$z")z}))

在这里插入图片描述

reduceLeft从左向右计算

def reduceLeft[B >: A](op: (B, T) ⇒ B): B
同 foldLeft，从左向右计算，不需要初始值

    var a=Array(1,2,3,4,5,6)a.foreach(x => print(x + "\t"));println()println(a.reduceLeft((x, y) => {var z = x + yprintln(s"$x+$y=$z")z}))

在这里插入图片描述

reduceRight从右向左计算

def reduceRight[B >: A](op: (B, T) ⇒ B): B
同 foldRight，从右向左计算，不需要初始值

    var a=Array(1,2,3,4,5,6)a.foreach(x => print(x + "\t"));println()println(a.reduceRight((x, y) => {var z = x + yprintln(s"$x+$y=$z")z}))

在这里插入图片描述

reduceOption二元计算返回option

def reduceOptionA1>:A: scala.Option[A1]
同 reduceLeftOption，计算Option，返回 Option

    var a=Array(1,2,3,4,5,6)a.foreach(x => print(x + "\t"));println()println(a.reduceOption((x, y) => {var z = x + yprintln(s"$x+$y=$z")z}))

在这里插入图片描述

reduceLeftOption从左向右计算返回option

def reduceLeftOption[B >: A](op: (B, T) ⇒ B): Option[B]
同 reduceLeft，返回 Option

    var a=Array(1,2,3,4,5,6)a.foreach(x => print(x + "\t"));println()println(a.reduceLeftOption((x, y) => {var z = x + yprintln(s"$x+$y=$z")z}))

在这里插入图片描述

reduceRightOption从右向左计算返回option

def reduceRightOption[B >: A](op: (T, B) ⇒ B): Option[B]
同 reduceRight，返回 Option

    var a=Array(1,2,3,4,5,6)a.foreach(x => print(x + "\t"));println()println(a.reduceRightOption((x, y) => {var z = x + yprintln(s"$x+$y=$z")z}))

在这里插入图片描述

scan折叠计算返回新集合

def scan[B >: A, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Array[T], B, That]): That
同 fold，scan 会把每一步的计算结果放到一个新的集合中返回，而 fold 返回的是最后的结果

    var a=Array(1,2,3,4,5,6)a.foreach(x => print(x + "\t"));println()a.scan(0)(_+_).foreach(x => print(x + "\t"));println()

在这里插入图片描述

scanLeft从左向右计算返回新集合

def scanLeft[B, That](z: B)(op: (B, T) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That
同 scan，从左向右计算，每一步的计算结果放到一个新的集合中返回

    var a=Array(1,2,3,4,5,6)a.foreach(x => print(x + "\t"));println()a.scanLeft(0)(_+_).foreach(x => print(x + "\t"));println()

在这里插入图片描述

scanRight从右向左计算返回新集合

def scanRight[B, That](z: B)(op: (T, B) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That
同 foldRight，从右向左计算，每一步的计算结果放到（从右向左放）一个新的集合中返回

    var a=Array(1,2,3,4,5,6)a.foreach(x => print(x + "\t"));println()a.scanRight(0)(_+_).foreach(x => print(x + "\t"));println()

在这里插入图片描述

sum求和

def sum: A
序列求和，元素需为 Numeric[T] 类型

    var a1=Array.range(1,5)a1.foreach(x=>print(x+"\t"));println()println(a1.sum)

在这里插入图片描述

5.数组拆分排序

groupBy按条件分组

def groupBy[K](f: (T) ⇒ K): Map[K, Array[T]]
按条件分组，条件由 f 匹配，返回值是 Map 类型，每个 key 对应一个数组

//下面代码实现的是，把小于3的数字放到一组，大于3的放到一组
//返回Map[String,Array[Int]]var a=Array(3,5,2,6,4,1,0)val b = a.groupBy( x => x match {case x if (x < 3) => "small"case _ => "big"})println(b) //Map(small -> [I@737996a0, big -> [I@2cb4c3ab)//b.get("big").getprintln(b.get("big").get.toList)

在这里插入图片描述

grouped分组

def grouped(size: Int): collection.Iterator[Array[T]]
按指定数量分组，每组有 size 个元素，返回一个迭代器

    var array2 = Array(1, 2, 3, 5, 7)array2.grouped(2).foreach(x=>{x.foreach(y=>print(y+"\t"))println()})

在这里插入图片描述

par并行计算

def par: ParArray[T]
返回一个并行实现，产生的并行序列不能被修改，其作用相当于hashcode进行分区

    var lst = new ArrayBuffer[Int]for (elem <- 1 to 5) {lst.append(Random.nextInt(100))}lst.foreach(x=>print(x+"\t"))println()println(lst.par)

在这里插入图片描述

partition分组

def partition(p: (T) ⇒ Boolean): (Array[T], Array[T])
按条件将序列拆分成两个数组，满足条件的放到第一个数组，其余的放到第二个数组，返回的是包含这两个数组的元组

    val a1 =Array(6,7,5,8,5,8,10,11)a1.foreach(x=>print(x+"\t"));println()a1.partition(_>8)._2.foreach(x=>print(x+"\t"))println()a1.partition(_>8)._1.foreach(x=>print(x+"\t"))println()

在这里插入图片描述

span拆分数组

def span(p: (T) ⇒ Boolean): (Array[T], Array[T])
将序列拆分成两个数组，从第一个元素开始，直到第一个不满足条件的元素为止，其中的元素放到第一个数组，其余的放到第二个数组，返回的是包含这两个数组的元组

    val a1 =Array(6,7,5,8,5,8,10,11)a1.foreach(x => print(x + "\t"));println()a1.span(_ > 5)._1.foreach(x => print(x + "\t"));println()a1.span(_ > 5)._2.foreach(x => print(x + "\t"));println()

在这里插入图片描述

splitAt按序列拆分成两个数组

def splitAt(n: Int): (Array[T], Array[T])
从指定位置开始，把序列拆分成两个数组，指定索引位置元素放入第二个数组中

    val a1 =Array(6,7,5,8,5,8,10,11)a1.foreach(x => print(x + "\t"));println()a1.splitAt(3)._1.foreach(x => print(x + "\t"));println()a1.splitAt(3)._2.foreach(x => print(x + "\t"));println()

在这里插入图片描述

sliding(size)滑动

def sliding(size: Int): collection.Iterator[Array[T]]
滑动，从第一个元素开始，每个元素和它后面的 size个元素组成一个数组，最终组成一个新的集合返回，当剩余元素个数不够size时，则结束。【该方法可以设置步长 step，每一组元素组合完后，下一组从上一组起始元素位置 + step 后的位置处开始】
如果size=step，则等同于grouped(5)

    val a1 =Array(6,7,5,8,5,8,10,11)a1.foreach(x => print(x + "\t"));println()//步长为0，a1.sliding(2).foreach(x =>{x.foreach(y=>print(y+"\t"));println()});println()println()//步长为2a1.sliding(2,2).foreach(x =>{x.foreach(y=>print(y+"\t"));println()});println()println()a1.sliding(3).foreach(x =>{x.foreach(y=>print(y+"\t"));println()});println()println()a1.sliding(3,2).foreach(x =>{x.foreach(y=>print(y+"\t"));println()});println()

在这里插入图片描述

sortBy按规则排序

def sortBy[B](f: (T) ⇒ B)(implicit ord: math.Ordering[B]): Array[T]
按指定的排序规则对序列排序

    val a1 =Array(6,7,5,8,5,8,10,11)a1.foreach(x => print(x + "\t"));println()//按顺序排序a1.sortBy(x=>x).foreach(x => print(x + "\t"));println()//倒序a1.sortBy(x=>(-x)).foreach(x => print(x + "\t"));println()

在这里插入图片描述

sorted排序

def sorted[B >: A](implicit ord: math.Ordering[B]): Array[T]]
使用默认的排序规则对序列排序，默认升序排列，无参数

    val a1 =Array(6,7,5,8,5,8,10,11)a1.foreach(x => print(x + "\t"));println()//默认升序a1.sorted.foreach(x => print(x + "\t"));println()

在这里插入图片描述

sortWith自定义排序

def sortWith(t:(T,T)=>boolean)：Array[T]
自定义排序方法

    val a1 =Array(6,7,5,8,5,8,10,11)a1.foreach(x => print(x + "\t"));println()a1.sortWith(_>_).foreach(x => print(x + "\t"));println()a1.sortWith(_<_).foreach(x => print(x + "\t"));println()

在这里插入图片描述

6. 数组长度

length返回元素个数

def length: Int
返回序列元素个数

    val a1 =Array(6,7,5,8,5,8,10,11)a1.foreach(x => print(x + "\t"));println()println(a1.length)//8

在这里插入图片描述

size返回元素个数

def size: Int
返回序列元素个数，同 length

    val a1 =Array(6,7,5,8,5,8,10,11)a1.foreach(x => print(x + "\t"));println()println(a1.size)//8

在这里插入图片描述

lengthCompare长度比较

def lengthCompare(len: Int): Int
比较序列的长度和参数 len，返回序列的长度减去参数len,根据二者的关系返回不同的值，长度length更小的话则为负，比较规则是：
x>0, length > len
x=0, length = len
x<0, length < len

    val a1 =Array(6,7,5,8,5,8,10,11)a1.foreach(x => print(x + "\t"));println()println(a1.length)//8println(a1.lengthCompare(8))//8-8=0println(a1.lengthCompare(3))//8-3=5println(a1.lengthCompare(10))//-2

在这里插入图片描述

segmentLength查找返回

def segmentLength(p: (T) ⇒ Boolean, from: Int): Int
从序列的 from 开始向后查找，返回满足条件 p 的连续元素的长度，只返回第一个，第一个不满足的话就结束

    val a1 =Array(6,7,5,8,5,8,10,11)a1.foreach(x => print(x + "\t"));println()println(a1.segmentLength(_ > 4, 0))println(a1.segmentLength(_ > 4, 1))println(a1.segmentLength(_ > 4, 2))

在这里插入图片描述

7.两数组操作

++合并数组操作

def ++[B](that: GenTraversableOnce[B]): Array[B]
合并集合，并返回一个新的数组，新数组包含左右两个集合对象的内容

    val a = Array(1, 2)val b = Array(3, 4)val c = a ++ b//打印数组c.foreach(print) // 1234println()//按格式打印数组println(c.mkString(",")) //1,2,3,4

在这里插入图片描述

++：合并数组操作

def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Array[T], B, That]): That
这个方法同上一个方法类似，两个加号后面多了一个冒号，但是不同的是右边操纵数的类型决定着返回结果的类型。
下面代码中List和LinkedList结合，返回结果是LinkedList类型

    val a=List(1,2)val b =scala.collection.mutable.LinkedList(3,4)val c = a ++: b //以b为类型返回//c的类型是：scala.collection.mutable.LinkedListprintln(c.getClass().getName())c.foreach(print) //1234 返回b的类型

在这里插入图片描述

canEqual两数比较

def canEqual(that: Any): Boolean
判断两个对象是否可以进行比较

    val a1=Array.range(1,5)a1.foreach(x=>print(x+"\t"))println()val a2 = Array("a","b","c")a2.foreach(x=>print(x+"\t"))println()println(a2.canEqual(a1))

在这里插入图片描述

corresponds元素比较

def corresponds[B](that: GenSeq[B])(p: (T, B) ⇒ Boolean): Boolean
判断两个序列长度以及对应位置元素是否符合某个条件。如果两个序列具有相同的元素数量并且p(x, y)=true，返回结果为true
下面代码检查a和b长度是否相等，并且a中元素是否小于b中对应位置的元素

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

diff计算两数组差集

def diff(that: collection.Seq[T]): Array[T]
计算当前数组与另一个数组的差集，即将当前数组中没有在另一个数组中出现的元素返回

    val a = Array(1,2,3)val b = Array(1,2,4,5,6)a.diff(b).foreach(x =>println(x+"\t"))//3b.diff(a).foreach(x =>println(x+"\t"))//4 5 6

在这里插入图片描述

intersect计算两数组交集

def intersect(that: collection.Seq[T]): Array[T]
返回两个集合的交集

    val a = Array(1,2,3)val b = Array(1,2,4,5,6)a.intersect(b).foreach(x =>println(x+"\t"))//1 2

在这里插入图片描述

union合并

def union(that: collection.Seq[T]): Array[T]
合并两个序列，同操作符 ++

    var a1=Array.range(1,5)var a2=Array.range(8,12)a1.foreach(x=>print(x+"\t"));println()a2.foreach(x=>print(x+"\t"));println()a1.union(a2).foreach(x=>print(x+"\t"));println()(a1 union a2).foreach(x=>print(x+"\t"));println()

在这里插入图片描述

sameElements值比较

def sameElements(that: GenIterable[A]): Boolean
判断两个序列是否顺序和对应位置上的元素都一样，值比较

    var a1=Array.range(1,5)a1.foreach(x=>print(x+"\t"))println()var a3 = a1.clone()println(a1 == a3)//重写same方法，比较值def same(a1:Array[Int],a2:Array[Int]):Boolean={var same:Boolean=trueif (a1.size!=a2.size) {same = false}else{breakable{for (elem <- 0 until a1.size) {if (a1(elem)!=a2(elem)) {same=falsebreak()}}}}same}println(same(a1, a3))println(a1.sameElements(a3))

在这里插入图片描述

8.数组克隆和复制

clone创建副本

def clone(): Array[T]
创建一个副本

    val a = Array('a','b','c')val newa=a.clone()newa.foreach(print)//abc
``
![在这里插入图片描述](https://img-blog.csdnimg.cn/6a14cfe464ee43768795f416f38405c7.png)
### copyToArray复制数组
def copyToArray(xs: Array[A]): Unit
def copyToArray(xs: Array[A], start: Int): Unit
def copyToArray(xs: Array[A], start: Int, len: Int): Unit
将当前数组元素复制到另一个数组中，2-3的参数是待复制的数组的起始位置和长度
```scalaval a =Array(1,2,3,4)//创建一个新的集合里面有五个元素val b : Array[Int] = new Array(5)//def copyToArray(xs: Array[A]): Unita.copyToArray(b)print(b.mkString(" "))//1 2 3 4 0//def copyToArray(xs: Array[A], start: Int): Unita.copyToArray(b, 1)print(b.mkString(" "))//0 1 2 3 4//def copyToArray(xs: Array[A], start: Int, len: Int): Unita.copyToArray(b,1,3)println(b.mkString(" "))//0 1 2 3 0

copyToBuffer复制数组

def copyToBuffer[B >: A](dest: Buffer[B]): Unit
将数组中的元素复制到 Buffer 中

    import scala.collection.mutable.ArrayBuffer//定义一个数组，100以内随机生成5个数var a = new ArrayBuffer[Int]for (elem <- 1 to 5){a.append(Random.nextInt(100))}a.foreach(x=>print(x +"\t"))println()val b = new ArrayBuffer[Int]a.copyToBuffer(b)b.foreach(x=>print(x+"\t"))

在这里插入图片描述

seq序列

def seq: collection.mutable.IndexedSeq[T]
产生一个引用当前序列的 sequential 视图，就是一个特殊的集合，WrappedArray

    var a1=Array.range(1,5)a1.foreach(x => print(x + "\t"));println()a1.seq.foreach(x => print(x + "\t"));println()println(a1.seq)

在这里插入图片描述

9.数组反转

reverse反转序列

def reverse: Array[T]
反转序列

    var a1=Array.range(1,5)a1.foreach(x => print(x + "\t"));println()a1.reverse.foreach(x => print(x + "\t"));println()

在这里插入图片描述

reverseIterator反向迭代器

def reverseIterator: collection.Iterator[T]
生成反向迭代器

    var a1=Array.range(1,5)a1.foreach(x => print(x + "\t"));println()println(a1.isTraversableAgain)a1.reverseIterator.foreach(x => print(x + "\t"));println()println(a1.reverseIterator.isTraversableAgain)

在这里插入图片描述

reverseMap反向操作

def reverseMap[B](f: (A) ⇒ B): Array[B]
同 map，方向相反

    var a1=Array.range(1,5)a1.map(x=>print(x + "\t"));println()a1.reverseMap(x=>print(x + "\t"));println()

在这里插入图片描述

10.数组的行列操作

flatMap扁平化映射

def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Array[B]
先map后降维，对当前序列的每个元素进行操作，map之后的每个元素必须还是集合，结果放入新序列返回，参数要求是 GenTraversableOnce 及其子类。什么类型调用的flatMap方法，则返回的也是什么类型

    var ints =Array(3,5,2,6,4)val b =ints.flatMap(x=>1 to x)println(b.mkString(","))//1,2,3,1,2,3,4,5,1,2,1,2,3,4,5,6,1,2,3,4var arrays =Array(Array(1,2,3),Array(4,5,6),Array(7,8,9))val c= arrays.flatMap(x=>x)//1,2,3,4,5,6,7,8,9 但类型为arrayprintln(c.mkString(","))var arrayss =Array(Array(Array(1,2),Array(3,4)))val d=arrayss.flatMap(x=>x)println(d.mkString(","))//[I@506e6d5e,[I@96532d6val d2=d.flatMap(x=>x)println(d2.mkString(","))//1,2,3,4

在这里插入图片描述

flatten扁平化

def flatten[U](implicit asTrav: (T) ⇒ collection.Traversable[U], m: ClassTag[U]): Array[U]
扁平化(降维)，将二维数组的所有元素组合在一起，形成一个一维数组返回

    val a2 = Array(Array(1,3,5),Array(2,4,6),Array(7,8,9))a2.foreach(x => {x.foreach(y=>print(y + "\t"))println()})a2.flatten.foreach(x => print(x + "\t"))

在这里插入图片描述

transpose矩阵转置

def transpose[U](implicit asArray: (T) ⇒ Array[U]): Array[Array[U]]
矩阵转置，二维数组行列转换

    var arr=Array(Array(1,2,3),Array(4,5,6),Array(7,8,9),Array(11,12,13),Array(21,22,3))arr.foreach(x =>{x.foreach(y=>print(y+"\t"));println()});println()println()arr.transpose.foreach(x =>{x.foreach(y=>print(y+"\t"));println()});println()

在这里插入图片描述

unzip二元数组

def unzip[T1, T2](implicit asPair: (T) ⇒ (T1, T2), ct1: ClassTag[T1], ct2: ClassTag[T2]): (Array[T1], Array[T2])
将二元组的数组，每个元组的第一个元素组成一个数组，第二个元素组成一个数组，返回包含这两个数组的元组

    var arr=Array(("aaaa",10),("bbbb",20))arr.unzip._1.foreach(x => print(x + "\t"));println()arr.unzip._2.foreach(x => print(x + "\t"));println()

在这里插入图片描述

unzip3三元数组

def unzip3[T1, T2, T3](implicit asTriple: (T) ⇒ (T1, T2, T3), ct1: ClassTag[T1], ct2: ClassTag[T2], ct3: ClassTag[T3]): (Array[T1], Array[T2], Array[T3])
将三元组的数组，每个元组的第一个元素组成一个数组，第二个元素组成一个数组，第三个元素组成一个数组，返回包含这三个数组的元组

    var arr=Array(("aaaa",10,'c'),("bbbb",20,'d'))arr.unzip3._1.foreach(x => print(x + "\t"));println()arr.unzip3._2.foreach(x => print(x + "\t"));println()arr.unzip3._3.foreach(x => print(x + "\t"));println()

在这里插入图片描述

zip数组组合

def zip[B](that: GenIterable[B]): Array[(A, B)]
将两个序列对应位置上的元素组成一个元组数组，要求两个序列长度相同

    var c1=Array(1,2,3)var c2=Array("a","b","c")c1.zip(c2).foreach(x=>print(x+"\t"));println()

在这里插入图片描述

zipAll数组组合

def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): Array[(A, B)]
同 zip ，但是允许两个序列长度不同，不足的自动填充，如果当前序列短，不足的元素填充为 thisElem，如果 that 序列短，填充为 thatElem

    var a=Array(1,2,3)var b=Array("a","b","c","d")a.zipAll(b,0,"z").foreach(x=>print(x+"\t"));println()b.zipAll(a,0,"z").foreach(x=>print(x+"\t"));println()

在这里插入图片描述

zipWithIndex元素和索引组成数组

def zipWithIndex: Array[(A, Int)]
序列中的每个元素和它的索引组成一个元组数组

    var a1=Array("a","b","c","d")a1.zipWithIndex.foreach(x=>print(x+"\t"));println()

在这里插入图片描述

11.字符串相关操作

addString 逐个添加元素

def addString(b: StringBuilder): StringBuilder
将数组中的元素逐个添加到b中

    val a =List(1,2,3,4)val b=new  StringBuilder()val c= a.addString(b)c.foreach(print) //1234

def addString(b: StringBuilder, sep: String): StringBuilder
同上，每个元素用sep分隔符分开

    val a1 =List(1,2,3,4)val b1=new  StringBuilder()val d= a1.addString(b1,",")d.foreach(print) //1,2,3,4

def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
同上，在首尾各加一个字符串，并指定sep分隔符

    val a2 =List(1,2,3,4)val b2=new  StringBuilder()val e =a2.addString(b2,"(","&",")")e.foreach(print)//(1&2&3&4)

在这里插入图片描述

mkString拼接成字符串

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

    var a2 = Array(1,1,2)a2.foreach(x=>print(x+"\t"))println()var a1=Array.range(1,5)a1.foreach(x=>print(x+"\t"))println()println(a1.mkString("[", "-", "]"))var lst = new ArrayBuffer[Int]for (elem <- 1 to 5) {lst.append(Random.nextInt(100))}println(lst.mkString(")"))

在这里插入图片描述

stringPrefix返回前缀

def stringPrefix: String
返回 toString 结果的前缀

    var a1 = Array.range(1, 5)a1.foreach(x => print(x + "\t"));println()a1.stringPrefix.foreach(x=>print(x+"\t"));println()

在这里插入图片描述

12.方法操作

aggregate聚合操作

def aggregate[B](z: ⇒ B)(seqop: (B, T) ⇒ B, combop: (B, B) ⇒ B): B
聚合计算，aggregate是柯里化方法，参数是两个方法
为了方便理解，我们把aggregate的两个参数，分别封装成两个方法，并把计算过程打印出来

def main(args: Array[String]): Unit = {val a = List(1,2,3,4)val c =a.par.aggregate(5)(seqop,combine)println("c:"+c)
}def seqop(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}

在这里插入图片描述

andThen方法连续调用（与 compose 相反）

def andThen[C](k : scala.Function1[B, C]) : scala.PartialFunction[A, C] = { /* compiled code */ }
表示方法的连续调用，相当于嵌套函数 a(b(x)(需要满足第一个函数的返回值类型为第二个函数的输入值类型)，与 compose 相反

    val a1=Array.range(1,5)a1.foreach(x=>print(x+"\t"))println()println(a1.andThen(x => {if (x % 3 == 0) {"match"}})(2))println(a1.andThen(x => {if (x % 3 == 0) Some(x)else None})(2))

在这里插入图片描述

collect 并行计算（偏函数）

def collect[B](pf: PartialFunction[A, B]): Array[B]
通过执行一个并行计算（偏函数），得到一个新的数组对象

    val char = Array('a','b','c')val newchar = char.collect({ case 'a' => 'A' case x => x })newchar.foreach(print)//Abc

在这里插入图片描述

collectFirst偏函数计算

def collectFirst[B](pf: PartialFunction[T, B]): Option[B]
在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算

    val arr =Array(1,'a',"b")val maybeInt = arr.collectFirst({ case x: Int => x * 100 })println(maybeInt) //Some(100)maybeInt.foreach(print) //100

在这里插入图片描述

compose方法连续调用（与 andThen 相反）

def compose[A](g : scala.Function1[A, T1]) : scala.Function1[A, R] = { /* compiled code */ }
表示方法的连续调用，与 andThen 相反

    def add(x:Int):Int=x*2def mul(x:Int):Int=2+x//先计算2+3 然后计算(2+3)*2=10def rst1 = add _ compose(mul)println(rst1(3))//10

在这里插入图片描述

elemManifest返回集合元素的类型

返回集合元素的类型

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

在这里插入图片描述

elemTag返回集合元素的类型

返回集合元素的类型

    val sss=Array((1,2),(3,4))println(sss.elemTag)var a= Array(1,1,2)println(a.elemTag)

在这里插入图片描述

foreach 遍历

def foreach(f: (A) ⇒ Unit): Unit
遍历序列中的元素，进行f的操作

    var a1 = Array.range(1, 5)a1.foreach(x=>print(x+"\t"))

在这里插入图片描述

iterator迭代

def iterator: collection.Iterator[T]
生成当前序列的迭代器

    var a1 = Array.range(1, 5)val iterator = a1.iteratorwhile (iterator.hasNext){println(iterator.next())}

在这里插入图片描述

map操作返回新序列

def map[B](f: (A) ⇒ B): Array[B]
对序列中的元素进行 f 操作，返回生成的新序列，对一个维度的数据进行操作

    var a1 = Array.range(1, 5)a1.foreach(x => print(x + "\t"));println()a1.map(x=>x*2).foreach(x => print(x + "\t"));println()val a2 = Array(("1001", "henry", "male", 100), ("1002", "pola", "female", 130), ("1003", "ariel", "female", 200))//元组的数组a2.foreach(x=>print(x+"\t"));println()a2.map(x=>(x._3,x._4)).foreach(x=>print(x+"\t"))

在这里插入图片描述

runWith执行偏函数

def runWith[U](action : scala.Function1[B, U]) : scala.Function1[A, scala.Boolean] = { /* compiled code */ }
执行偏函数，当参数不在定义域内时，返回false，否则返回true，并执行action

    var b = Array.range(1, 20)b.runWith(print)(18);println()b.runWith(print)(21);println()b.runWith(print)(17);println()println(b.runWith(x => x match {case x if x % 2 == 0 => x})(17))

在这里插入图片描述

13.指定条件判断

contains包含

def contains[A1 >: A](elem: A1): Boolean
判断序列中是否包含指定对象

    var a1 = Array.range(1, 5)a1.foreach(x => print(x + "\t"))println()println(a1.contains(1))println(a1.contains(0))println(a1.contains("a"))

在这里插入图片描述

containsSlice包含序列

def containsSlice[B](that: GenSeq[B]): Boolean
判断当前序列中是否包含另一个序列(数量和顺序相等)，是否包含子序列

    var a1=Array.range(1,5)a1.foreach(x=>print(x+"\t"))println()println(a1.containsSlice(Array(1,2)))println(a1.containsSlice(Array(1,3)))

在这里插入图片描述

count统计

def count(p: (T) ⇒ Boolean): Int
统计符合条件的元素个数，下面统计大于 2 的元素个数

    val a = Array(1, 2, 3)println(a.count({x:Int => x > 2}))  // count = 1

endsWith判断结尾

def endsWith[B](that: GenSeq[B]): Boolean
判断当前序列是否以某个序列结尾

    var a1 = Array.range(1, 5)a1.foreach(x => print(x + "\t"))println()var a2 = Array.range(1,3)a2.foreach(x => print(x + "\t"))println()var a3 = Array.range(4,5)a3.foreach(x => print(x + "\t"))println()println(a1.endsWith(a2))println(a1.endsWith(a3))

在这里插入图片描述

startsWith判断开头

def startsWith[B](that: GenSeq[B], offset: Int): Boolean
判断序列从指定偏移处是否以某个序列开始，第二个参数是主序列的偏移量，也就是从第n位开始的位置是否以子序列结束

    var a1 = Array.range(1, 5)a1.foreach(x => print(x + "\t"))println()var a2 = Array.range(1,3)a2.foreach(x => print(x + "\t"))println()var a3 = Array.range(4,5)a3.foreach(x => print(x + "\t"))println()println(a1.startsWith(a2))println(a1.startsWith(a3))println(a1.startsWith(a3,3))

在这里插入图片描述

exists判断符合条件

def exists(p: (T) ⇒ Boolean): Boolean
判断当前数组是否包含符合条件的元素

    var a1=Array.range(1,5)a1.foreach(x=>print(x+"\t"));println()println(a1.exists(_ > 6))//大于6 falseprintln(a1.exists(_ > 3))//大于3 true

在这里插入图片描述

filter过滤

def filter(p: (T) ⇒ Boolean): Array[T]
取得当前数组中符合条件的元素，组成新的数组返回

    val a =Array(1,2,3,4,5)a.filter(_>2).foreach(x =>print(x+"\t")) //3 4 5

在这里插入图片描述

filterNot过滤

def filterNot(p: (T) ⇒ Boolean): Array[T]
不符合条件的元素，组成新的数组返回
与上面的 filter 作用相反

val a =Array(1,2,3,4,5)
a.filterNot(_>2).foreach(x =>print(x+"\t"))//1 2

在这里插入图片描述

withFilter条件过滤

def withFilter(p: (T) ⇒ Boolean): FilterMonadic[T, Array[T]]
根据条件 p 过滤元素,不生成新的集合

    var a1 = Array.range(1, 5)a1.foreach(x => print(x + "\t"))println()a1.withFilter(_>2).foreach(x => print(x + "\t"))//过滤大于2的 但不返回新的集合

在这里插入图片描述

find查找

def find(p: (T) ⇒ Boolean): Option[T]
查找第一个符合条件的元素，返回 Option

    var a1 = Array.range(1, 5)a1.foreach(x => print(x + "\t"))println()println(a1.find(_ > 2))//Some(3)println(a1.find(_ > 5))//None

在这里插入图片描述

forall全部满足

def forall(p: (T) ⇒ Boolean): Boolean
检测序列中的元素是否都满足条件 p，如果序列为空，则返回 true

    var a1 = Array.range(1, 5)a1.foreach(x=>print(x+"\t"));println()println(a1.forall(_ > 0))//trueprintln(a1.forall(_ < 0))//falseprintln(a1.forall(_ > 2))//false

在这里插入图片描述

hasDefiniteSize检测有限长度

def hasDefiniteSize: Boolean
检测序列是否存在有限的长度，对应 Stream 这样的流数据则返回 false，流没有确定的大小

    var b1 = Array(1, 2, 3, 5, 7)println(b1.hasDefiniteSize)println(b1.toStream.hasDefiniteSize)

在这里插入图片描述

isDefinedAt判断指定索引

def isDefinedAt(idx: Int): Boolean
判断序列中是否存在指定索引

    var b = Array.range(1, 5)b.foreach(x=>print(x+"\t"));println()println(b.isDefinedAt(5))println(b.isDefinedAt(2))

在这里插入图片描述

isEmpty判断为空

def isEmpty: Boolean
判断序列是否为空

    var b = Array.range(1, 5)b.foreach(x=>print(x+"\t"));println()println(b.isEmpty)

在这里插入图片描述

nonEmpty判断不为空

def nonEmpty: Boolean
判断序列是否不为空

    var b = Array.range(1, 5)b.foreach(x=>print(x+"\t"));println()println(b.nonEmpty)

在这里插入图片描述

isTraversableAgain判断可以反复遍历

def isTraversableAgain: Boolean
判断序列是否可以反复遍历，该方法是 GenTraversableOnce 中的方法，对于 Traversables 一般返回 true，对于 Iterators 返回 false，除非被复写或者说判断是否为迭代器（只能遍历一次）

    var b = Array.range(1, 5)b.foreach(x=>print(x+"\t"));println()println(b.isTraversableAgain)println(b.toIterator.isTraversableAgain)

在这里插入图片描述

14.类型转换

在这里插入图片描述

toArray

def toArray: Array[A]
将序列转换成 Array 类型

    var b = Array.range(1, 5)b.foreach(x=>print(x+"\t"));println()val list = b.toListprintln(list)println(list.toArray.mkString(","))

在这里插入图片描述

toBuffer

def toBuffer[A1 >: A]: Buffer[A1]
将序列转换成 Buffer 类型

    var b = Array.range(1, 5)b.foreach(x=>print(x+"\t"));println()println(b.toBuffer)

在这里插入图片描述

toIndexedSeq

def toIndexedSeq: collection.immutable.IndexedSeq[T]
将序列转换成 IndexedSeq 类型

    var b = Array.range(1, 5)b.foreach(x=>print(x+"\t"));println()println(b.toIndexedSeq)

在这里插入图片描述

toIterable

def toIterable: collection.Iterable[T]
将序列转换成可迭代的类型

    var b = Array.range(1, 5)b.foreach(x=>print(x+"\t"));println()println(b.toIterable)

在这里插入图片描述

toIterator

def toIterator: collection.Iterator[T]
将序列转换成迭代器，同 iterator 方法

    var b = Array.range(1, 5)b.foreach(x=>print(x+"\t"));println()val iterator = b.toIteratorprintln(iterator)while (iterator.hasNext){println(iterator.next())}

在这里插入图片描述

toList

def toList: List[T]
将序列转换成 List 类型

    var b = Array.range(1, 5)b.foreach(x=>print(x+"\t"));println()println(b.toList)

在这里插入图片描述

toMap

def toMap[T, U]: Map[T, U]
将序列转转换成 Map 类型，需要被转化序列中包含的元素是 Tuple2 类型，Tuple2 类型意思是：元组必须是2元的，以元组的第一个元素做键，第二个元素做值

    var a= Array((1,"zs"),(2,"ls"),(3,"ww"))a.foreach(x=>print(x+"\t"));println()println(a.toMap)

在这里插入图片描述

toSeq

def toSeq: collection.Seq[T]
转换成序列

    var b = Array.range(1, 5)b.foreach(x=>print(x+"\t"));println()println(b.toSeq)

在这里插入图片描述

toSet

def toSet[B >: A]: Set[B]
将序列转换成 Set 类型

    var b = Array.range(1, 5)b.foreach(x=>print(x+"\t"));println()println(b.toSet)

在这里插入图片描述

toStream

def toStream: collection.immutable.Stream[T]
将序列转换成 Stream 类型（流类型），懒de序列，只存一个值，其他值需要时再取

    var b = Array.range(1, 5)b.foreach(x=>print(x+"\t"));println()println(b.toStream)

在这里插入图片描述

toVector

def toVector: Vector[T]
将序列转换成 Vector 类型，内部线程安全，但效率低

    var b = Array.range(1, 5)b.foreach(x=>print(x+"\t"));println()println(b.toVector)

在这里插入图片描述

词库加载错误:未能找到文件“E:\highferrum_mysql\Configuration\Dict_Stopwords.txt”。

上一篇：内存避障的前世今生

下一篇：【华为机试真题详解 Python实现】统计差异值大于相似值二元组个数【2023 Q1 | 100分】