头图

Scala数据结构和算法之数组

IT小尚

数组-定长数组(声明泛型)
第一种方式定义数组
说明

这里的数组等同于 Java 中的数组,大数据培训中括号的类型就是数组的类型 val arr1 = new ArrayInt

//赋值,集合元素采用小括号访问

arr1(1) =7

代码演示

package com.ldc

object ArrayDemo01 {

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

    //说明

    // 1. 创建了一个 Array 对象,

    // 2. [Int] 表示泛型,即该数组中,只能存放 Int

    // 3. [Any] 表示 该数组可以存放任意类型

    // 4. 在没有赋值情况下,各个元素的值 0

    // 5.  arr01(3) = 10 表示修改 第 4 个元素的值

    val arr01 = new Array[Int](4) //底层 int[] arr01 = new int[4]

    println(arr01.length) // 4

    println("arr01(0)=" + arr01(0)) // 0

    // 数据的遍历

    for (i <- arr01) {

        println(i)

    }

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

    arr01(3) = 10

    for (i <- arr01) {

        println(i)

    }

}

}

第二种方式定义数组
说明

在定义数组时,直接赋值 //使用 apply 方法创建数组对象 val arr1 = Array(1, 2)

代码演示

package com.ldc

object ArrayDemo02 {

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

    //说明

    // 1. 使用的是 object Array 的 apply

    // 2. 直接初始化数组,这时因为你给了 整数和 "", 这个数组的泛型就 Any

    // 3. 遍历方式一样

    var arr02 = Array(1, 3, "xx")

    arr02(1) = "xx"

    for (i <- arr02) {

        println(i)

    }

    //可以使用我们传统的方式遍历,使用下标的方式遍历

    for (index <- 0 until arr02.length) {

        printf("arr02[%d]=%s", index, arr02(index) + "\t")

    }

}

}

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

//定义/声明 val arr2 = ArrayBufferInt//追加值/元素 arr2.append(7) //重新赋值 arr2(0) = 7

代码演示

package com.ldc

import scala.collection.mutable.ArrayBuffer

object ArrayBufferDemo01 {

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

    //创建 ArrayBuffer

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

    //访问,查询//通过下标访问元素

    println("arr01(1)=" + arr01(1)) // arr01(1) = 2

    // 遍历

    for (i <- arr01) {

        println(i)

    }

    println(arr01.length) //3

    println("arr01.hash=" + arr01.hashCode())

    //修改 [修改值,动态增加]

    //使用 append 追加数据 ,append 支持可变参数

    //可以理解成 java 的数组的扩容

    arr01.append(90.0, 13) // (3,2,5,90.0,13)

    println("arr01.hash=" + arr01.hashCode())

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

    arr01(1) = 89 //修改 (3,89,5,90.0,13)

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

    for (i <- arr01) {

        println(i)

    }

    //删除...

    // 删除,是根据下标来说

    arr01.remove(0) // (89,5,90.0,13)

    println("--------删除后的元素遍历---------------")

    for (i <- arr01) {

        println(i)

    }

    println("最新的长度=" + arr01.length) // 4

}

}

变长数组分析总结

1) ArrayBuffer 是变长数组,类似 java 的 ArrayList

2) val arr2 = ArrayBufferInt 也是使用的 apply 方法构建对象

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

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

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

在开发中,我们可能使用对定长数组和变长数组,进行转换 arr1.toBuffer //定长数组转可变数组 arr2.toArray //可变数组转定长

注意事项:

arr2.toArray 返回结果才是一个定长数组, arr2 本身没有变化 arr1.toBuffer 返回结果才是一个可变数组, arr1 本身没有

代码演示

package com.ldc

import scala.collection.mutable.ArrayBuffer

object Array22ArrayBuffer {

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

    val arr2 = ArrayBuffer[Int]()

    // 追加值

    arr2.append(1, 2, 3)

    println(arr2)

    //说明

    //1. arr2.toArray 调用 arr2 的方法 toArray

    //2. 将 ArrayBuffer ---> Array

    //3. arr2 本身没有任何变化

    val newArr = arr2.toArray

    println(newArr)

    //说明

    //1. newArr.toBuffer 是把 Array->ArrayBuffer

    //2. 底层的实现

    /*

        override def toBuffer[A1 >: A]: mutable.Buffer[A1] = {

            val result = new mutable.ArrayBuffer[A1](size)

            copyToBuffer(result)

            result

        }

    */

    //3. newArr 本身没变化

    val newArr2 = newArr.toBuffer

    newArr2.append(123)

    println(newArr2)

}

}

多维数组的定义和使用
说明

//定义 val arr = Array.ofDimDouble//说明:二维数组中有三个一维数组,每个一维数组中有四个元素 //赋值 arr(1)(1) = 11.

代码演示

package com.ldc

object MultiplyArray {

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

    //创建

    val arr = Array.ofDim[Int](3, 4)

    //遍历

    for (item <- arr) { //取出二维数组的各个元素(一维数组)

        for (item2 <- item) { // 元素(一维数组) 遍历

            print(item2 + "\t")

        }

        println()

    }

    //指定取出

    println(arr(1)(1)) // 0

    //修改值

    arr(1)(1) = 100

    //遍历

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

    for (item <- arr) { //取出二维数组的各个元素(一维数组)

        for (item2 <- item) { // 元素(一维数组) 遍历

            print(item2 + "\t")

        }

        println()

    }

    //使用传统的下标的方式来进行遍历

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

    for (i <- 0 to arr.length - 1) { //先对

        for (j <- 0 to arr(i).length - 1) {

            printf("arr[%d][%d]=%d\t", i, j, arr(i)(j))

        }

        println()

    }

}

}

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

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

代码演示

package com.ldc

import scala.collection.mutable.ArrayBuffer

object ArrayBuffer2JavaList {

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

    // Scala 集合和 Java 集合互相转换

    val arr = ArrayBuffer("1", "2", "3")

    /*

    implicit def bufferAsJavaList[A](b : scala.collection.mutable.Buffer[A]) : java.util.List[A] = {

    /compiled code 

    */

    import scala.collection.JavaConversions.bufferAsJavaList

    //对象 ProcessBuilder , 因为 这里使用到上面的 bufferAsJavaList

    val javaArr = new ProcessBuilder(arr) //为什么可以这样使用?

    // 这里 arrList 就是 java 中的List

    val arrList = javaArr.command()

    println(arrList) //输出 [1, 2, 3]

}

}

补充了一个多态(使用trait来实现的参数多态)的知识点

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 的 ArrayBuffer

//说明

//1. asScalaBuffer 是一个隐式函数

/*

implicit def asScalaBufferA : scala.collection.mutable.Buffer[A] = { /* compiled

code */ }

*/

import scala.collection.JavaConversions.asScalaBuffer

import scala.collection.mutable

// java.util.List ==> Buffer

val scalaArr: mutable.Buffer[String] = arrList

scalaArr.append("jack")

scalaArr.append("tom")

scalaArr.remove(0)

println(scalaArr) // (2,3,jack,tom)

阅读 115

尚硅谷IT培训学习爱好分享者

6 声望
0 粉丝
0 条评论
你知道吗?

尚硅谷IT培训学习爱好分享者

6 声望
0 粉丝
宣传栏