Scala---Array方法

最新推荐文章于 2024-07-07 17:14:23 发布

快跑呀长颈鹿

最新推荐文章于 2024-07-07 17:14:23 发布

阅读量284

点赞数 1

分类专栏： Scala 文章标签： scala 开发语言后端

本文链接：https://blog.csdn.net/weixin_43240150/article/details/129645794

版权

Scala 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Scala之Array的方法

文章目录

Scala之Array的方法
数组

数组

第一种方式定义数组

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 +: a
    c.foreach(print) //0 1 2

在这里插入图片描述

:+尾添加元素

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

    val d = a :+ 66
    d.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,b
      a,c
      b,c
      */
    //迭代器只能遍历一次
    newarr.foreach((item) => println(item.mkString(",")))
    
    //示例2
      val 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,4
    val a = Array(3,2,3,4)
    val c = a.dropWhile( {x:Int => x > 2} )
    println(c.mkString(","))
    //如果数组 a 是下面这样，第一个元素就不满足，所以返回整个数组 1, 2, 3,4
    //val a = Array(1, 2, 3,4)

在这里插入图片描述

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-4
    var a1=Array.range(1,5) //1	2	3	4
    a1.foreach(x=>print(x+"\t"))
    println()
    //数组下标为10 数组越界 返回200
    println(a1.applyOrElse(10, { i: Int => 200 }))
    //数组下标为4 返回数组下标相应的数 4
    println(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+y
      println(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+10
    println("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 + y
      println(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 + y
      println(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 + y
      println(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 + y
      println(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 + y
      println(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 + y
      println(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").get
    println(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()
    //步长为2
    a1.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)//8
    println(a1.lengthCompare(8))//8-8=0
    println(a1.lengthCompare(3))//8-3=5
    println(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) // 1234
    println()
    //按格式打印数组
    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.LinkedList
    println(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"))//3
    b.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=true
      if (a1.size!=a2.size) {
        same = false
      }else{
        breakable{
          for (elem <- 0 until a1.size) {
            if (a1(elem)!=a2(elem)) {
              same=false
              break()
            }

          }
        }
      }
      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的参数是待复制的数组的起始位置和长度
```scala
    val a =Array(1,2,3,4)
    //创建一个新的集合里面有五个元素
    val b : Array[Int] = new Array(5)
    //def copyToArray(xs: Array[A]): Unit
    a.copyToArray(b)
    print(b.mkString(" "))//1 2 3 4 0
    
    //def copyToArray(xs: Array[A], start: Int): Unit
    a.copyToArray(b, 1)
    print(b.mkString(" "))//0 1 2 3 4
    
    //def copyToArray(xs: Array[A], start: Int, len: Int): Unit
    a.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,4
    var 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 但类型为array
    println(c.mkString(","))
    var arrayss =Array(Array(Array(1,2),Array(3,4)))
    val d=arrayss.flatMap(x=>x)
    println(d.mkString(","))//[I@506e6d5e,[I@96532d6
    val 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*2
    def mul(x:Int):Int=2+x
    //先计算2+3 然后计算(2+3)*2=10
    def 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.iterator
    while (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 false
    println(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))//true
    println(a1.forall(_ < 0))//false
    println(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.toList
    println(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.toIterator
    println(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)

在这里插入图片描述

快跑呀长颈鹿

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Scala---Array方法

Scala之Array的方法
复制链接

扫一扫

专栏目录