Scala数据结构和算法数组之

数组-定长数组（声明泛型）

第一种方式定义数组

• 说明

这里的数组等同于 Java 中的数组，中括号的类型就是数组的类型 val arr1 = new Array[Int】(10)

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

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 asScalaBuffer[A](l : java.util.List[A]) : 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)

相关大数据开发技术知识：www.atguigu.com