Scala入门到放弃——数组（四）

七、数组操作

• 概念上类似于Java中的数组，一个特定类型的元素集合

数组的初始化

package array

object Array01 {
  def main(args: Array[String]): Unit = {
    // 数组声明
    // a1数组的长度为10 泛型为Int
    val a1 = new Array[Int](10)
    val a2 = new Array[String](5)

    // 指定数组 元素并初始化
    val a3 = Array[Long](10,20,30)

    val a4 = Array(1.0,2.0,3.0)

    // 使用：长度 length  下标index【0 ~ length-1】
    // 访问数组元素使用 变量名(下标)
    // 数组默认值：整数为 0  小数为0.0  boolean false null
    println(a1(0))
    println(a2(4))
    println(a3(1))
    println(a4(2))
      
    // 遍历 传统方式
    for (n <- 0 until (a4.length)) {
      println(a4(n))
    }

    for (n <- a4) {
      println(n)
    }

    for( n <- a4.indices){ // Range(0,1,2)
      println(a4(n))
    }
  }
}

数组的使用

• 长度 length
• 下标 index

val a1 = Array(1, 2, 3, 4, 5)
// 传统方式
for (n <- 0 until (a1.length)) {
  println(a1(n))
}
// 推荐方式
for (n <- a1.indices) {
  println(a1(n))
}

// 跳跃遍历(步长2)
for (n <- a1.indices by 2) {
  print(a1(n) +"\t")
}

排序

/**
  * 冒泡排序
  * 2 1 5 0 3
  * 第一轮：
  *   1 2 5 0 3
  *   1 2 5 0 3
  *   0 2 2 1 3
  *
  *
  */
package array

/**
  * 冒泡排序
  */
object Array02 {
  def main(args: Array[String]): Unit = {
    val a1 = Array(3, 1, 5, 4, 10, 0)
    //    for (m <- 0 until (a1.length)) {
    //      for (n <- 0 until (a1.length - m - 1)) {
    //        if (a1(n) > a1(n + 1)) {
    //          var tmp = a1(n)
    //          a1(n) = a1(n + 1)
    //          a1(n + 1) = tmp
    //        }
    //      }
    //    }

    // 多重循环  + if守卫  
    for (m <- 0 until (a1.length); n <- 0 until (a1.length - m - 1) if a1(n) > a1(n + 1)) {
      val tmp = a1(n)
      a1(n) = a1(n + 1)
      a1(n + 1) = tmp
    }

    for (n <- a1) {
      println(n)
    }
  }
}

ArrayBuffer

可变数组，数组支持自动扩容

• 类似于ArrayList集合

import scala.collection.mutable.ArrayBuffer

object ArrayBuffer01 {
  def main(args: Array[String]): Unit = {
    val a1 = new ArrayBuffer[Byte]()
    // 注意： += 语法是给ArrayBuffer添加元素
    a1 += 1
    a1 += 2
    // 一次性添加多个元素
    a1 += (3,4,5)
    // 注意： ++= 将数组中的所有元素添加到ArrayBuffer中
    a1 ++= Array[Byte](6,7,8)
    // 从末尾截断指定个数的元素
    a1.trimEnd(3)

    // 从下标5 添加元素 6，7，8
    a1.insert(5,6,7,8)

    // 跳跃遍历
    for ( i <- 0 until(a3.length,2) ) {
      print(a3(i) +"\t")
    }
  }
}

Array和ArrayBuffer相互转换

val a1 = new ArrayBuffer[Byte]()
// 转为数组
val a2 = a1.toArray
a2(2) = 0

// 转为ArrayBuffer
val a3 = a2.toBuffer

println(a1)
println(a3)

其它操作

import scala.util.Sorting

object Array04 {
  def main(args: Array[String]): Unit = {
    val a1 = Array(5,4,3,2,1)
    println(a1.sum) //15
    println(a1.max) //5
    println(a1.min) //1

    println(a1.mkString) //54321
    println(a1.mkString(",")) //5,4,3,2,1
    println(a1.mkString("<",",",">")) //<5,4,3,2,1>

    //println(a1.sorted.mkString) // 排序
    Sorting.quickSort(a1) //快速排序
    println(a1.mkString)
  }
}

多维数组

定义

// 二维数组 有三个一维数组，每个一维中包含四个元素
val arr = Array.ofDim(3,4)

使用

package com.baizhi.array

/**
  * 多维数组
  */
object MultiplyBuffer01 {
  def main(args: Array[String]): Unit = {
    val arr = Array.ofDim[Int](3, 4)
    for (m <- arr) {
      print(m.mkString(","))
      println()
    }

    // 二维数组赋值
    arr(2)(1) = 100
    for (m <- arr) {
      print(m.mkString(","))
      println()
    }
  }
}

算法案列：移除第一个负数后的所有数

• 测试数据val a1=Array(1,2,3,4,5,-5,-4,-3)
• 预期结果val a2=Array(1,2,3,4,5,-5)

package array

object Array05 {
  def main(args: Array[String]): Unit = {
    // val a1=Array(1,2,3,4,5,-5,-4,-3)
    // val a2=Array(1,2,3,4,5,-5)

    val a1 = Array(1, 2, 3, 4, 5, -5, -4, -3)
    var first = true
    var position = 0
    for (n <- a1.indices) {
      if (first || a1(n) >= 0) {
        if(a1(n) <0 ){
          first = false
          position = n
        }
      }
    }

    println(position)

    val ab = a1.toBuffer
    ab.trimEnd(a1.length - position-1)
    println(ab)
  }
}