Scala（集合）通俗易懂

注意：使用dos窗口退出scala模式是:q

一、Scala集合大分类

此处集合说的是：Collection
● Seq：序列，元素按顺序排列 （List）
● Set：集合，元素不重复
● Map：映射，键值对集合
所有的集合都继承自Traversable，都可以使用它里面的函数

二、Scala集合-可变/不可变

●不可变集合
scala.collection.immutable,默认scala中选择不可变集合
● 可变集合:可以修改、添加或移除一个集合的元素
可变函数包下有个ListBuffer
scala.collection.mutable

2.1 不可变集合

● scala.collection.immutable

Set：ListSet、HashSet、TreeSet
Map：ListMap、HashMap、TreeMap
Seq：Vevtor、String、Range、List、Stack、Stream、Queue

2.2 可变集合

● scala.collection.mutable
重点是Buffer下的ListBuffer

三、List常用操作

定义一个可变List
1、导包

import scala.collection.mutable.ListBuffer

2、定义一个List

val lst = ListBuffer(1,2,3,6,7)

3、向集合尾巴上添加元素

lst+=100
println(lst)
=>输出ListBuffer(1, 2, 3, 6, 7, 100)
   
lst+=(21,22)
println(lst)
=>输出 ListBuffer(1, 2, 3, 6, 7, 100,21,22)

4、向集合头部添加元素

21+=:lst   // 冒号要指向集合
println(lst)
=>输出 ListBuffer(21, 1, 2, 3, 6, 7, 100, 21, 22)

5、把一个List添加进去

List(22,33)++=:lst
println(lst)
=>输出  ListBuffer(22, 33, 21, 1, 2, 3, 6, 7, 100, 21, 22)

四、List中方法

1、grouped :分组（生成一个迭代器）

val ls = List(1,2,3,4,5,6,7,8)
var iter = ls grouped 3   // 生成迭代器，每组3个元素,
println(iter.next())    // 分组，生成迭代器，把每一组元素存到迭代器中
println(iter.next())    // 迭代器的方法
println(iter.next())
// 如果在输出iter.next()则会报错，因为迭代器把所有元素都输出出来了

2、sliding（同样是生成一个迭代器）（只有一个参数的情况下）
生成的结果有点类似于滑动的效果，一个接着一个（1,2）（2,3）(3,4)这样的

val l = List(1,2,3,4,5,6,7,8)
    var iter = l.sliding(2)
    // 生成一个新的迭代器
    println(iter)
    println(iter.next())
    println(iter.next())
    println(iter.next())
    println(iter.next())
    println(iter.next())
    println(iter.next())
    println(iter.next())
   

当第二个位置有参数的时候，这个参数代表指定滑动的大小，默认是滑动一个元素

val l = List(1,2,3,4,5,6,7,8)
    var iter = l.sliding(2,2)  // 第二个元素是指定滑动的大小，默认是滑动一个元素
    // 生成一个新的迭代器
    println(iter)
    println(iter.next())
    println(iter.next())
    println(iter.next())
    println(iter.next())
/*    println(iter.next())
    println(iter.next())
    println(iter.next())*/

3、concat:连接

var a1 = Array(1,2,3,4)
var a2 = Array(100,200,300,400)
var a = List.concat(a1,a2)
println(a)
=>输出 List(1, 2, 3, 4, 100, 200, 300, 400)

4、head:提取第一个元素

var lst = List(1,2,3,4)
println(lst.head)
=>输出 1

5、last：提取最后一个

var lst = List(1,2,3,4)
println(lst.last)
=>输出 4

6、tail：提取除了第一个元素之外的所有（除了头以外其他所有的）

var lst = List(1,2,3,4)
println(lst.tail)
=>输出 List(2, 3, 4)

7、init：提取除了尾巴以外其他所有的

var lst = List(1,2,3,4)
println(lst.init)
=>输出 List(1, 2, 3)

8、filter（过滤器）

var lst = List(1,2,3,4)
lst.filter(x=>{x%2==0}).foreach(println)
=>输出 2 4

println(lst.filter(x=>x%2!=0))  // 拿出x等于那些x取余2不等于0的值
=>输出 List(1, 3)

也可以直接写成_
println(lst.filter(_%2!=0))   //只有一个参数的时候，可以用_替代
=>输出 List(1, 3)

9、sum：数组求和

var lst = List(1,2,3,4)
println(lst.sum)
=>输出 10

10、reverse：反转

var lst = List(1,2,3,4)
println(lst.reverse)
List(4, 3, 2, 1)

11、sorted：排序

var lst = List(9,0,2,1,8)
println(lst.sorted)
=>输出 List(0, 1, 2, 8, 9)

12、sortWith：逆序/正序

