Scala - 快速学习05 - 数据结构

1- 数组（Array）

数组一般包括定长数组和变长数组。

可以不指明数组类型，Scala会自动根据提供的初始化数据来推断出数组的类型。

在Scala中，对数组元素的应用，是使用圆括号，而不是方括号。

示例：定长数组

就是长度不变的数组，在Scala中使用Array进行声明。

  val myIntArr = new Array[Int](3)                //> myIntArr  : Array[Int] = Array(0, 0, 0)
  myIntArr(0) = 111
  myIntArr(1) = 222
  myIntArr(2) = 333
  for (i <- 0 to 2) println(myIntArr(i))          //> 111
                                                  //| 222
                                                  //| 333

  val myStrArr = new Array[String](3)             //> myStrArr  : Array[String] = Array(null, null, null)
  myStrArr(0) = "AAA"
  myStrArr(1) = "BBB"
  myStrArr(2) = "CCC"
  for (i <- 0 to 2) println(myStrArr(i))          //> AAA
                                                  //| BBB
                                                  //| CCC

  val myIntArr2 = Array(123, 456, 789)            //> myIntArr2  : Array[Int] = Array(123, 456, 789)
  val myStrArr2 = Array("aaa", "bbb", "ccc")      //> myStrArr2  : Array[String] = Array(aaa, bbb, ccc)

注意：数组元素的初始化值

• 整型数组，每个数组元素初始化为0
• 字符串数组，每个数组元素初始化为null

2- 列表（List）

列表是相同类型值的聚集，各个元素必须是相同类型。

列表有头部和尾部的概念，头部是一个元素，而尾部则仍然是一个列表。

• 可以使用intList.head来获取列表的头部
• 可以使用intList.tail来获取列表的尾部
• 可以使用“::”操作符，可以在列表的头部增加新的元素，也可以构建列表
• 可以使用:::操作符对不同的列表进行连接得到新的列表

Scala列表具备常用的方法。

  val intList = List(1, 2, 3)                     //> intList  : List[Int] = List(1, 2, 3)
  val intList2 = 4 :: 5 :: 6 :: Nil               //> intList2  : List[Int] = List(4, 5, 6)
  val initList3 = 0 :: intList                    //> initList3  : List[Int] = List(0, 1, 2, 3)
  val initList4 = intList ::: intList2            //> initList4  : List[Int] = List(1, 2, 3, 4, 5, 6)
  initList4.sum                                   //> res0: Int = 21

3- 元组(Tuple)

元组是不同类型值的聚集，可以包含不同类型的元素。

  val myTuple = ("AAA", 111, 'v')                 //> myTuple  : (String, Int, Char) = (AAA,111,v)
  println(myTuple._1)                             //> AAA
  println(myTuple._2)                             //> 111
  println(myTuple._3)                             //> v

4- 集（Set）

集是不重复元素的集合，包括可变集和不可变集，都可以进行添加或删除元素的操作。

• 对不可变集进行操作，会产生一个新的集，原来的集并不会发生变化。
• 对可变集进行操作，改变的是该集本身。

缺省情况下创建的是不可变集，通常使用不可变集。

集不会记录元素的插入顺序，而是以“哈希”方法对元素的值进行组织，可以快速地找到某个元素。

  var mySet = Set("AAA", "BBB")                   //> mySet  : scala.collection.immutable.Set[String] = Set(AAA, BBB)
  mySet += "CCC"
  println(mySet.contains("CCC"))                  //> true

注意：这里使用var声明一个可变集合，如果使用val则会报错。

声明一个可变集，需要引入scala.collection.mutable.Set包。

package testscala
import scala.collection.mutable.Set

object TestScala {
  def main(args: Array[String]) {
    val myMutableSet = Set("AAA", "BBB")
    myMutableSet += "ccc"
    println(myMutableSet)
  }
}

注意：虽然声明myMutableSet为val变量，但由于其是可变集，所以能够可以正确执行myMutableSet += "ccc"，不会报错。

5- 映射(Map)

映射(Map)是一系列键值对的集合。在映射中，所有的值都可以通过键来获取。

