scala 数据结构（二）：数组

转载

mb5fdb1266ce6df 2020-07-07 22:32:00

文章标签 数组 scala 可变数组 java 赋值 文章分类 数据结构与算法人工智能

1 数组-定长数组(声明泛型)

第一种方式定义数组

这里的数组等同于Java中的数组,中括号的类型就是数组的类型

val arr1 = new Array[Int](10) //赋值,集合元素采用小括号访问 arr1(1) = 7

val arr01 = new Array[Int](4)
println(arr01.length)

println("arr01(0)=" + arr01(0))
for (i <- arr01) {
println(i)
}
println("--------------------")
arr01(3) = 10
for (i <- arr01) {
println(i)
}

第二种方式定义数组

在定义数组时，直接赋值

//使用apply方法创建数组对象

val arr1 = Array(1, 2)

scala 数据结构（二）：数组_可变数组

2 数组-变长数组(声明泛型)

基本使用和应用案例

//定义/声明
val arr2 = ArrayBuffer[Int]()
//追加值/元素
arr2.append(7)
//重新赋值
arr2(0) = 7
//学习集合的流程(创建,查询,修改,删除)

val arr01 = ArrayBuffer[Any](3, 2, 5)

println("arr01(1)=" + arr01(1))
for (i <- arr01) {
println(i)
}
println(arr01.length) //?
println("arr01.hash=" + arr01.hashCode())
arr01.append(90.0,13)
println("arr01.hash=" + arr01.hashCode())

arr01(1) = 89 //修改
println("--------------------------")
for (i <- arr01) {
println(i)
}

//删除
arr01.remove(0)
println("--------------------------")
for (i <- arr01) {
println(i)
}
println("最新的长度=" + arr01.length)

变长数组分析小结

1）ArrayBuffer是变长数组，类似java的ArrayList

2）val arr2 = ArrayBuffer[Int]() 也是使用的apply方法构建对象

3）def append(elems: A*) { appendAll(elems) } 接收的是可变参数.

4）每append一次，arr在底层会重新分配空间，进行扩容，arr2的内存地址会发生变化，也就成为新的ArrayBuffer

定长数组与变长数组的转换

arr1.toBuffer //定长数组转可变数组

arr2.toArray //可变数组转定长数组

1）arr2.toArray 返回结果才是一个定长数组， arr2本身没有变化

2）arr1.toBuffer返回结果才是一个可变数组， arr1本身没有变化

val arr2 = ArrayBuffer[Int]()
// 追加值
arr2.append(1, 2, 3)
println(arr2)

val newArr = arr2.toArray;
println(newArr)

val newArr2 = newArr.toBuffer
newArr2.append(123)
println(newArr2)

3 数组-多维数组

多维数组的定义和使用

说明

//定义
val arr = Array.ofDim[Double](3,4)
//说明：二维数组中有三个一维数组，每个一维数组中有四个元素

//赋值
arr(1)(1) = 11.11

val array1 = Array.ofDim[Int](3, 4)
array1(1)(1) = 9
for (item <- array1) {
for (item2 <- item) {
print(item2 + "\t")
}
println()
}
println("===================")
for (i <- 0 to array1.length - 1) {
for (j <- 0 to array1(i).length - 1) {
printf("arr[%d][%d]=%d\t", i, j, array1(i)(j))
}
println()
}

4 数组-Scala数组与Java的List的互转

Scala数组转Java的List

// Scala集合和Java集合互相转换
val arr = ArrayBuffer("1", "2", "3")
import scala.collection.JavaConversions.bufferAsJavaList
val javaArr = new ProcessBuilder(arr) //为什么可以这样使用?
val arrList = javaArr.command()
println(arrList) //输出 [1, 2, 3]

补充:
trait MyTrait01 {}
class A extends MyTrait01 {}
object B {
  def test(m: MyTrait01): Unit = {
    println("b ok..")
  }
}
//明确一个知识点
//当一个类继承了一个trait
//那么该类的实例，就可以传递给这个trait引用
val a01 = new A
B.test(a01)

Java的List转Scala数组(mutable.Buffer)

在项目开发中，有时我们需要将Java的List转成Scala数组，看下面案例：

import scala.collection.JavaConversions.asScalaBuffer
import scala.collection.mutable
// java.util.List ==> Buffer
val scalaArr: mutable.Buffer[String] = arrList
scalaArr.append("jack")
println(scalaArr)

实例一：

package com.atguigu.scala.chapter07

