Scala基础（4）：数组

Scala数组操作详解

最新推荐文章于 2024-12-12 00:07:22 发布

原创最新推荐文章于 2024-12-12 00:07:22 发布 · 425 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Scala #数组

Scala 专栏收录该内容

5 篇文章

订阅专栏

本文详细介绍Scala中的数组操作，包括固定数组和数组缓冲的创建、元素访问、转换、遍历及常用方法等。此外还介绍了数组的排序、统计、求和等功能，并提供了多维数组的创建方法。

import scala.collection.mutable.ArrayBuffer

object Demo {
  def main(args: Array[String]) {
    changInt // 调用函数
  }

  def changInt: Unit = {
    val a = Array(1, -2, 0, -3, 0, 4, 5) //定义一个固定长度的数组
    val b = sigNumArr(a)
    b.foreach(println) // 迭代输出

  }
  def sigNumArr(arr: Array[Int]) = {
    val buf = new ArrayBuffer[Int]() // 定义一个数组缓冲（不定长数组）

    buf ++= (for (i <- arr if i > 0) yield i) // ++= 连接一个数组
    buf ++= (for (i <- arr if i == 0) yield i)
    buf ++= (for (i <- arr if i < 0) yield i)
    //println(buf)
    buf.toArray // 将数组缓冲转换成数组
  }

}

数组

创建

//固定数组
val arr1 = new Array[Int](3) // 初始值都是0
val arr2 = Array("Hello", "World") // 不用new关键字
//数组缓冲
val arrBuffer = new ArrayBuffer[Int]()

元素访问

数组访问调用角标的时候使用的是()不是[]
数组缓冲的trimEnd方法十分高效，逻辑可以尽量往这边靠拢

//固定数组
arr2(0) = "Hi" //设置角标为0的值
println(arr2(0)) // 输出 Hi
//数组缓冲
arrBuffer += 12 // 添加元素 12
println(arrBuffer(0)) // 输出 12

arrBuffer ++= arr // 添加 arr 所有元素后：12 0 0 0

arrBuffer.insert(2,5) //在角标处插入元素后：12 0 5 0 0

arrBuffer.trimEnd(3) //删除倒数第 3 个元素后：12 0 0 0

转换

val arr = arrBuffer.toArray //数组缓冲转化成固定数组
val arrBuffer = arr.toBuffer //固定数组转化成数组缓冲

遍历

    for (i <- 0 until arrBuffer.length) print(arrBuffer(i))

    for (i <- arrBuffer.indices) print(arrBuffer(i))// arrBuffer.indices相当于0 until arrBuffer.length

    for (i <- 0 until(arrBuffer.length, 2)) print(arrBuffer(i)) // 每两个一跳（会不会视为元组？）

    for (i <- (0 until arrBuffer.length).reverse) print(arrBuffer(i)) // 从尾部开始遍历

    for (elem <- arrBuffer) println(elem)

    arrBuffer.foreach(println) //输出每一个值

数组转换

    val a = Array(2, 3, 4, 5)
    val b = for (elem <- a) yield elem // 通过for yield 返回的是数组或者数组缓冲
    val c = for (elem <- a if elem % 2 == 0) yield elem //使用守卫过滤奇数，for yield是不会影响原数组或数组缓冲的

常用方法

    // 逆序
    arr.reverse：返回array的逆序
    arrayBuffer.reverse：返回arrayBuffer的逆序

    // 求和
    val a1 = Array(1, 2, 3, 4).sum //10
    println("常用算法a1:" + a1)
    val a2 = ArrayBuffer(1, 2, 3, 4).sum //10
    println("常用算法a2:" + a2)

    // 统计
    val a = arr.count(_ < a)//统计数组arr中小于a的个数
    val a = arr.count(_ == a)//统计数组arr中等于a的个数
    val a = arr.count(_ > a)//统计数组arr中大于a的个数

    // 极值
    val b1 = Array("Mary", "had", "little").max //"little"
    println("常用算法b1:" + b1)
    val b2 = ArrayBuffer("Mary", "had", "little").max //"little"
    println("常用算法b2:" + b2)

    // 排序(新建另一个数组)
    val c1 = ArrayBuffer(1, 7, 9, 3)
    println("常用算法c1:" + c1)
    val cSorted1 = c1.sorted //原数组不会发生改变，cStorted1：1,3,7,9
    println("常用算法cSorted1:" + cSorted1)

    val c2 = ArrayBuffer(1, 7, 9, 3)
    println("常用算法c2:" + c2)
    val cSorted2 = c2.sorted //原数组不会发生改变，cStorted2：1,3,7,9
    println("常用算法cSorted2:" + cSorted2)

    // 排序(不新建数组)
    val d1 = Array(1, 7, 9, 3)
    scala.util.Sorting.quickSort(d1)//只能用于固定长度数组
    printArray(d1)

    val s = "HelloWorld"
    val str = s.take(3) //顺序取 第三个以前 Hel
    val str = s.drop(3) //顺序取 第三个以后 loWorld
    val str = s.takeRight(3) //逆序取 倒数第三个以后 rld
    val str = s.dropRight(3) //逆序取 倒数第三个以前 HelloWo
    val str = s.substring(1,3) //前闭后开 el

多维数组

    val arr1 = Array.ofDim[Int](3, 4) // 直接创建 3行4列

    //不规则多维数组
    val arr2 = new Array[Array[Int]](10) // 创建不规则多维数组
    for (i <- 0 until arr2.length) arr2(i) = new Array[Int](i + 1)// 赋值