Scala学习笔记4: 数组

第四章

1- 定长数组

在Scala中, 定长数组可以使用 Array 类来创建;

定长数组在创建时需要指定数组的长度, 并且长度在整个数组生命周期中保持不变;

示例:

    // 定义一个定长数组
    val fixeArray = new Array[Int](5)
    // 给定长数组赋值
    fixeArray(0) = 1
    fixeArray(1) = 2
    fixeArray(2) = 3
    fixeArray(3) = 4
    fixeArray(4) = 5
    // 遍历数组 并打印
    for (i <- 0 until fixeArray.length) {
      println(fixeArray(i)) // 输出: 1 2 3 4 5
    }
1
2
3
4
5
6
7
8
9
10
11
12

在上面示例中, 我们首先创建了一个长度为5的定长整型数组 fixedArray , 然后分别给数组的每个位置赋值, 并最后通过循环访问并打印数组中的元素;

定长数组在Scala中是一种常见的数据结构, 使用于需要固定长度的情况 .

2- 变长数组

在Scala中, 变长数组通常使用 ArrayBuffer 来实现;

ArrayBuffer 是可变长度的数组, 可以动态添加或删除元素, 是一种常用的数据结构;

示例:

    import scala.collection.mutable.ArrayBuffer
    // 创建一个空的变长数组 ArrayBuffer
    val dynamicArray = new ArrayBuffer[Int]()

    // 向 ArrayBuffer 中添加元素
    dynamicArray += 10
    dynamicArray += 20
    dynamicArray += 30

    // 打印 ArrayBuffer 中的元素
    println(dynamicArray) // 输出: ArrayBuffer(10, 20, 30)

    // 通过循环访问 ArrayBuffer 中的元素
    for (elem <- dynamicArray) {
      println(elem) // 输出: 10 20 30
    }

    // 从ArrayBuffer 中删除元素
    dynamicArray -= 20

    // 打印移除元素后的 ArrayBuffer
    println(dynamicArray) // 输出: ArrayBuffer(10, 30)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

通过使用 ArrayBuffer , 可以方便地操作变长数组, 动态添加或删除元素以满足不同需求 .

3- 遍历数组和数组缓存

在Scala中, 遍历数组可以使用循环结构或者高阶函数来实现;

对应数据缓存, 可以使用 ArrayBuffer 来动态管理数据组大小;

示例:

    // 遍历数组, 数组缓存
    import scala.collection.mutable.ArrayBuffer

    // 创建一个普通数组
    val arr = Array(1, 2, 3, 4, 5)

    // 遍历数组并打印每个元素
    for (elem <- arr) {
      println(elem) // 输出: 1, 2, 3, 4, 5
    }

    for (i <- 0 until arr.length) {
      println(arr(i)) // 输出: 1, 2, 3, 4, 5
    }

    // 使用高阶函数遍历数组
    arr.foreach(elem => println(elem)) // 输出: 1, 2, 3, 4, 5

    // 创建一个数组缓存
    val buffer = ArrayBuffer[Int]()

    // 向数组缓存中添加元素
    buffer += 10
    buffer += 20
    buffer += 30

    // 遍历并打印数组缓存中的元素
    for (elem <- buffer) {
      println(elem) // 输出: 10, 20, 30
    }

    // 使用高阶函数遍历数组缓存
    buffer.foreach(elem => println(elem)) // 输出: 10, 20, 30
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

上面示例, 可以了解如何在Scala中遍历数组以及使用数组缓存;

遍历数组可以通过循环或高阶函数实现, 而数组缓存则可以使用 ArrayBuffer 来动态管理数组大小 .

4- 数组转换

在Scala中, 可以使用 map 函数对数组进行转换;

map 函数可以将数组中的每个元素应用于指定的函数, 并返回一个新的数组, 其中包含应用函数后的结果;

示例:

    val arr = Array(1, 2, 3, 4, 5)

    // 使用 map 函数对数组进行转换, 将每个元素乘2
    val transformedArr = arr.map(x => x * 2)

    // 打印转换后的数组
    println(transformedArr.mkString(", ")) // 输出: 2, 4, 6, 8, 10

    // 增加过滤条件(能被2整除的元素乘2), 数组进行准换
    val filteredArr = arr.filter(x => x % 2 == 0).map(x => x * 2)

    // 打印转换后的数组
    println(filteredArr.mkString(", ")) // 输出: 4, 8
