scala的基本语法：集合

集合

Iterable特质常用方法

可变集合

1 . 不可变集合继承层次一览图

在这里插入图片描述

ArrayBuffer转javalist（生产常用）

  val arr = ArrayBuffer("1", "2", "3") //JavaList
    /*bufferAsJavaList 是一个隐式函数：
    implicit def bufferAsJavaList[A](b : scala.collection.mutable.Buffer[A]) : java.util.List[A] =
     */
    import scala.collection.JavaConversions.bufferAsJavaList
    val javaArr = new ProcessBuilder(arr) //只能接受list 返回ProcessBuilder 对象
    val arrList = javaArr.command() //返回ava.util.List
    println(arrList) //输出 [1, 2, 3]

可变集合注意事项

Set、Map是Java中也有的集合
Seq是Java没有的，我们发现List归属到Seq了,因此这里的List就和java不是同一个概念了
我们前面的for循环有一个 1 to 3 , 就是IndexedSeq 下的Vector
String也是属于IndexeSeq
我们发现经典的数据结构比如Queue 和 Stack被归属到LinearSeq
大家注意Scala中的Map体系有一个SortedMap,说明Scala的Map可以支持排序
IndexedSeq 和 LinearSeq 的区别[IndexSeq是通过索引来查找和定位，因此速度快，比如String就是一个索引集合，通过索引即可定位] [LineaSeq 是线型的，即有头尾的概念，这种数据结构一般是通过遍历来查找，它的价值在于应用到一些

元组Tuple

元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据。将多个无关的数据封装为一个整体，称为元组, 最大的特点灵活,对数据没有过多的约束。

元组t1 的类型取决于 t1 后面有多少个元素, 有对应关系，比如 4个元素=》Tuple4 ,因为类型与个数关联所以底层效率高
注意：元组中最大只能有22个元素
两种访问方法：
- 符号 .__ 下标从1开始
- 方法productElement 下标从0开始方法本质上还是用的 .__
元组可以包含元组，类似数组，取用.__6.__4
Tuple是一个整体，遍历需要调其迭代器。

列表List

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

List默认为不可变的集合
List 和Nil 在 scala包对象声明的,因此不需要引入其它包也可以使用val List = scala.collection.immutable.List 或.Nil
List 中可以放任何数据类型，比如 arr1的类型为 List[Any] 可以指定泛型。
特殊集合空集合如果希望得到一个空列表list（）
索引同数组从0开始
向列表中增加元素, 会返回新的列表/集合对象，与Java不同

①list 不可变有序列表

增加数据 :+ 或者**+：** （向后面或前面插入数据）
列表后增加数据 ：：或者：：：
- 符号：：相当于把前面的集合当做元素连同后面集合元素放到新集合中，a::b与b::a不一样。
```
    val a =List(1,2)
    val b = List(3,4)
    println(a::b) //List(List(1, 2), 3, 4)
    println(b::a) //List(List(3, 4), 1, 2)
```
- 运算时，集合对象一定要放置在最右边
- 运算规则，从右向左，列表从末端开始创建
- ::: 运算符是将集合中的每一个元素加入到一个新的空集合中去(集合间操作)
```
val list1 = List(1, 2, 3, "abc")
val list7 = 4 :: 5 :: 6 :: list1 ::: Nil //结果是List(4, 5, 6, 1, 2, 3, "abc")
val list7 = 4 :: 5 :: 6 :: list1 :: Nil //结果是List(4, 5, 6, List(1, 2, 3, abc))
```

② ListBuffer 可变列表

ListBuffer是可变的list集合，可以添加，删除元素,ListBuffer属于序列。需要import scala.collection.mutable.ListBuffer

方法：

+= 元素
++= 集合操作添加List or ListBuffer
lst1.append()方法一个无返回值的方法用的是++=
list.remover()

    lst1 += 4 	//ListBuffer(4)
    lst1.append(5) 	//ListBuffer(4,5)
    lst0 ++=  lst1 	// 集合操作

队列 Queue

队列是一个有序列表，在底层可以用数组或是链表来实现。
其输入和输出要遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出
在Scala中，由设计者直接给我们提供队列类型使用。
在scala中, 有 scala.collection.mutable.Queue 和 scala.collection.immutable.Queue , 一般来说，我们在开发中通常使用可变集合中的队列。

方法：
+= 当泛型未Any时
++= List(2,9) 集合间操作
q1.dequeue() 删除
q1.enqueue(20,60) 增加
返回队列的第一个元素

println(q1.head) //对队列本身没有任何影响

返回队列最后一个元素

println(q1.last) //对队列本身没有任何影响

返回队列的尾部即：返回除了第一个以外剩余的元素，可以级联使用，这个在递归时使用较多。

println(q1.tail)
println(q1.tail.tail)

集set

★★映射 Map

Scala中的Map 和Java类似，也是一个散列表，它存储的内容也是键值对(key-value)映射，Scala中不可变的Map是有序的，可变的Map是无序的。

创建

构造不可变映射有序，元素底层是Tuple2类型

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

构造可变映射创建可变Map需要指定可变Map的包：scala.collection.mutable.Map

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

创建空的映射

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

对偶元组对偶元组就是只含有两个数据的元组

val map4 = mutable.Map( ("A", 1), ("B", 2), ("C", 3),("D", 30) )
println("map4=" + map4)
println(map4("A"))

取值

使用map(key)

与Java不同，如果key不存在scala则抛出异常[java.util.NoSuchElementException]，在Java中是返回null。

val value1 = map2("Alice")

使用map.get(key).get
- map.get方法会将数据进行包装，返回一个Option对象Some（value）或者None
- map.get(key).get key如果不存在，会抛出异常 java.util.NoSuchElementException: None.get

var map4 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
println(map4.get("A")) //Some(1) 
println(map4.get("A").get) //1  相当于Some(1).get

使用contains方法检查是否存在key
使用map.getOrElse()
- key存在，返回key对应的值
- key不存在返回默认值，不会抛出异常
- 原理还是contains

map1.getOrElse("A","不存在就返回本默认值"))
map2.getOrElse(c, 0)