Scala 数组的优雅操作（三）

数组Array

定长数组声明

有多中声明方法 长度不可变
语法： `Array数据元素类型

package array

/**
  * 数组创建
  */
object ArrayCreate {

  def main(args: Array[String]): Unit = {

    // 声明数组

    // 方法一
    // 定义类型和数组元素  长度不可变
    val arr1 = Array[Int](1, 2, 3, 4, 5)
    // arr1(5) = 0 // Error: java.lang.ArrayIndexOutOfBoundsException: 5

    // 方法二
    // 给定长度
    val arr2 = new Array[Int](6)

	// 赋值
    arr2(0) = 10
    arr2(0) = 11

    // 方法三
    // 类型自动推导
    val arr3 = Array(12,4,1,5,1)

    // 方法四
    // 使用超类作为数组类型  类似java中的Object
    val arr4: Array[Any] = Array(12,2,4,"hello World")

    // 遍历
    for (elem <- arr4) {
      println(elem)
    }

  // 取值 下标 1~10
//    println(arr1(1))

  }
}

使用

• 下标（index）: 0 ~ length-1
• 长度（length）： 元素个数

遍历查询数组

package array

/**
  * 遍历数组
  */
object ArrayForeach {

  def main(args: Array[String]): Unit = {

    val arr = Array(11,2,4,"Hello Array")

    // 遍历一
    for (elem <- arr) {
      println(s"elem = ${elem}")
    }

    println("=--=-=-=-=-=-=-=-=-=-=")

    // 使用Range until for 循环遍历
    for(index <- 0 until  arr.length){
      print(arr(index) + "\t")
    }
    println()

    println("=--=-=-=-=-=-=-=-=-=-=")

    arr.foreach(n => println(n))
	// 等同于
    arr.foreach(println)


    println("=--=-=-=-=-=-=-=-=-=-=")

  }

}

数组排序

package array

/**
  * 数组排序
  */
object ArraySort {

  def main(args: Array[String]): Unit = {

    val arr3 = Array(12,4,3,5,1)
    xuanze(arr3)

    for (elem <- arr3) {
      println(elem)
    }

  }

  // 选择排序
  // 拿1个值挨个查询
  def xuanze(array: Array[Int])={
    for(i <- 0 until array.length - 1){
      for (j <- i + 1 until(array.length)){
        var tmp = array(i)
        if(array(i) < array(j)){
          array(i) = array(j)
          array(j) = tmp
        }
      }
    }

  }


  // 冒泡排序 相邻的两个进行比较
  def maopao(array: Array[Int]) ={

    for(i <- 0 until array.length){
      for(j <- 0 until array.length - i - 1){
       var tmp  = array(j + 1)
        if(array(j) > array(j + 1)){
          array(j + 1) = array(j)
          array(j) = tmp
        }
      }
    }

  }

}

多维数组

使用ofDim声明多维数组

package array

/**
  * 多维数组
  */

object ArrayOfDim {

  def main(args: Array[String]): Unit = {

    // 长度为10 的二维数组
    val array:Array[Array[Int]] = Array.ofDim(10,2)

    array(1)(0) = 5
    array(3)(1) = 1

    for(index <- 0 until(array.length)){
      for(j <- 0 until(array(index).length)){
        print(array(index)(j) + "\t")
      }
      println()
    }

  }
}

可变长数组

当需要一个数组但是不确定长度的时候可以声明为可变长数组，然后toArray转为普通数组

package array

import scala.collection.mutable.ArrayBuffer

/**
  * 可变长数组
  */

object ArrayBufferTest {

  def main(args: Array[String]): Unit = {
    val arr = ArrayBuffer(4,1,5,2)

    // 添加数据
    arr.+=(500)

    // 追加一个集合的数据
    arr.++=(Array(1,23,4))

    // 指定位置插入
    arr.insert(0,10)

    // 移除后面几个
    arr.trimEnd(1)

    //移除前面几个
    arr.trimStart(1)

    // 移除index 上的数据
    arr.remove(0)

    // 移除index开始几个数据
    arr.remove(0,3)

    // 遍历
    for (elem <- arr) {
      println(elem)
    }

    // 转为定长数组
    val array = arr.toArray

    // 转为可变长数组
    val buffer = array.toBuffer

  }

}

数组Doc

def test()={
    val ints = Array(-1,-4,4,1,5)

    // 清点 ints 中有几个值符合表达式
    println(s"ints.count(_>0 = ${ints.count(_ > 0)}")

    // 最大值
    println(s"ints.max = ${ints.max}")

    // 最小值
    println(s"ints.min = ${ints.min}")
}

玩数组

移除数组中第一个以外的所有负数

  def test()={
    // 移除第一个负数以外的所有负数
    val ints = Array(-1,-4,4,1,5)

    var first = true

    // 获取出第一个需要保留的索引(>= 0 和 第一个<0的数)
    var indexs = for (i <- 0 until ints.length if first || ints(i) >=0 ) yield {
      if(ints(i) < 0) first = !first
      i
    }

    // 移动数据  将indexs中第i项的索引上的数据存放到数组的第i项
    for (i <- 0 until(indexs.length)) ints(i) = ints(indexs(i))

    // 移动后截断无用数据
    val buffer = ints.toBuffer

    buffer.trimEnd(ints.length - indexs.length)

    for (elem <- buffer) {
      println(elem) // -1 4 1 5
    }
  }

玩数组2

package array

import scala.util.Random

object RandomTest {

  // 使用随机数将a设置为一个n个随机整数的数组
  // 随机整数的取值范围要在0 until n
  def main(args: Array[String]): Unit = {
    val random = new Random

    val len = random.nextInt(10)

    val ints = new Array[Int](len)

    for (index <- 0 until  ints.length){
      val num = random.nextInt(len)
      ints(index) = num
    }

    for (elem <- ints) {
      println(elem)
    }

    println(len == ints.length)

  }

}

玩数组4

package array

object ArrayTest2 {
  def main(args: Array[String]): Unit = {
    // 相邻两个元素进行互换位置
    val arr1 = Array[Int](1, 2, 3, 4, 5)

    for (index <- 0 until(arr1.length) by 2){
      if(index < arr1.length - 1){
        var tmp = arr1(index + 1)
        arr1(index + 1) = arr1(index)
        arr1(index) = tmp
      }
    }

    for (elem <- arr1) {
      print(elem + "\t") //2	1	4	3	5
    }

  }

}