【Scala】集合总结（一）——Array、List、Set、Map、Tuple的创建、访问、遍历方法

一、Scala集合简介

（1）Scala 的集合有三大类：序列 Seq 、集 Set 、映射 Map ，所有的集合都扩展自 Iterable 特质。

（2）对于几乎所有的集合类， Scala 都同时提供了 可变 和 不可变 的版本，分别位于以下两

个包：

不可变集合： scala.collection. immutable

可变集合： scala.collection. mutable

（3 ） Scala 不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而

不会对原对象进行修改。类似于 java 中的 String 对象

（4 ）可变集合，就是这个集合可以直接对原对象进行修改，而不会返回新的对象。类似

于 java 中 StringBuilder 对象

二、各集合的创建方式对比

 Array 数组：

不可变数组：
    
    // 1. 创建数组
    val arr: Array[Int] = new Array[Int](5)

    // 另一种创建方式
    val arr2 = Array(12, 37, 42, 58, 97)

可变数组：

    val arr1: ArrayBuffer[Int] = new ArrayBuffer[Int]()
    val arr2 = ArrayBuffer(23, 57, 92)

// 1. 创建二维数组
    val array: Array[Array[Int]] = Array.ofDim[Int](2, 3)
    

List：

// 不可变List

val list1 = List(23, 65, 87)

// 可变List

val list1: ListBuffer[Int] = new ListBuffer[Int]()
val list2 = ListBuffer(12, 53, 75)

Set：

// 不可变Set

val set1 = Set(13, 23, 53, 12, 13, 23, 78)

// 可变Set

val set1: mutable.Set[Int] = mutable.Set(13, 23, 53, 12, 13, 23, 78)

Map：

// 不可变Map

val map1: Map[String, Int] = Map("a" -> 13, "b" -> 25, "hello" -> 3)

// 可变Map

val map1: mutable.Map[String, Int] = mutable.Map("a" -> 13, "b" -> 25, "hello" -> 3)

Tuple（元组）：

val tuple: (String, Int, Char, Boolean) = ("hello", 100, 'a', true)

三、各集合的遍历方式对比

  Array 数组：

// 不可变数组和可变数组的访问、遍历方式一致
// 访问元素：下标从0开始
    println(arr(0))
    println(arr(1))

// 1) 普通for循环
    for (i <- 0 until arr.length){
      println(arr(i))
    }

    for (i <- arr.indices) println(arr(i))


// 2) 增强for循环
    for (elem <- arr2) println(elem)


// 3) 迭代器
    val iter = arr2.iterator
    while (iter.hasNext)
      println(iter.next())


// 4) 调用foreach方法
    arr2.foreach( (elem: Int) => println(elem) )
    arr.foreach( println )
    println(arr2.mkString("--"))
    

List：（访问、遍历方式与数组一样）

Set：（访问、遍历方式与数组一样）

Map：

// 2. 遍历元素

    map1.foreach(println)

    map1.foreach( (kv: (String, Int)) => println(kv) )

    for (elem <- map1) {
      println(elem)
    }


// 3. 取map中所有的key 或者 value

    for (key <- map1.keys){
      println(s"$key ---> ${map1.get(key)}")
    }

// 4. 访问某一个key的value
    println("a: " + map1.get("a").get)
    println("c: " + map1.get("c"))
    println("c: " + map1.getOrElse("c", 0))

Tuple（元组）：

// 2. 访问数据
    println(tuple._1)
    println(tuple._2)

    println(tuple.productElement(1))
    println(tuple.productElement(2))

// 3. 遍历元组数据
    for (elem <- tuple.productIterator){
      println(elem)
    }