映射包括可变和不可变两种，默认情况下创建的是不可变映射。

• 不可变映射，是无法更新映射中的元素的，也无法增加新的元素。
• 可变映射，可以更新和添加映射的元素，但在创建时需要引入scala.collection.mutable.Map包。

使用contains方法可以检查映射中是否包含某个值。

  val test = Map("111" -> "AAA", 222 -> "BBB", "333" -> "CCC")
                                                  //> test  : scala.collection.immutable.Map[Any,String] = Map(111 -> AAA, 222 -> B
                                                  //| BB, 333 -> CCC)
  println(test("111"))                            //> AAA
  println(test(222))                              //> BBB
  if (test.contains("333")) test("333") else 0    //> res0: Any = CCC

示例：可变映射

  import scala.collection.mutable.Map
  val test2 = Map(1 -> "a", 2 -> "b")             //> test2  : scala.collection.mutable.Map[Int,String] = Map(2 -> b, 1 -> a)
  test2(1) = "A"
  test2(3) = "d"
  test2 += (4 -> "d", 5 -> "e")                   //> res0: testrepl.test2.type = Map(2 -> b, 5 -> e, 4 -> d, 1 -> A, 3 -> d)

注意：可以使用+=操作来添加新的元素

示例：循环遍历映射

• 循环遍历映射的基本格式：for ((k,v) <- 映射) 语句块
• 可以同时遍历k和v，也可以只遍历映射中的k或者v

  val test3 = Map("1" -> "AAA", "2" -> "BBB", "3" -> "CCC")
                                                  //> test3  : scala.collection.immutable.Map[String,String] = Map(1 -> AAA, 2 -> B
                                                  //| BB, 3 -> CCC)
  for ((k, v) <- test3) printf("Key is : %s and Value is: %s\n", k, v)
                                                  //> Key is : 1 and Value is: AAA
                                                  //| Key is : 2 and Value is: BBB
                                                  //| Key is : 3 and Value is: CCC
  for (k <- test3.keys) println(k)                //> 1
                                                  //| 2
                                                  //| 3
  for (v <- test3.values) println(v)              //> AAA
                                                  //| BBB
                                                  //| CCC
  for (x <- test3) println(x)                     //> (1,AAA)
                                                  //| (2,BBB)
                                                  //| (3,CCC)

6- 迭代器(Iterator)

迭代器不是一个集合，而是提供了访问集合的一种方法，适用于需要很大开销操作集合的情况。

迭代器包含两个基本操作：next和hasNext。

• next可以返回迭代器的下一个元素
• hasNext用于检测是否还有下一个元素

利用这两个基本操作，可以通过while循环或者for循环实现对迭代器的遍历。

  val iter = Iterator("AAA", "BBB", "CCC")        //> iter  : Iterator[String] = non-empty iterator
  while (iter.hasNext) {
    println(iter.next())
  }                                               //> AAA
                                                  //| BBB
                                                  //| CCC
  val iter2 = Iterator("111", "222", "333")       //> iter2  : Iterator[String] = non-empty iterator
  for (elem <- iter2) {
    println(elem)                                 //> 111
                                                  //| 222
                                                  //| 333

7 - 示例

排序示例-1：

  def qSort(x: List[Int]): List[Int] = {
    if (x.length <= 2) x
    else qSort(x.filter(x.head > _)) ++
      x.filter(x.head == _) ++
      qSort(x.filter(x.head < _))
  }                                               //> qSort: (x: List[Int])List[Int]

  qSort(List(6, 4, 5, 3, 1, 2, 9, 8, 0, 7))       //> res0: List[Int] = List(0, 1, 2, 3, 4, 5, 6, 8, 7, 9)

排序示例-2：

  def qSort(y: List[Int]): List[Int] =
    if (y.length < 2) y
    else qSort(y.filter(_ < y.head)) ++
      y.filter(_ == y.head) ++
      qSort(y.filter(_ > y.head))                 //> qSort: (y: List[Int])List[Int]

  qSort(List(6, 4, 5, 3, 1, 2, 9, 8, 0, 7))       //> res0: List[Int] = List(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)