Scala集合——元组Tuple、列表List、集合Set、队列Queue、映射Map

一、元组tuple

元组（tuple）类似Java中的集合，可以放入不同类型的数据，元组最多存放22个数据

把无关的对象变成一个整体

例如：val t1:(String,Int,Double,boolean) = ("abc",123,23.6,true)，这个元素的类型就是(String,Int,Double,boolean)

//元组
object TupleDemo1 {
    def main(args: Array[String]): Unit = {
        //1. 创建元组
        val t1 = ("a",1,"2",3.4,true)
        println(t1)
        println("_________")

        //2. 访问元组中的数据_1、_2、...
        println(t1._1)
        println(t1._3)
        println("_________")

        //3. 遍历元组
        for(ele <- t1.productIterator){
            println(ele)
        }
    }
}

打印结果

(a,1,2,3.4,true)
_________
a
2
_________
a
1
2
3.4
true

二、列表List

java中的List是一个集合接口，真正存放数据用的是ArrayList，对标scala中的变长数组ArrayBuffer；

scala中的List是列表，可以直接存放数据，默认不可变

ListBuffer是可变列表

特点：有序、可重复、增删快、查询慢

//列表List
object ListDemo1 {
    def main(args: Array[String]): Unit = {
        //1. 创建列表——方式1
        val list1 = List(10, 20, 30, 40)
        //创建列表——方法2：需要在最后加Nil
        val list2: List[Int] = 10 :: 20 :: 30 :: 40 :: 50 :: Nil
        println("list1: "+ list1)
        println("list2: "+ list2)
        println("___________")

        //2. 访问List中的元素
        println(list1(0))
        println(list2(1))
        println("___________")

        //3. 向列表尾部追加元素，追加符号:+
        //追加完后生成新List
        val list3 = list1 :+ 60 :+ 70
        println("list3: "+ list3)
        println("list1: "+ list1)
        println("___________")

        //4. 向列表头部追加元素，追加符号+:
        val list4 = 60 +: 70 +: list1
        println("list4: "+ list4)
        println("list1: "+ list1)
        println("___________")

        //5. 连接两个列表，:::和++
        println(list1 ::: list2)
        println(list1 ++ list2)
    }
}

打印结果

list1: List(10, 20, 30, 40)
list2: List(10, 20, 30, 40, 50)
___________
10
20
___________
list3: List(10, 20, 30, 40, 60, 70)
list1: List(10, 20, 30, 40)
___________
list4: List(60, 70, 10, 20, 30, 40)
list1: List(10, 20, 30, 40)
___________
List(10, 20, 30, 40, 10, 20, 30, 40, 50)
List(10, 20, 30, 40, 10, 20, 30, 40, 50)

从结果可以看出List是有序的，并且增删后会生成新List，原List不变

三、集合Set

scala中Set的特点：元素无序、不重复，增删慢、查询快；默认以hash集的形式实现

分为可变的Set和不可变的Set，默认是不可变Set

写可变的Set需要导包import scala.collection.mutable；Set集合修改后原集合会发生改变

import scala.collection.mutable

object SetDemo1 {
    def main(args: Array[String]): Unit = {
        //1. 创建一个不可变Set
        val set1 = Set(10, 2, 5, 9, "a", "bb")
        println(set1)

        //2. 创建一个可变的Set，需要导包mutable
        val set2 = mutable.Set("a", 1, "b")
        println(set2)
        println("________________")

        //3. 可变Set元素的增加和删除，修改后原Set会改变（不可变Set无法修改）
        //（1）增加元素，+=
        set2 += "abc"
        println(set2)
        //（2）删除元素，-=
        set2 -= "a"
        println(set2)
        println("________________")

        val set3 = set2.+("abcd")
        println(set3)
        println(set2)
    }
}

打印结果

Set(5, 10, a, 9, 2, bb)
Set(1, a, b)
________________
Set(1, abc, a, b)
Set(1, abc, b)
________________
Set(abcd, 1, abc, b)
Set(1, abc, b)

从结果上可以看出，Set是无序的，并且增删后原集合会发生改变

四、队列Queue

