详细讲解Scala数据结构

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

不可变集合：scala.collection.immutable（Scala默认采用不可变集合）

可变集合：scala.collection.mutable

2，Scala的集合有三大类

• 序列seq(有序的，Linear Seq)
• 集Set
• 映射Map[key -> value]

初学者会有点不明白，什么时候应该用什么集合呢？

3，可变集合和不可变集合概念

• 不可变集合：Scala不可变集合，就是这个集合本身不能动态变化（类似Java的数组，是不可变台增长的）
• 可变集合：Scala可变集合，就是这个集合本身可以动态变化（如：ArrayList,是可动态增长）

4，不可变集合继承层次：

小结：IndexSeq和LinearSeq的区别？

• IndexSeq：是通过索引来查找和定位，所以速度快（如：String就是一个索引集合）
• LinearSeq：是线型的，即有头尾的概念，一般通过遍历来查找，它的价值应用到一些具体 的应用场景（如：电商网站，大数据推荐系统：最近浏览的10个商品等这些场景）

5，可变集合继承层次：

小结：在可变集合中比可变集合更加丰富，在Seq集合中，增加了Buffer集合，在将来开发中，会常用的有ArrayBuffer和ListBuffer

注意：这些集合继承关系，最好记得主熟悉就好了，方便后面的学习

6,Tuple元组

6.1，元组介绍：理解为一个容器，可以存放各种或不同类型的数据，叫做元组。

注意：元组中最大只能有22个元素

6.2，元组创建&&访问&&遍历

val tuple1 = ("spark",1,"hello","hadoop",2,3)
println(tuple1._1)//1代表访问元组第三个元素

6.3，元组的遍历需要使用迭代器

val tuple1 = ("spark",1,"hello","hadoop",2,3)
for (item <- tuple1.productIterator) {
  print(item + " ")
}

7，列表List

介绍：Scala中的List和Java不一样，在Java中List是一个接口，真正的存放数据是ArrayList，而Scala的List可以直接存放数据，就是一个object，默认下Scala的List是不可变的，List属于序列Seq。

List的使用

val list = List(1,2,3,"hello","spark")
val list2 = list :+ 4//:+ 运算表示在列表最后增加数据，结果为：List(1, 2, 3, hello, spark, 4)
val list3 = 10 +: list//:+ 运算表示在列表最前增加数据，结果为：List(10,1, 2, 3, hello, spark)
println(list2)
println(list2)
//符号::表示向集合中，新建集合添加元素
val list4 = 4::5::6::list::Nil//运算规则：从左往右，结果为：List(4, 5, 6, List(1, 2, 3, hello, spark))
//符号:::运算符是将集合中的每一个元素加入到集合中
val list5 = 7::8::9::list:::Nil//结果为：List(7, 8, 9, 1, 2, 3, hello, spark)
println(list4)
println(list5)

8,队列Queue

介绍：队列是一个有序列表，在底层用数组或是链表来实现，输入、输出遵循先进先出的原则

在Scala中，有可变和不可变，一般来说，在开发中通常用可变集合的队列。（应用场景：银行排队等）

package UerFuntion01

import scala.collection.mutable

object Tuple04 {
  def main(args: Array[String]): Unit = {
    val q1 = new mutable.Queue[Int]//创建队列
    //追加数据
    q1 += 9
    println(q1)//结果为：Queue(9)
    q1 ++= List(1,2,3)//注：默认直接加在队列后面
    println(q1)//结果为：Queue(9, 1, 2, 3)
    //删除
    val q2 = q1.dequeue()//从队列的头取出元素q1本身不变
    println(q2)
    //加入队列元素
    q1.enqueue(88,99,100)//入队，默认是从队列的尾部加入的
    println(q1)//结果为：Queue(1, 2, 3, 88, 99, 100)
  }
}

还有更多方法，查看api就可以了。

9，映射Map

9.1、Java&&Scala的Map对比

Java中的map：HashMap是一个散列表（数组+链表），存储内容是键值对(key-value)映射，Java中的HashMap是无序的，Key不能有重复。

Scala中的Map类似JavaMap，也是散列表，存储内容也是键值对(key-value)映射，注意：Scala中不可变的Map是有序的，可变的Map是无序的。

映射Map构建

方式一：构建可变映射

package UerFuntion01

import scala.collection.mutable

object Tuple04 {
  def main(args: Array[String]): Unit = {
    val map1 = mutable.Map("Hadoop" ->10,"Spark" -> 20,"Flink" ->"被阿里收购了吗")
    println(map1)//结果：Map(Hadoop -> 10, Spark -> 20, Flink -> 被阿里收购了吗)
  }
}

方式二：构建不可变映射

package UerFuntion01

//import scala.collection.mutable

object Tuple04 {
  def main(args: Array[String]): Unit = {
    val map1 = Map("Hadoop" ->10,"Spark" -> 20,"Flink" ->"被阿里收购了吗")
    println(map1)//结果：Map(Hadoop -> 10, Spark -> 20, Flink -> 被阿里收购了吗)
  }
}

方式三：对偶元组

即创建包含键值对的二元组，和前面方式等价，只是形式不同罢了。

对偶元组，就是只含有两个数据的元组，代码如下：

package UerFuntion01

//import scala.collection.mutable

object Tuple04 {
  def main(args: Array[String]): Unit = {
    val map1 = Map(("Hadoop",10),("Spark" ,20),("Flink" ,"被阿里收购了吗"))
    println(map1)//结果：Map(Hadoop -> 10, Spark -> 20, Flink -> 被阿里收购了吗)
  }
}

9.2、映射-Map的取值

方式一：使用map(key)

val map1 = map2("Hadoop")
println(map1)
注：
如key存在，则返回对应的值
如key不存在，则抛出异常
在Java中，如key不存在则返回null

方式二：使用contains方法检查是否存在key

package UerFuntion01


object Tuple04 {
  def main(args: Array[String]): Unit = {
    val value = Map(("Hadoop",10))
    println(value)
    if (value.contains("Hadoop")) {
      println(value("Hadoop"))
    } else {
      println("key不存在：")
    }
  }
}

方式三：使用map.get(key).get取值

通过映射.get(键)这样的调用返回一个Option对象，

1，如果key存在map.,get(key) 就会返回Some(值)，然后Some(值).get就可以取出

2，如果key不存在map.get(key) 就会返回None

println(map.get("Hdaoop").get)
println(map.get("Hdaoop~").get)//抛异常

方式四：使用map.getOrElse()取值

getOrElse方法说明：def getOrElse[V1 >:V](key:k,default: => V1)

说明：

1，若key存在，返回key对应的值

2，若key不存在，返回默认值，

代码如下：

println(map.getOrElse("Hadoop","默认的值"))

10，集-Set

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

创建

package UerFuntion01


object Tuple04 {
  def main(args: Array[String]): Unit = {
    //不可变set
    val set = Set(1,2,3,4,"spark",5,6,5,3)
    println(set)//结果顺序是乱的,没有重复的如：Set(5, 1, 6, 2, spark, 3, 4)
    //可变set
    val set2 = scala.collection.mutable.Set(1,2,3,3,"Hadoop",5)
    println(set2)//结果：Set(1, Hadoop, 2, 5, 3)
  }
}

Set的遍历：

//遍历一：使用for
val set3 = scala.collection.mutable.Set(1,2,3,3,"Hadoop",5,"Hive")
for (x <- set3) print(x + " ")//结果：1 Hadoop 2 5 3 Hive
//遍历二：使用foreach
val set4 = scala.collection.mutable.Set(1,2,3,3,"Hadoop",55,"Hive")
set4.foreach(x => print(x+ ","))