Scala 集合（Array、List、Set、Map、元组、Option）

落日映苍穹つ 2023-02-20 06:19 14阅读 0赞

# 1、数组 #

// 创建数组
        // **** 方式1 ****
        val array = Array[String]("a", "b", "c")
        // **** 方式2 ****
        // (1) 创建类型为String 长度为3的数组
        val array1 = new Array[String](3)
        // (2) 赋值
        array1(0) = "a"
        array1(1) = "s"
        array1(2) = "d"

*  同Java数组，数组包含的元素数据类型相同
 *  scala 数组取值用的是（） java用的是\[\]

### 遍历数组 ###

// 遍历数组
        // 方式1
        for (x <- array) {
          println(x)
        }
        // 方式2
        array1.foreach(x => {
          println(x)
        })
        // 方式3
        for (i <- 0 to (array.length - 1)) {
          println(array(i))
        }

# 2、List #

// 字符串列表
        val list: List[String] = List("百度", "腾讯", "阿里")
        // 二维列表
        val dim: List[List[Int]] =
          List(
            List(1, 0, 0),
            List(0, 1, 0),
            List(0, 0, 1)
          )
        // 1
        for (x <- list) {
          println(x)
        }

*  元素有序可重复，元素类型可以不同
 *  Nil 长度为0的list
 *  遍历方式与数组相同
 *  常用方法：[https://www.runoob.com/scala/scala-lists.html][https_www.runoob.com_scala_scala-lists.html]

# 3、Set #

// 创建
        val set1 = Set(1,2,3,4,4)
        val set2 = Set(1,2,5)
        // 注意：set会自动去重
        set1.foreach(println)
        println("====")
        for(s <- set1) {
          println(s)
        }

*  元素无序，不可重复
 *  创建后set会自动去重
 *  遍历方法同数组、List
 *  常用方法：[https://www.runoob.com/scala/scala-sets.html][https_www.runoob.com_scala_scala-sets.html]

# 4、Map #

Scala映射(`Map`)是一组键/值对的对象。 任何值都可以根据键来进行检索。键在映射中是唯一的，但值不一定是唯一的。映射也称为哈希表。映射有两种，不可变的和可变的。可变对象和不可变对象之间的区别在于，当对象不可变时，对象本身无法更改。

默认情况下，Scala使用不可变映射(`Map`)。如果要使用可变集合(`Map`)，则需要明确导入`scala.collection.mutable.Map`类。如果想同时使用可变的和不可变映射(`Map`)，那么可以继续引用不可变映射(`Map`)，但是可以将`mutable`集合引用`mutable.Map`。

// 创建
        var map = Map("1" -> "a", 2 -> "b", (3, "c"))
        // 添加 键值对
        map += ("k1" -> "V1")
        map += ("k2" -> "V2")
    
        // 取值
        println(map.get("1")) // 返回Some(a)
        println(map("1")) // 返回 a
        println(map.get("1").get) // 返回 a
        println(map.get("6").getOrElse("no value")) // 返回 no value
    
        println("map 中的键为 : " + map.keys) // Set(k2, 2, 1, 3, k1)
        println("map 中的值为 : " + map.values) // MapLike(V2, b, a, c, V1)
        println("检测 map 是否为空 : " + map.isEmpty) // false
    
        // map 遍历
        for (x <- map) {
          println(x) // x 是一个元组:(k2,V2) (2,b)
          println("key: " + x._1 + "\tvalue: " + x._2)// key: k2	value: V2
        }
    
        map.foreach(x => {
          println("key: " + x._1 + "\tvalue: " + x._2)
        })
    
        map.keys.foreach(key => {
          println("key:" + key + ", value:" + map.get(key).get)
        })

*  map中的每一个元素都是一个二元组
 *  如果需要添加 key-value 对，可以使用 + 号
 *  基本操作：keys、values、isEmpty
 *  可以使用 **++** 运算符或 **Map.++()** 方法来连接两个 Map，Map 合并时会移除重复的 key。
    
     *  `++`例：`map1.++(map2)` map1中加入map2
     *  `++:`例：`map1.++:(map2)` map2中加入map1
 *  常用方法：[https://www.runoob.com/scala/scala-maps.html][https_www.runoob.com_scala_scala-maps.html]
    
     *  `filter`：过滤，留下符合条件的记录
     *  `count`：统计符合条件的记录数
     *  `contains`：map中是否包含某个key
     *  `exist`：符合条件的记录存在不存在

# 5、元组 #

Scala元组将固定数量的项目组合在一起，以便它们可以作为一个整体传递。 与数组或列表不同，元组可以容纳不同类型的对象，但它们也是不可变的。

// 创建元组
        val t = (1, 3.14, "Fred")
        val t1 = new Tuple4(2, 4.14, "Fred1", "fff")
        val t2 = Tuple4(2, 4.14, "Fred2", "dddd")
        val t22 = new Tuple22(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22)
        
        // 要访问元组t的元素，可以使用t._1方法访问第一个元素，t._2方法访问第二个元素，依此类推。 
        val sum = t22._1 + t22._2 + t22._3 + t22._10
        println("元素之和为: " + sum)
    
        // 迭代元组
        t2.productIterator.foreach(i => {
          println("Value = " + i)
        })
    
        // 元组转为String
        println("连接后的字符串为: " + t.toString() )

*  与列表一样，元组不可变，但与列表不同在于，元组可以包含不同类型的元素。
 *  元组的值通常是通过单个的值包含在圆括号中构成的
 *  元组的实际类型取决于它的元素的类型
 *  目前Scala支持的元组最大长度为22.对于更大长度可以使用集合，或者扩展元组。
 *  用 ".\_xx" 获取元祖中的值
 *  **Tuple.productIterator()** 方法来迭代输出元组的所有元素

# 6、Option(选项) #

Scala `Option[T]`是由给定类型的零或一个元素的一种容器。`Option[T]`可以是 `Some[T]`或`None`对象（它代表缺少的值）。 例如，如果已找到与给定key对应的value，则Scala的Map的`get`方法会生成`Some(value)`，如果在`Map`中未定义给定的key，则将返回`None`。

`Option`类型在Scala程序中经常使用，可以将其与Java中可用的`null`值进行比较，表示`null`值。 例如，`java.util.HashMap`的`get`方法返回存储在`HashMap`中的值，如果没有找到值，则返回`null`。

Scala Option(选项)类型用来表示一个值是可选的（有值或无值)。

Option\[T\] 是一个类型为 T 的可选值的容器：

*  如果值存在， Option\[T\] 就是一个 Some\[T\] 
 *  如果不存在， Option\[T\] 就是对象 None

val myMap: Map[String, String] = Map("key1" -> "value")
    val value1: Option[String] = myMap.get("key1")
    val value2: Option[String] = myMap.get("key2")
     
    println(value1) // Some("value")
    println(value2) // None
    //如何在没有值的情况下使用getOrElse()方法来访问值或默认值。
          val a:Option[Int] = Some(5)
          val b:Option[Int] = None 
    
          println("a.getOrElse(0): " + a.getOrElse(0) ) // 5
          println("b.getOrElse(10): " + b.getOrElse(10) )// 10
    // isEmpty()方法检查该选项是否为None
          println("b.isEmpty: " + b.isEmpty ) // true

在上面的代码中，myMap 一个是一个 Key 的类型是 String，Value 的类型是 String 的 hash map，但不一样的是他的 get() 返回的是一个叫 Option\[String\] 的类别。

Scala 使用 Option\[String\] 来告诉你：「我会想办法回传一个 String，但也可能没有 String 给你」。

myMap 里并没有 key2 这笔数据，get() 方法返回 None。

Option 有两个子类别，一个是 Some，一个是 None，当他回传 Some 的时候，代表这个函式成功地给了你一个 String，而你可以透过 get() 这个函式拿到那个 String，如果他返回的是 None，则代表没有字符串可以给你。

常用方法：[https://www.runoob.com/scala/scala-options.html][https_www.runoob.com_scala_scala-options.html]

*  isEmpty()
 *  getOrElse()

[https_www.runoob.com_scala_scala-lists.html]: https://www.runoob.com/scala/scala-lists.html
[https_www.runoob.com_scala_scala-sets.html]: https://www.runoob.com/scala/scala-sets.html
[https_www.runoob.com_scala_scala-maps.html]: https://www.runoob.com/scala/scala-maps.html
[https_www.runoob.com_scala_scala-options.html]: https://www.runoob.com/scala/scala-options.html