Scala数组Array/ArrayBuffer和集合Set

数组

概述

数组就是用来存储多个同类型元素的容器, 每个元素都有编号(也叫: 下标, 脚标, 索引), 且编号都是从0开始数的.

分类

定长数组

1. 特点

• 数组的长度不允许改变
• 数组

2. 语法
   格式一：通过制定长度定义数组

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

格式二：通过添加数组元素定义数据

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

注：

在scala中，数组的泛型使用[]来指定
使用数组名(索引值)来获取数组中的元素
数组元素是有默认值的，Int:0，Double：0.0，String:null
通过数组名.length或者数组名.size来获取数组的长度

3. 示例代码

object 不可变数组 {
  def main(args: Array[String]): Unit = {
    //1.格式一：
    //1.1定义一个长度为5的整型数组ints
    val ints = new Array[Int](5)
    //1.2赋值
    ints(0)=1
    ints(1)=2
    ints(2)=3
    ints(3)=4
    ints(4)=5

    //1.3获取ints长度
    println(ints.length)
    //或
    println(ints.size)

    //1.4获取索引为0的元素
    println(ints(0))

    //1.5遍历数组
    for (elem <- ints) {
      println(elem)
    }

    //2.格式2：
    //2.1定义一个包含java，scala的数组
    val array = Array("java","scala");
    //2.2打印数组长度
    println(array.length)
  }
}

变长数组

1. 特点

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

2. 语法

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

import scala.collection.mutable.ArrayBuffer

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

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

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

val/var 变量名 = ArrayBuffer(元素1，元素2，元素3....)

3. 示例代码

import scala.collection.mutable.ArrayBuffer
object 可变数组 {
  def main(args: Array[String]): Unit = {
    //1.格式一
    //1.1创建一个空的变长数组
    val arr1= new ArrayBuffer[Int]()
    //1.2插入数据,第一个参数为索引，第二个为值
    arr1.insert(0,1)
    arr1.insert(1,2)
    arr1.insert(2,3)
    //1.3打印
    println(s"arr1：${arr1}")

    //2.格式二
    //2.1定义一个包含"hadoop", "storm", "spark"这三个元素的变长数组
    val arr2 = ArrayBuffer("hadoop", "storm", "spark")
    //2.2打印
    println(s"arr2：${arr2}")
  }
}

增删改可变数组

针对Scala中的变长数组, 可通过下述方式来修改数组中的内容：
使用 += 添加单个元素
使用 -= 删除单个元素
使用 ++= 追加一个数组到变长数组中
使用 --= 移除变长数组中的指定多个元素

示例
1. 定义一个变长数组，包含以下元素: "hadoop", "spark", "flink"
2. 往该变长数组中添加一个"flume"元素
3. 从该变长数组中删除"hadoop"元素
4. 将一个包含"hive", "sqoop"元素的数组, 追加到变长数组中. 
5. 从该变长数组中删除"sqoop", "spark"这两个元素. 
6. 打印数组, 查看结果.

参考代码：
//导包 import scala.collection.mutable.ArrayBuffer 
//案例: 修改变长数组中的内容. 
import scala.collection.mutable.ArrayBuffer
object 增删改可变数组 {
  def main(args: Array[String]): Unit = {
    //1. 定义一个变长数组，包含以下元素: "hadoop", "spark", "flink"
    val arr1 = ArrayBuffer("hadoop", "spark", "flink")
    //2. 往该变长数组中添加一个"flume"元素
    arr1 += "flume"
    //3. 从该变长数组中删除"hadoop"元素
    arr1 -= "hadoop"
    //4. 将一个包含"hive", "sqoop"元素的数组, 追加到变长数组中.
    arr1 ++= Array("hive", "sqoop")
    //5. 从该变长数组中删除"sqoop", "spark"这两个元素.
    arr1 --= Array("sqoop", "spark")
    //6. 打印数组, 查看结果.
    println(arr1)
  }
}

数组常用算法

sum()方法: 求和
max()方法: 求最大值
min()方法: 求最小值
sorted()方法: 排序, 返回一个新的数组.
reverse()方法: 反转, 返回一个新的数组.

集合

概述

Set：代表没有重复元素的集合
特点

• 唯一：集合中的元素唯一，不会重复第二次
• 无序：Set集合中的元素，添加顺序和取出顺序不一致

分类

不可变集合

概述
不可变集指的是元素, 集的长度都不可变的集合

语法

格式一: 创建一个空的不可变集
val/var 变量名 = Set[类型]()

格式二: 给定元素来创建一个不可变集
val/var 变量名 = Set(元素1, 元素2, 元素3...)

示例代码

object 不可变集合 {
  def main(args: Array[String]): Unit = {
    //1. 定义一个空的整型不可变集.
    val set1 = Set[Int]()
    //2. 定义一个不可变集，保存以下元素：1,1,3,2,4,8.
    val set2 = Set[Int](1,1,3,2,4,8)
    //打印结果.
    println(s"set1：${set1}")
    println(s"set2：${set2}")
  }
}

不可变集的常见操作
格式

1. 获取集的大小（ size ）
2. 遍历集（ 和遍历数组一致 ）
3. 添加一个元素，生成一个新的Set（ + ）
4. 拼接两个集，生成一个新的Set（ ++ ）
5. 拼接集和列表，生成一个新的Set（ ++ ）

object 不可变集的常见操作 {
  def main(args: Array[String]): Unit = {
    //1. 创建一个集，包含以下元素：1,1,2,3,4,5
    val set1 = Set[Int](1, 1, 2, 3, 4, 5)
    //2. 获取集的大小, 并打印结果.
    println(set1.size)
    //3. 遍历集，打印每个元素.
    for (elem <- set1) {
      print(elem+" ")
    }
    println()
    //4. 删除元素1，生成新的集, 并打印.
    val set2 = set1 - 1
    println(s"set2:${set2}")
    //5. 拼接另一个集Set(6, 7, 8), 生成新的集, 并打印.
    val set3 = set1 ++ Set(6, 7, 8)
    println(s"set3:${set3}")
    //6. 拼接一个列表List(6,7,8, 9), 生成新的集, 并打印.
    val list = List(6, 7, 8, 9)
    val set4 = set1 ++ list
    println(s"set4:${set4}")
  }
}

可变集合

概念
可变集指的是元素, 集的长度都可变, 它的创建方式和不可变集的创建方式一致，只不过需要先导入可变集类。

手动导入： import scala.collection.mutable.Set

示例代码

import  scala.collection.mutable.Set
object 可变集合场景操作 {
  def main(args: Array[String]): Unit = {
    //1. 定义一个可变集，包含以下元素: 1,2,3, 4
    val set1 = Set(1, 2, 3, 4)
    //2. 添加元素5到可变集中
    set1.add(5)
    //3. 添加元素6, 7, 8到可变集中
    set1.add(6)
    set1.add(7)
    set1.add(8)
    //4. 从可变集中移除元素1
    set1 -= 1
    //5. 从可变集中移除元素3, 5, 7
    set1 --= List(3,5,7)

    //6. 打印结果.
    println(s"set1:${set1}")
  }
}