1
2
3
4
5
6
7
8
9
10
11
12
13

在上述示例中, 我们创建了一个整数数组 arr , 然后使用 map 函数对数组中的每个元素进行乘2操作(使用 filter 函数对数组元素进行过滤), 得到一个新的数组, 打印转换后的数组内容 ;

通过使用 map 函数, 可以方便地对数组进行转换操作 .

5- 常用算法

在Scala中, 数组常用的算法包括求和、查找最大最小值、排序以及显示数组内容等操作;

示例:

1. 求和

    // 数组求和
    val arr = Array(1, 2, 3, 4, 5)
    val sum = arr.sum
    println(s"数组元素之和为: $sum") // 输出: 数组元素之和为: 15
1
2
3
4

2. 查找最大最小值

    // 查找数组最大最小值
    val arr = Array(10, 12, 31, 24, 5)
    val max = arr.max
    val min = arr.min
    println(s"max: $max, min: $min") // 输出: max: 31, min: 5
1
2
3
4
5

3. 排序

    // 数组排序
    val arr = Array(1, 3, 2, 5, 4)
    val sortedArr = arr.sorted
    println("数组排序后: " + sortedArr.mkString(",")) // 输出: 数组排序后: 1,2,3,4,5
1
2
3
4

4. 显示数组内容

    // 显示数组内容
    val arr = Array("lyf", "wdf", "fkc")
    for (i <- 0 until arr.length) {
      println(arr(i)) // 输出: lyf wdf kfc
    }
    for (i <- arr) {
      println(i) // 输出: lyf wdf kfc
    }
    for (i <- arr.indices) {
      println(arr(i)) // 输出: lyf wdf kfc
    }
    println(arr.mkString(", ")) // 输出: lyf, wdf, kfc
    arr.foreach(println) // 输出: lyf wdf kfc
1
2
3
4
5
6
7
8
9
10
11
12
13

6- 多维数组

在Scala中, 可以使用多维数组来表示多维数据结构;

通常, 可以使用数组的数组 (Array of Array) 来实现多维数组 ;

示例:

    // 创建一个二维数组表示矩阵
    val matrix = Array.ofDim[Int](3, 3)

    // 初始化二位数组
    matrix(0) = scala.Array(1, 2, 3)
    matrix(1) = scala.Array(4, 5, 6)
    matrix(2) = scala.Array(7, 8, 9)

    // 访问二维数组中的元素
    val element = matrix(1)(2)
    println(s"二维数组中第二行第三列的元素为: $element") // 输出: 二维数组中第二行第三列的元素为: 6
1
2
3
4
5
6
7
8
9
10
11

    // 创建一个二维数组
    val matrix = Array.ofDim[Int](3, 4)

    // 初始化二维数组
    for (i <- 0 until matrix.length) {
      for (j <- 0 until matrix(i).length) {
        matrix(i)(j) = i * j
      }
    }

    // 打印二维数组
    for (i <- 0 until matrix.length) {
      for (j <- 0 until matrix(i).length) {
        print(matrix(i)(j) + " ")
      }
      println() // 换行
    }
    /*
    输出:
    0 0 0 0 
    0 1 2 3 
    0 2 4 6 
    */
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

    // 创建一个二维数组
    val matrix = Array.ofDim[Int](2, 2)

	// 初始化二维数组
    matrix(0)(0) = 1
    matrix(0)(1) = 2
    matrix(1)(0) = 3
    matrix(1)(1) = 4
    for (i <- 0 until matrix.length) {
      for (j <- 0 until matrix(i).length) {
        print(matrix(i)(j) + " ")
      }
      println()
    }
    /*
    输出:
    1 2
    3 4
    */
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

上面示例创建了不同大小的二维数组, 并使用不同的方法初始化二维数组, 访问了二维数组的一个元素或遍历二维数组 .

end