Scala中数组的学习

数组

1.1 定长数组

1.1.1 特点

1. 数组的长度不允许改变
2. 数组的内容是可变的

1.1.2 语法

• 格式一：通过指定长度定义数组

  val/var 变量名 = new Array[元素类型](数组长度)

• 格式二：通过指定元素定义数组

  val/var 变量名 = Array(元素1、元素2、元素3....)

注意：

1. **在scala中，数组的泛型使用[ ]来指定**
1. **使用 数组名(索引) 来获取数组中的元素**
1. **数组元素是有默认值的，数值为：0，字符串为：null**
1. **通过 数值名 .length或者 数组名.size 来获取数组长度**

示例

需求：

1. 定义一个长度为10的整形数组，设置第1个元素为11，并打印第一个元素
2. 定义一个包含“java，python，scala”这三个元素的数组，并打印数组长度

参考代码

object test01 {
  def main(args: Array[String]): Unit = {
    // 	1. 定义一个长度为10的整形数组，设置第1个元素为11，并打印第一个元素
    var a = new Array[Int](10)
    a(0) = 11
    println(a(0))
    // 	2. 定义一个包含“java，python，scala”这三个元素的数组，并打印数组长度
    var b = Array("java","python","scala")
    println(b.length)
  }
}

1.2 变长数组

1.2.1 特点

• 数组的长度和内容都是可变的，可以往数组中添加、删除元素

1.2.2 语法

• 创建变长数组，需要导入ArrayBuffer类

​ import scala.collection.mutable.ArrayBuffer

• 定义格式一：创建空的ArrayBuffer变长数组

​ val/var 变量名 = ArrayBuffer[元素类型]()

• 定义格式二：创建带有初始元素的ArrayBuffer变长数组

​ val/var 变量名 = ArrayBuffer(元素1、元素2、元素2....)

1.2.3 示例一：定义变长数组

1. 定义一个长度为0的整形变长数组
1. 定义一个包含“hadoop”，“storm”，“spark”这三个元素的变长数组
1. 打印结果

参考代码

object test02 {
  def main(args: Array[String]): Unit = {
    // 定义一个长度为0的整形变长数组
    var a  = ArrayBuffer[Int]()
    // 定义一个包含“hadoop”，“storm”，“spark”这三个元素的变长数组
    var b = ArrayBuffer("hadoop","storm","spark")
    // 打印结果
    println(a.length,b)
  }
}

1.2.4 示例二：增删改元素

格式

• 使用 += 添加单个元素
• 使用 -= 删除单个元素
• 使用 ++= 追加一个数组到变长数组中
• 使用 --= 移除变长数组中指定多个元素

示例

1. 定义一个变长数组，包含一下元素：“hadoop”，“spark”，“flink”
2. 往该变长数组中添加一个“flume”元素
3. 从该变长数组中删除“hadoop”元素
4. 将一个包含“hive”，“sqoop”元素的数组，追加到变长数组中
5. 从该变长数组中删除“sqoop”，“spark”这两个元素

参考代码

object test03 {
  def main(args: Array[String]): Unit = {
    //1. 定义一个变长数组，包含一下元素：“hadoop”，“spark”，“flink”
    var a = ArrayBuffer("hadoop","spark","flink")
    println("one times:"+ a)
    //2. 往该变长数组中添加一个“flume”元素
    a += "flume"
    println("two times:" + a)
    //3. 从该变长数组中删除“hadoop”元素
    a -= "hadoop"
    println("three times:" + a)
    //4. 将一个包含“hive”，“sqoop”元素的数组，追加到变长数组中
    a ++= Array("hive","sqoop")
    println("four times:" + a)
    //5. 从该变长数组中删除“sqoop”，“spark”这两个元素
    a --= Array("sqoop","spark")
    println("five times:" + a)
  }
}

1.4 遍历数组

方法：

1. 使用索引遍历数组
2. 使用 for 表达式，直接遍历数组中元素

示例

1. 定义一个数组，包含一下元素1,2,3,4,5
2. 通过两种方法遍历数组，并打印数组中的元素

参考代码

object test04 {
  def main(args: Array[String]): Unit = {
    var a = Array(1,2,3,4,5)
    for(i <-  0 to a.length-1){
      print(s"${a(i)}\t")
    }
    println()
    println("---" * 15)
    for (elem <- a) {
      print(s"${elem}\t")
    }
  }
}

1.5 数组常用算法

算法：

• sum()：求和
• max ()：求最大值
• min()：求最小值
• sorted()：排序，返回一个新的数组
• reverse()：反转，返回一个新的数组

示例

1. 定义一个数组，包含4，1，6，5，2，3
2. 在main方法中，测试上面的常用算法

参考代码

object test05 {
  def main(args: Array[String]): Unit = {
    var a = Array(4,1,6,5,2,3)
    println("sum:"+ a.sum)
    println("min:"+ a.min)
    println("max:" + a.max)
    var b = a.sorted
    var c = a.reverse
    for (elem <- b) {
      println(elem)
    }
    println("-" * 15)
    for (elem <- c) {
      println(elem)
    }
  }
}