/**
  * Author: Felix
  * Date: 2020/5/4
  * Desc: 不可变数组
  *   不可变数组，所以在执行添加或者删除操作的时候，会创建新的数组对象
  */
object Scala01_TestArray {
  def main(args: Array[String]): Unit = {
    //创建不可变数组 方式1
    val arr: Array[Int] = new Array[Int](5)
    //创建不可变数组 方式2
    //val arr: Array[Int] = Array(1,2,3,4,5)

    //访问数组中的元素  并修改数组中的元素
    arr(1) = 10
    arr.update(1,20)
    //println(arr(1))

    //遍历数组中的元素
   /*
   //方式1：普通的for循环
    for(i <- 0 until arr.length){
      println(arr(i))
    }
`
   //方式2：普通的for循环
   // for( elem:Int <- arr){
    for( elem <- arr){
      println(elem)
    }

    //方式3：迭代器
    val it: Iterator[Int] = arr.iterator
    //while(it.hasNext){
    //  println(it.next())
    //}
    for (elem <- it) {
      println(elem)
    }

    //方式4：增强for循环   foreach的参数是一个和函数，是对当前集合中的元素的具体操作
    //arr.foreach((elem:Int)=>{println(elem)})
    //arr.foreach(println(_))
    arr.foreach(println)
   */
    //方式5: 用指定的字符串连接数组中的元素，形成一个新的字符串
    //println(arr.mkString("--"))


    //向数组中添加元素
    //因为Array是不可变数组，所以在执行添加操作的时候，会创建新的数组对象
    //val newArr: Array[Int] = arr. +: (30)

    //在Scala语言中，如果运算符方法中包含冒号，并且冒号在后，运算顺序为从右到左
    //val newArr: Array[Int] = arr +: 30  编译报错
    val newArr: Array[Int] = 30 +: arr

    //val newArr: Array[Int] = arr. :+ (20)
    //val newArr: Array[Int] = arr :+ 20

    println(arr.mkString("--"))
    println(newArr.mkString("--"))





  }
}

实例二：

package com.atguigu.scala.chapter07

import scala.collection.mutable
import scala.collection.mutable.ArrayBuffer

/**
  * Author: Felix
  * Date: 2020/5/4
  * Desc: 可变数组
  *   可变数组，在执行添加或者删除操作的时候，不会创建新的数组对象，直接在源数组上进行操作
  */
object Scala02_TestArrayBuffer {
  def main(args: Array[String]): Unit = {
    //创建可变数组
    //val arr: ArrayBuffer[Int] = new ArrayBuffer[Int]()
    //val arr: ArrayBuffer[Int] = ArrayBuffer(1,2,3)

    //访问数组中的元素  对数组中的元素进行修改
    //arr(1) = 20
    //arr.update(1,30)
    //println(arr(1))

    //向数组中添加元素    建议：在操作集合的时候，不可变用符号，可变用方法
    //val newArr = arr. += (20)
    //arr.append(30)
    //arr.insert(1,50)

    //注意：并不是数组是可变的，在操作数组对象的时候，就不能创建新的数组对象了。  也可以调用相关的方法，去创建新的对象
    //val newArr: ArrayBuffer[Int] = arr.+:(30)
    //println(arr.mkString(","))
    //println(newArr.mkString(","))

    //删除数组中的元素
    //val num: Int = arr.remove(1)
    //println(num)

    //arr.remove(1,2)
    //println(arr.mkString(","))


    //可变数组转换为不可变数组
    val arr: ArrayBuffer[Int] = ArrayBuffer(1,2,3)
    val newArr: Array[Int] = arr.toArray

    //不可变数组转换为可变数组
    val buffer: mutable.Buffer[Int] = newArr.toBuffer

  }
}

实例三：

package com.atguigu.scala.chapter07

/**
  * Author: Felix
  * Date: 2020/5/4
  * Desc: 多维数组
  */
object Scala03_TestMulArray {
  def main(args: Array[String]): Unit = {
    //创建二维数组
    val arr: Array[Array[Int]] = Array.ofDim[Int](2,3)
    arr(1)(0) = 20
    //对二维数组进行遍历
    for ( i <- 0 until arr.length;j <- 0 until(arr(i).length)){
      println(arr(i)(j))
    }

    //创建五维数组
    val newArrr: Array[Array[Array[Array[Array[Int]]]]] = Array.ofDim[Int](2,3,4,5,6)
  }
}