scala的数据结构

数据结构
5.1  数据结构特点

Scala同时支持可变集合和不可变集合，不可变集合从不可变，可以安全的并发访问。

两个主要的包：

不可变集合：scala.collection.immutable

可变集合：  scala.collection.mutable

Scala优先采用不可变集合，对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本。

不可变集合继承层次：

5.2  数组 Array

1) 定长数组

//定义    val arr1 = new Array[Int](10)    //赋值    arr1(1) = 7    或：    //定义    val arr1 = Array(1, 2)

2) 变长数组

//定义    val arr2 = ArrayBuffer[Int]()    //追加值    arr2.append(7)    //重新赋值    arr2(0) = 7

3) 定长数组与变长数组的转换

arr1.toBuffer    arr2.toArray

4) 多维数组

//定义    val arr3 = Array.ofDim[Double](3,4)    //赋值    arr3(1)(1) = 11.11

5) 与Java数组的互转

Scal数组转Java数组：

val arr4 = ArrayBuffer("1",  "2", "3")    //Scala to Java    import  scala.collection.JavaConversions.bufferAsJavaList    val javaArr = new ProcessBuilder(arr4)    println(javaArr.command())

Java数组转Scala数组：

import  scala.collection.JavaConversions.asScalaBuffer    import scala.collection.mutable.Buffer    val scalaArr: Buffer[String] =  javaArr.command()    println(scalaArr)

6) 数组的遍历

for(x <- arr1) {       println(x)    }

5.3  元组 Tuple

元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据。

1)  元组的创建

val tuple1 = (1, 2, 3, "heiheihei")    println(tuple1)

2)  元组数据的访问，注意元组元素的访问有下划线，并且访问下标从1开始，而不是0

val value1 = tuple1._4    println(value1)

3)  元组的遍历

方式1：

for (elem <- tuple1.productIterator) {       print(elem)    }    println()

方式2：

tuple1.productIterator.foreach(i =>  println(i))    tuple1.productIterator.foreach(print(_))

5.4  列表 List

如果List列表为空，则使用Nil来表示。

1)  创建List

val list1 = List(1, 2)    println(list1)

2)  访问List元素

val value1 = list1(1)    println(value1)

3)  List元素的追加

val list2 = list1 :+ 99    println(list2)    val list3 = 100 +: list1    println(list3)

4)  List的创建与追加，符号“::”，注意观察去掉Nil和不去掉Nil的区别

val list4 = 1 :: 2 :: 3 :: list1 :: Nil    println(list4)

5.5  队列 Queue

队列数据存取符合先进先出策略

1)  队列的创建

import scala.collection.mutable    val q1 = new mutable.Queue[Int]    println(q1)

2)  队列元素的追加

q1 += 1;    println(q1)

3)  向队列中追加List

q1 ++= List(2, 3, 4)    println(q1)

4)  按照进入队列的顺序删除元素

q1.dequeue()    println(q1)

5)  塞入数据

q1.enqueue(9, 8, 7)    println(q1)

6)  返回队列的第一个元素

println(q1.head)

7)  返回队列最后一个元素

println(q1.last)

8)  返回除了第一个以外的元素

println(q1.tail)

5.6  映射 Map

这个地方的学习，就类比Java的map集合学习即可。

1)  构造不可变映射

val map1 = Map("Alice" ->  10, "Bob" -> 20, "Kotlin" -> 30)

2)  构造可变映射

val map2 =  scala.collection.mutable.Map("Alice" -> 10, "Bob"  -> 20, "Kotlin" -> 30)

3)  空的映射

val map3 = new scala.collection.mutable.HashMap[String,  Int]

4)  对偶元组

val map4 = Map(("Alice", 10),  ("Bob", 20), ("Kotlin", 30))

5)  取值

如果映射中没有值，则会抛出异常，使用contains方法检查是否存在key。如果通过 映射.get(键) 这样的调用返回一个Option对象，要么是Some，要么是None。

val value1 = map1("Alice")//建议使用get方法得到map中的元素    println(value1)

6)  更新值

map2("Alice") = 99    println(map2("Alice"))    或：    map2 += ("Bob" -> 99)    map2 -= ("Alice",  "Kotlin")    println(map2)    或：    val map5 = map2 + ("AAA" ->  10, "BBB" -> 20)    println(map5)

7)  遍历

for ((k, v) <- map1) println(k +  " is mapped to " + v)    for (v <- map1.keys) println(v)    for (v <- map1.values) println(v)    for(v <- map1) prinln(v)

5.7  集 Set

集是不重复元素的结合。集不保留顺序，默认是以哈希集实现。

如果想要按照已排序的顺序来访问集中的元素，可以使用SortedSet（已排序数据集），已排序的数据集是用红黑树实现的。

默认情况下，Scala 使用的是不可变集合，如果你想使用可变集合，需要引用scala.collection.mutable.Set 包。

1)  Set不可变集合的创建

val set = Set(1, 2, 3)    println(set)

2)  Set可变集合的创建，如果import了可变集合，那么后续使用默认也是可变集合

import scala.collection.mutable.Set    val mutableSet = Set(1, 2, 3)

3)  可变集合的元素添加

mutableSet.add(4)    mutableSet += 6    // 注意该方法返回一个新的Set集合，而非在原有的基础上进行添加    mutableSet.+(5)

4)  可变集合的元素删除

mutableSet -= 1    mutableSet.remove(2)    println(mutableSet)

5) 遍历

for(x <- mutableSet) {       println(x)    }

6) Set更多常用操作

序号	方法	描述
1	def  +(elem: A): Set[A]	为集合添加新元素，并创建一个新的集合，除非元素已存在
2	def  -(elem: A): Set[A]	移除集合中的元素，并创建一个新的集合
3	def  contains(elem: A): Boolean	如果元素在集合中存在，返回 true，否则返回 false。
4	def  &(that: Set[A]): Set[A]	返回两个集合的交集
5	def  &~(that: Set[A]): Set[A]	返回两个集合的差集
6	def  ++(elems: A): Set[A]	合并两个集合
7	def  drop(n: Int): Set[A]]	返回丢弃前n个元素新集合
8	def  dropRight(n: Int): Set[A]	返回丢弃最后n个元素新集合
9	def  dropWhile(p: (A) => Boolean): Set[A]	从左向右丢弃元素，直到条件p不成立
10	def  max: A	查找最大元素
11	def  min: A	查找最小元素
12	def  take(n: Int): Set[A]	返回前 n 个元素