var lst = List(9,0,2,1,8)
 println(lst.sortWith(_>_))
 =>输出 List(9, 8, 2, 1, 0)

正序
 println(lst.sortWith(_<_))

15、sortBy():正序/逆序

升序
var lst = List(9,0,2,1,8)
println(lst.sortBy(lst=>lst))
=>输出 List(0, 1, 2, 8, 9)

降序
 println(lst.sortBy(lst => lst*(-1)))
 =>输出 List(9, 8, 2, 1, 0)

五、Scala 中Set常用操作

1、求两个的差集（使用符号：- -）/ diff / &~

    // se1的元素多，看看哪些是se2中没有的
    var se1 = Set(1,2,4,5,6)
    // se2中仅有3个元素，只能看se2中的元素有哪些是se1中没有的
    var se2 = Set(1,2,3)

    println(se1 -- se2)
=>输出 Set(5, 6, 4)

println(se1 diff se2)
=>输出 Set(5, 6, 4)

pentln(se1 &~ se2)
=>输出 Set(5, 6, 4)

2、++/ |：做并集，重复的只会保留一个

var se1 = Set(1,2,4,5,6)
var se2 = Set(1,2,3)

println(se1 ++ se2)
=>输出 Set(1, 5, 2, 6, 3, 4)

println(se1 | se2)
=>输出 Set(1, 5, 2, 6, 3, 4)

3、& ：求出交集

var se1 = Set(1,2,4,5,6)
var se2 = Set(1,2,3)

println(se1 & se2)
=>输出 Set(1, 2)

六、Scala中Map常用操作

1、定义一个Map
->只会出现在（k,v）中

import scala.collection.mutable.Map
var m = Map("a"-> 1,"b"-> 2,"c"-> 3,"d"-> 4,"e"-> 5,"f"-> 6,"g"-> 7,"h"-> 8)

2、如何能够Map中的元素
通过k获取v

// 直接把k传进去获得v
println(m("a"))
=>输出 1

3、添加元素
其实就是生成了一个新的Map

 m += ("w"-> 10)

println(m)
加在最头部
=>输出 Map(w -> 10, e -> 5, h -> 8, b -> 2, d -> 4, g -> 7, a -> 1, c -> 3, f -> 6)

注意观察，以前a的值是1
这个时候 a经过下面操作后变成了2
验证了Map中k是唯一的，后面添加的会覆盖上一个相同key的值
m+=("a"-> 2)
println(m)
=>输出 Map(w -> 10, e -> 5, h -> 8, b -> 2, d -> 4, g -> 7, a -> 2, c -> 3, f -> 6)

4、遍历Map
此处的打印是随机的，没有顺序的

for ((k,v)<-m) {
      println((k,v))
    }
 =>输出
(e,5)
(h,8)
(b,2)
(d,4)
(g,7)
(a,1)
(c,3)
(f,6)
   

按照key的字母顺序进行排序

val m2 = scala.collection.SortedMap("b"->2,"a"-> 1,"e"-> 3)
println(m2)
=>输出 Map(a -> 1, b -> 2, e -> 3)

七、Scala Stream & Vector

Stream是List惰性版，它只会确定第一个值，后面的值用到再求值，可以防止数据过大全部加载导致内存溢出
简而言之，一边遍历一边往流里读

val stream = (1 to 100).toStream
println(stream.head)
=>输出1

println(stream.tail)
=>输出 Stream(2, ?)


想要获取后面的值，比如说第10个值
必须先
stream(10)
后
println(stream.tail)
=>输出 Stream(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ?)
只会查到第10个元素

八、元祖

元组在 Scala 中是非常重要一种数据结构，允许用户最多存储 22 个不同类型 的元素，本质上分别对应 Tuple1~Tuple22 共 22 个类。除了 Tuple1 外其他的都可 以使用“()”快速创建相应元组。

8.1 创建Tuple

var tp1= new Tuple5(11,21,33,44,55)
// 提取值
// 存储多少值，只能点出几个
tpe1.2

Tuple1只能存储1个值

8.2 提取值

   var tp1 = new Tuple5(1,2,3,4,5)

    println(s"${tp1._1},${tp1._2}")
    => 返回 1,2

8.3 遍历Tuple

没有foreach方法，不支持直接遍历

有一个迭代器：productIterator

   var tp1 = new Tuple5(1,2,3,4,5)

    tp1.productIterator.foreach(println)
    =>输出结果为
    1
    2
    3
    4
    5
    
    // 如果想要提取几个值,比如前三个，只能_1,_2,_3这种方式提取

注意：元祖不可变，一旦创建无法改变内容很长度

总结

重点：
Scala数组、元组、数组
Array、Tuple、List、Map、Set