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)