定长数组
特点：
- 1.长度可变
- 2.内容不可变
语法格式：
- 1.通过指定长度定义数组
- val/var 变量名 = new Array[元素类型](数组长度)
- 2.通过指定元素定义数组
- val/var 变量名 = Array(元素1, 元素2, 元素3…)
注意：
- 1.在Scala中数组的泛型使用[]来指定。
- 2.使用 数组名(索引) 来获取数组中的元素。
- 3.数组元素是有默认值的，Int:0，Double:0，String:null。
- 4.通过 数组名.length 或者通过 数组名.size 来获取数组的长度。在Java中数组只能是length方法获取长度，而集合是使用size方法来获取长度。
代码实例：
object 定长数组 {
def main(args: Array[String]): Unit = {
//1.定义一个长度为10的整数类型数组，设置第一个元素为11，并且打印出第一个数组
var arr1 = new Array[Int](10)
arr1(0) = 11
println(arr1(0))
println("-" * 15)
//2.定义一个包含"Java" "Scala" "Python" 这三个元素的数组，并且打印数组长度。
val arr2 = Array("Java","Scala","Python")
println(arr2.length)
println(arr2.size)
}
}
运行结果：
11
---------------
3
3
变长数组
特点：
- 数组的长度和内容都是不可变的，可以往数组中添加、删除元素
语法：
- 创建变长数组，首先需要导入 ArrayBuffer 类。
- import scala.collection.mutable.ArrayBuffer
- 定义格式1：创建空的 ArrayBuffer 变长数组。
- val/var 变量名 = ArrayBuffer[元素类型]()
- 定义格式2：创建带有初始元素的ArrayBuffer变长数组
- val/var 变量名 = ArrayBuffer(元素1，元素2，元素3…)
代码示例：
- 定义一个长度为0的整型变长数组.
- 定义一个包含"hadoop", “storm”, "spark"这三个元素的变长数组.
- 打印结果
import scala.collection.mutable.ArrayBuffer
object 变长数组 {
def main(args: Array[String]): Unit = {
var arr1 = new ArrayBuffer[Int]()
println("arr1:" + arr1)
val arr2 = ArrayBuffer("hadoop","Storm","Spark")
println("arr2:" + arr2)
}
}
增删改元素
针对Scala中的变长数组, 可通过下述方式来修改数组中的内容
格式：
- 使用 += 添加单个元素
- 使用 -= 删除单个元素
- 使用 ++= 追加一个数组到变长数组中
- 使用 --= 移除变长数组中的指定多个元素
代码实例：
- 定义一个变长数组，包含以下元素: “hadoop”, “spark”, “flink”
- 往该变长数组中添加一个"flume"元素
- 从该变长数组中删除"hadoop"元素
- 将一个包含"hive", "sqoop"元素的数组, 追加到变长数组中.
- 从该变长数组中删除"sqoop", "spark"这两个元素.
- 打印数组, 查看结果
import scala.collection.mutable.ArrayBuffer
object 变长数组 {
def main(args: Array[String]): Unit = {
//1. 定义一个变长数组，包含以下元素: "hadoop", "spark", "flink"
var arr = ArrayBuffer("hadoop","spark","flink")
//2. 往该变长数组中添加一个"flume"元素
arr += "flume"
//3. 从该变长数组中删除"hadoop"元素
arr -= "hadoop"
//4. 将一个包含"hive", "sqoop"元素的数组, 追加到变长数组中.
arr ++= Array("hive", "sqoop")
//5. 从该变长数组中删除"sqoop", "spark"这两个元素.
arr --= Array("sqoop", "spark")
//6. 打印数组, 查看结果.
println(s"arr: ${arr}")
}
}
运行结果：
arr: ArrayBuffer(flink, flume, hive)
遍历数组
在Scala中, 可以使用以下两种方式来遍历数组：
- 1.使用 索引 遍历数组中的元素
- 2.使用 for表达式 直接遍历数组中的元素
代码示例：
- 定义一个数组，包含以下元素1,2,3,4,5
- 通过两种遍历方式遍历数组，并打印数组中的元素
object 遍历数组 {
def main(args: Array[String]): Unit = {
//1. 定义一个数组，包含以下元素1,2,3,4,5
val arr = Array(1, 2, 3, 4, 5)
//2. 通过两种遍历方式遍历数组，并打印数组中的元素.
// 方式一: 遍历索引的形式实现.
for(i <- 0 to arr.length-1) println(arr(i))
println("-" * 15) //分割线
for(i <- 0 until arr.length) println(arr(i))
println("-" * 15) //分割线
//方式二: 直接遍历数组元素.
for(i <- arr) println(i)
}
}
注意：
- 0 until n 获取0~n之间的所有整数, 包含0, 不包含n
- 0 to n 获取0~n之间的所有整数, 包含0, 也包含n
数组常用算法
Scala中的数组封装了一些常用的计算操作，将来在对数据处理的时候，不需要我们自己再重新实现, 而是可以直接拿来用。以下为常用的几个算法：
- sum()方法: 求和、
- max()方法: 求最大值
- min()方法: 求最小值
- sorted()方法: 排序, 返回一个新的数组.
- reverse()方法: 反转, 返回一个新的数组.
代码实例：
- 定义一个数组, 包含4, 1, 6, 5, 2, 3这些元素. 、
- 在main方法中, 测试上述的常用算法
object 数组方法 {
def main(args: Array[String]): Unit = {
//1. 定义一个数组, 包含4, 1, 6, 5, 2, 3这些元素.
var arr = Array(4, 1, 6, 5, 2, 3)
//2. 在main方法中, 测试上述的常用算法.
println(s"sum: ${arr.sum}")
println(s"max: ${arr.max}")
println(s"min: ${arr.min}")
val arr2 = arr.sorted //即: arr2的内容为:1, 2, 3, 4, 5, 6
val arr3 = arr.sorted.reverse //即: arr3的内容为: 6, 5, 4, 3, 2, 1
for(i <- arr) println(i)
println("-"*15)
for(i <- arr2) println(i)
println("-"*15)
for(i <- arr3) println(i)
}
}
运行结果：
sum: 21
max: 6
min: 1
4
1
6
5
2
3
---------------
1
2
3
4
5
6
---------------
6
5
4
3
2
1