关于大数据:Scala数据结构和算法之数组

60次阅读

共计 4376 个字符，预计需要花费 11 分钟才能阅读完成。

数组 - 定长数组 (申明泛型)
第一种形式定义数组
阐明

这里的数组等同于 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)

正文完
大数据
发表至： 大数据
2021-09-14
 0
关于druid:OLAP引擎基于Druid组件进行数据统计分析
关于大数据:深度解读MRS-IoTDB时序数据库的整体架构设计与实现
关于大数据:再拔头筹FusionInsight为华为云大数据打造硬实力
关于大数据:基于-Impala-的高性能数仓实践之物化视图服务