队列是一个有序列表，底层是用数组或链表实现；

与Tuple、List、Set的区别是，队列数据输入和输出遵循先入先出原则，即先存入的数据先取出，后存入的数据后取出

创建Queue需要导包import scala.collection.mutable

import scala.collection.mutable

//队列
object QueueDemo1 {
    def main(args: Array[String]): Unit = {
        //1. 创建空队列
        val queue1 = new mutable.Queue[Int]
        //2. 创建队列，并初始化两个元素
        val queue2 = mutable.Queue(10, 20)
        println(queue1)
        println(queue2)
        println("________________")

        //3. 添加一个元素 +=
        queue1 += 1
        queue1 += 2
        queue1 += (3, 4)
        println(queue1)

        //4. 添加List列表 ++=
        queue1 ++= List(1, 2, 3, 4)
        println(queue1)

        //5. 添加Array数组 ++=
        queue1 ++= Array(1, 20, 30)
        println(queue1)
        println("________________")

        //6. 添加元素，使用enqueue
        queue1.enqueue(100, 200)
        println(queue1)

        //7. 删除队列中第一个元素，使用dequeue
        queue1.dequeue()
        println(queue1)
        println("________________")

        //8. 返回队列头部元素head
        println("queue1.head= " + queue1.head)

        //9. 返回队列中除头元素外的所有元素tail
        println("queue1.tail= " + queue1.tail)
    }
}

打印结果

Queue()
Queue(10, 20)
________________
Queue(1, 2, 3, 4)
Queue(1, 2, 3, 4, 1, 2, 3, 4)
Queue(1, 2, 3, 4, 1, 2, 3, 4, 1, 20, 30)
________________
Queue(1, 2, 3, 4, 1, 2, 3, 4, 1, 20, 30, 100, 200)
Queue(2, 3, 4, 1, 2, 3, 4, 1, 20, 30, 100, 200)
________________
queue1.head= 2
queue1.tail= Queue(3, 4, 1, 2, 3, 4, 1, 20, 30, 100, 200)

五、映射Map

Scala中Map映射存储的是key-value键值对，不可变Map是有序的，可变Map是无序的

Map里的元素是(key，value)以元组的形式存在

//映射Map
object MapDemo1 {
    def main(args: Array[String]): Unit = {
        //1. 创建不可变Map
        val map1 = Map("A" -> 50, "B" -> 100, "C" -> 200)
        //遍历
        for (elem <- map1) {
            println(elem) //遍历的每个元素都是一个元组
            println(elem._1)
        }
        println("____________")

        //2. 创建可变Map
        import scala.collection.mutable
        val map2 = mutable.Map("a" -> 1, "b" -> 2, "c" -> 3)
        //遍历
        for (elem <- map2) {
            println(elem)
            println(elem._2)
        }
    }
}

打印结果

(A,50)
A
(B,100)
B
(C,200)
C
____________
(b,2)
2
(a,1)
1
(c,3)
3

从打印结果可以看出，不可变Map是有序的，输出顺序和元素的声明顺序一致；可变Map是无序的

5.1 Map取key对应的value值

//Map中通过key查找value
object MapDemo2 {
    def main(args: Array[String]): Unit = {
        val map1 = mutable.Map("a" -> 1, "b" -> 2, "c" -> 3)
        //1. map("key")获取key对应的value，没有对应的key会报错
        println(map1("a"))
        //取值前判断key是否存在
        if (map1.contains("d")) {
            println(map1("d"))
        } else {
            println("查找的key不在")
        }
        println("_________________")

        //2. get("key")，返回的是Some(value)，需要用.get获取value
        val v1 = map1.get("b")
        val v2 = map1.get("d")
        println(v1)
        println(v1.get)
        println(v2)
        println("_________________")

        //3. getOrElse，若存在key返回对应value值，若不存在key返回设定的默认值
        val i1 = map1.getOrElse("a", 100)
        val i2 = map1.getOrElse("d", 200)
        println(i1)
        println(i2)
    }
}

打印结果

1
查找的key不在
_________________
Some(2)
2
None
_________________
1
200