Scala-集合类型实践

集合

Scala 的集合有三大类:序列 Seq、集 Set、映射 Map,所有的集合都扩展自 Iterable特质。

对于几乎所有的集合类,Scala 都同时提供了可变和不可变的版本,分别位于以下两个包中

不可变集合:scala.collection.immutable

可变集合: scala.collection.mutable

Scala 不可变集合,就是指该集合对象不可修改,每次修改就会返回一个新对象,而不会对原对象进行修改。类似于 java 中的 String 对象

可变集合,就是这个集合可以直接对原对象进行修改,而不会返回新的对象。类似于 java 中 StringBuilder 对象

建议:在操作集合的时候,不可变用符号,可变用方法

不可变集合类型

其中蓝色是具体的class，绿色是trait。

1)Set、Map 是 Java 中也有的集合

2)Seq 是 Java 没有的,我们发现 List 归属到 Seq 了,因此这里的 List 就和 Java 不是同一个概念了

3)我们前面的 for 循环有一个 1 to 3,就是 IndexedSeq 下的 Range

4)String 也是属于 IndexedSeq，String和Array是通过隐式转换成了IndexedSeq

5)我们发现经典的数据结构比如 Queue 和 Stack 被归属到 LinearSeq(线性序列)

6)注意 Scala 中的 Map 体系有一个 SortedMap,说明 Scala 的 Map 可以支持排序

7)IndexedSeq 和 LinearSeq 的区别:

a、IndexedSeq 是通过索引来查找和定位,因此速度快,比如 String 就是一个索引集合,通过索引即可定位

b、LinearSeq 是线型的,即有头尾的概念,这种数据结构一般是通过遍历来查找

可变集合类型

数组

不可变数组

第一种方式定义数组

val arr1 = new Array[Int](10)

(1)new 是关键字

(2)[Int]是指定可以存放的数据类型,如果希望存放任意数据类型,则指定 Any

(3)(10)表示数组的大小,确定后就不可以变化

第二种方式定义数组

val arr1 = Array(1, 2)

(1)在定义数组时,直接赋初始值

(2)使用 apply 方法创建数组对象

object TestImmutableArray {

    def main(args: Array[String]): Unit = {
        // 1、创建数组
        val arr = new Array[Int](5)

        // 2、另一种创建的方式
        val arr2 = Array(14, 56, 78)

        // 3、访问数组的元素
        println(arr(0)) // 0
        println(arr(4)) // 0
//        println(arr(5)) error
        arr(0) = 1
        arr(4) = 109
        println(arr(0)) // 1
        println(arr(4)) // 109

        // 4、数组遍历
        // 4.1、普通for循环
        // 相当与for (i <- 0 until arr.length)
        for (i <- arr.indices) {
            println(arr(i))
        }

        // 4.2、直接遍历所有元素，增强for循环
        for (elem <- arr2) {
            println(elem)
        }

        // 4.3、迭代器的使用
        val iter = arr2.iterator
        while (iter.hasNext) {
            println(iter.next())
        }

        // 4.4、调用foreach方法
        arr2.foreach((elem: Int) => {
            println(elem)
        })
        // 简写
        arr.foreach(println)

        println(arr2.mkString("--")) // 14--56--78

        // 5、添加元素
        val newArr = arr2.:+(35)        // :+()从数组后面追加一个元素，并返回新的数组
        println(arr2.mkString("--"))    // 14--56--78
        println(newArr.mkString("--"))  // 14--56--78--35

        val newArr2 = newArr.+:(98)     // +:()从数组前面追加一个元素，并返回新的数组
        println(newArr2.mkString("--")) // 98--14--56--78--35

        val newArr3 = newArr2 :+ 15
        val newArr4 = 19 +: 15 +: newArr3 :+ 67    // 如果是以:结尾的话，需要更换位置
        println(newArr4.mkString(","))  // 19,15,98,14,56,78,35,15,67
    }
}

可变数组

定义变长数组

 val arr01 = ArrayBuffer[Any](3, 2, 5)

(1)[Any]存放任意数据类型

(2)(3, 2, 5)初始化好的三个元素

(3)ArrayBuffer 需要引入 scala.collection.mutable.ArrayBuffer

(4)ArrayBuffer 是有序的集合

(5)增加元素使用的是 append 方法(),支持可变参数

可变数组和不可变数组的转换：

arr1.toBuffer //不可变数组转可变数组，返回结果才是一个可变数组,arr1 本身没有变化
arr2.toArray //可变数组转不可变数组，返回结果才是一个不可变数组,arr2 本身没有变化

object TestArrayBuffer {

    def main(args: Array[String]): Unit = {
        // 1、创建一个可变数组
        val arr1 = new ArrayBuffer[Int]()
        val arr2 = ArrayBuffer(1, 3, 46, 7)

        println(arr1.mkString(",")) // 无数据
        println(arr2)               // ArrayBuffer(1, 3, 46, 7)
        println(arr2.toString())    // ArrayBuffer(1, 3, 46, 7)

        // 2、访问数组中的元素
//        println(arr1(0)) // error
        println(arr2(1))
        arr2(2) = 17
        println(arr2(1))

        // 3、添加元素
        val newArr1 = arr1 :+ 15   // :+是针对不可变数组的添加元素的
        println(newArr1)  // ArrayBuffer(15)
        println(arr1)     // ArrayBuffer()

        val newArr2 = arr1 += 19   // 这里是把arr1的地址给newArr2了，因此不推荐把可变数组处理的结果赋值给别的
        println(arr1)              // ArrayBuffer(19)
        println(newArr2)           // ArrayBuffer(19)
        println(newArr2 == arr1)   // true

        77 +=: arr1
        println(arr1)             // ArrayBuffer(77, 19)

        arr1.append(36)
        arr1.prepend(45, 88)
        arr1.insert(1, 99999, 1000)
        println(arr1)             // ArrayBuffer(45, 99999, 1000, 88, 77, 19, 36)

        arr1.insertAll(2, newArr1)
        arr1.appendAll(newArr1)
        arr1.prependAll(newArr1)
        println(arr1)             // ArrayBuffer(15, 45, 99999, 15, 1000, 88, 77, 19, 36, 15)

        // 对于不可变数组推荐使用 :+ 和 +: 来进行处理
        // 对于可变数组推荐使用方法来处理

        // 4、删除元素
        arr1.remove(1)
        println(arr1)             // ArrayBuffer(15, 99999, 15, 1000, 88, 77, 19, 36, 15)

        arr1.remove(1, 2)
        println(arr1)             // ArrayBuffer(15, 1000, 88, 77, 19, 36, 15)

        arr1 -= 77
        println(arr1)             // ArrayBuffer(15, 1000, 88, 19, 36, 15)

        arr1 -= 888
        println(arr1)             // ArrayBuffer(15, 1000, 88, 19, 36, 15)
        
        // 5、可变数组转换成不可变数组
        val arr: ArrayBuffer[Int] = ArrayBuffer(23, 45, 67)
        val newArr: Array[Int] = arr.toArray
        println(newArr.mkString(",")) // 23,45,67
        println(arr)                  // ArrayBuffer(23, 45, 67)

        // 6、不可变数组转换为可变数组
        val buffer: mutable.Buffer[Int] = newArr.toBuffer
        println(buffer) // ArrayBuffer(23, 45, 67)
        println(newArr) // [I@6b2fad11
        println(newArr.mkString(",")) // 23,45,67
    }
}

在大数据的处理过程中，如果用到了数组的话，推荐使用不可变数组进行操作，并且能用不可变就用不可变。

多维数组

多维数组定义

val arr = Array.ofDim[Double](3,4)

说明:二维数组中有三个一维数组,每个一维数组中有四个元素

object TestMulArray {

    def main(args: Array[String]): Unit = {
        // 1、创建一个二位数组
        val array: Array[Array[Int]] = Array.ofDim[Int](2, 3)

        // 2、访问元素
        array(0)(2) = 9
        array(1)(0) = 25

        for (i <- 0 until array.length; j <- 0 until array(i).length) {
            println(array(i)(j))
        }
        for (i <- array.indices; j <- array(i).indices) {
            print(array(i)(j) + "\t")
            if (j == array(i).length - 1) println()
        }

        array.foreach(line => line.foreach(println))
        // 简写
        array.foreach(_.foreach(println))
    }
}

列表List

不可变列表

object TestList {

    def main(args: Array[String]): Unit = {
        // (1)List 默认为不可变集合
        // (2)创建一个 List(数据有顺序,可重复)
        val list1 = List(23, 56, 89)
        println(list1) // List(23, 56, 89)

        println(list1(1))
//        list1(1) = 12 // error

        // (3)遍历 List
        list1.foreach(println)

        // (4)List 增加数据
        val list2 = list1 :+ 10
        val list3 = 10 +: list1
        println(list1) // List(23, 56, 89)
        println(list2) // List(23, 56, 89, 10)
        println(list3) // List(10, 23, 56, 89)

        val list4 = list2.::(51)
        println(list2) // List(23, 56, 89, 10)
        println(list4) // List(51, 23, 56, 89, 10)

        // 空集合 Nil
        val list5 = Nil.::(13)
        println(list5)  // List(13)

        val list6 = 42 :: 56 :: 44 :: Nil
        println(list6)  // List(42, 56, 44)

        // (5)集合间合并:将一个整体拆成一个一个的个体,称为扁平化
        val list7 = list5 :: list6
        println(list7)  // List(List(13), 42, 56, 44)

        val list9 = list5 ::: list6
        println(list9)  // List(13, 42, 56, 44)

        val list10 = list5 ++ list6
        println(list10)  // List(13, 42, 56, 44)
    }
}

可变列表

object TestListBuffer {

    def main(args: Array[String]): Unit = {
        // 1、创建可变列表
        val list1 = new ListBuffer[Int]()
        val list2 = ListBuffer(12, 34, 56)

        println(list1) // ListBuffer()
        println(list2) // ListBuffer(12, 34, 56)

        // 2、添加元素
        list1.append(12, 45)
        list2.prepend(45, 67)
        list1.insert(1, 19, 44)

        println(list1) // ListBuffer(12, 19, 44, 45)
        println(list2) // ListBuffer(45, 67, 12, 34, 56)

        31 +=: 24 +=: list1 += 35 += 44 += 11
        println(list1) // ListBuffer(31, 24, 12, 19, 44, 45, 35, 44, 11)

        // 3、合并list
        val list3 = list1 ++ list2
        println(list1) // ListBuffer(31, 24, 12, 19, 44, 45, 35, 44, 11)
        println(list2) // ListBuffer(45, 67, 12, 34, 56)
        println(list3) // ListBuffer(31, 24, 12, 19, 44, 45, 35, 44, 11, 45, 67, 12, 34, 56)

        list1 ++= list2
        println(list1) // ListBuffer(31, 24, 12, 19, 44, 45, 35, 44, 11, 45, 67, 12, 34, 56)
        println(list2) // ListBuffer(45, 67, 12, 34, 56)

        val list4 = ListBuffer(1, 2, 3)
        list4 ++=: list2
        println(list4) // ListBuffer(1, 2, 3)
        println(list2) // ListBuffer(1, 2, 3, 45, 67, 12, 34, 56)

        // 4、修改元素
        list2(3) = 444
        list2.update(0, 111)
        println(list2) // ListBuffer(111, 2, 3, 444, 67, 12, 34, 56)

        // 5、删除元素
        list2.remove(0)
        list2 -= 67
        println(list2) // ListBuffer(2, 3, 444, 12, 34, 56)
    }
}

Set集合

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

不可变Set

Set 默认是不可变集合,数据无序，数据不可重复，因此可以使用Set来进行数据的去重。

object TestImmutableSet {

    def main(args: Array[String]): Unit = {
        // 1、创建一个Set
        val set1 = Set(13, 45, 13, 45, 67, 8)
        println(set1) // Set(13, 45, 67, 8)

        // 2、添加元素
        val set2 = set1 + 44
        println(set1) // Set(13, 45, 67, 8)
        println(set2) // Set(13, 45, 44, 67, 8)

        // 3、合并Set
        val set3 = Set(13, 45, 13, 99, 77)
        val set4 = set2 ++ set3
        println(set2) // Set(13, 45, 44, 67, 8)
        println(set3) // Set(13, 45, 99, 77)
        println(set4) // Set(77, 13, 45, 44, 67, 99, 8)

        // 4、删除元素
        val set5 = set3 - 13
        println(set3) // Set(13, 45, 99, 77)
        println(set5) // Set(45, 99, 77)
    }
}

可变mutable.Set

object TestMutableSet {

    def main(args: Array[String]): Unit = {
        // 1、创建一个Set
        val set1 = mutable.Set(13, 45, 13, 45, 67, 8)
        println(set1) // Set(13, 45, 67, 8)

        // 2、添加元素
        val set2 = set1 + 11
        println(set1) // Set(13, 45, 67, 8)
        println(set2) // Set(13, 45, 67, 11, 8)

        set1 += 12
        println(set1) // Set(13, 12, 45, 67, 8)

        val flag1 = set1.add(123)
        println(flag1) // true
        println(set1) // Set(13, 12, 123, 45, 67, 8)
        val flag2 = set1.add(123)
        println(flag2) // false
        println(set1) // Set(13, 12, 123, 45, 67, 8)

        // 3、删除元素
        set1 -= 12
        val flag3 = set1.remove(13)
        println(set1) // Set(45, 67, 123, 8)
        val flag4 = set1.remove(13)
        println(set1) // Set(45, 67, 123, 8)

        // 4、合并两个Set
        val set3 = mutable.Set(13, 45, 13, 44, 77)
        val set4 = set1 ++ set3
        println(set1) // Set(45, 67, 123, 8)
        println(set3) // Set(45, 13, 44, 77)
        println(set4) // Set(45, 67, 13, 123, 8, 44, 77)
        set1 ++= set3
        println(set1) // Set(45, 67, 13, 123, 8, 44, 77)
        println(set3) // Set(45, 13, 44, 77)
    }
}

Map集合

Scala 中的 Map 和 Java 类似, 也是一个散列表,它存储的内容也是键值对(key-value)映射

不可变Map

object TestImmutableMap {

    def main(args: Array[String]): Unit = {
        // 1、创建map
        val map1: Map[String, Int] = Map("a" -> 13, "b" -> 56, "hello" -> 8)
        println(map1)          // Map(a -> 13, b -> 56, hello -> 8)
        println(map1.getClass) // class scala.collection.immutable.Map$Map3 3是3个元素

        // 2、遍历元素
        map1.foreach(println)
//        (a,13)
//        (b,56)
//        (hello,8)
        map1.foreach((kv: (String, Int)) => println(kv))

        // 3、取map所有的key 或者value
        for (key <- map1.keys) {
            println(s"key is $key, value is ${map1.get(key)}")
//            key is a, value is Some(13)
//            key is b, value is Some(56)
//            key is hello, value is Some(8)
        }

        // 4、访问某一个key的value
        println("a: " + map1.get("a").get)        // a: 13，这个写法不够安全
        println("a: " + map1.getOrElse("a", "0")) // a: 13
//        println("c: " + map1.get("c").get)        // 这里会报错
        println("c: " + map1.get("c"))            // c: None
        println("c: " + map1.getOrElse("c", 0))   // c: 0

        println("a: " + map1("a"))                // a: 13，这个等于map1.get("a").get
    }
}

可变Map

object TestMutableMap {

    def main(args: Array[String]): Unit = {
        // 1、创建map
        val map1: mutable.Map[String, Int] = mutable.Map("a" -> 13, "b" -> 56, "hello" -> 8)
        println(map1)          // Map(a -> 13, b -> 56, hello -> 8)
        println(map1.getClass) // class scala.collection.mutable.HashMap

        // 2、添加元素
        map1.put("c", 54)
        map1.update("d", 3)
        println(map1)          // Map(b -> 56, d -> 3, a -> 13, c -> 54, hello -> 8)

        map1 += (("e",13))
        println(map1)          // Map(e -> 13, b -> 56, d -> 3, a -> 13, c -> 54, hello -> 8)

        // 3、删除元素
        map1.remove("c")
        println(map1.getOrElse("c", -1)) // -1
        map1 -= "d"
        println(map1)          // Map(e -> 13, b -> 56, a -> 13, hello -> 8)

        // 4、修改元素=插入元素
        map1.put("c", 54)
        map1.update("d", 3)
        println(map1)          // Map(e -> 13, b -> 56, d -> 3, a -> 13, c -> 54, hello -> 8)

        // 5、合并两个Map
        val map2: Map[String, Int] = Map("a" -> 33, "test" -> 19)
        map1 ++= map2    // 添加并覆盖
        println(map1)    // Map(e -> 13, b -> 56, d -> 3, a -> 33, c -> 54, hello -> 8, test -> 19)
        println(map2)    // Map(a -> 33, test -> 19)

        val map4: Map[String, Int] = Map("e" -> 999, "map" -> 77)
        val map3: Map[String, Int] = map4 ++ map1
        println(map3) // Map(e -> 13, test -> 19, map -> 77, a -> 33, b -> 56, c -> 54, hello -> 8, d -> 3)

    }
}

元组

元组也是可以理解为一个容器,可以存放各种相同或不同类型的数据。说的简单点,就是将多个无关的数据封装为一个整体,称为元组，即元素的组合。

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

object TestTuple {

    def main(args: Array[String]): Unit = {
        // 1、创建元祖
        val tuple: (String, Int, Char, Boolean) = ("hello", 100, 'a', true)
        println(tuple) // (hello,100,a,true)

        // 2、访问元组
        println(tuple._1) // hello
        println(tuple._2) // 100
        println(tuple._3) // a
        println(tuple._4) // true

        println(tuple.productElement(1)) // 100

        // 3、遍历元组数据
        for (elem <- tuple.productIterator) {
            println(elem)
        }

        // 4、嵌套元组
        val mulTuple = (12, 0.3, "hello", (0, "scala"), 99)

        println(mulTuple._4._2) // scala
    }
}

队列

Scala 也提供了队列(Queue)的数据结构,队列的特点就是先进先出。进队和出队的方法分别为 enqueue 和 dequeue。

object TestQueue {

    def main(args: Array[String]): Unit = {
        // 创建一个可变的队列
        val queue = new mutable.Queue[String]()

        queue.enqueue("a", "b", "hello") // Queue(a, b, hello)

        println(queue)            // a
        println(queue.dequeue())  // Queue(b, hello)
        println(queue)            // b
        println(queue.dequeue())  // Queue(hello)
        println(queue)

        // 不可变队列
        val queue2 = Queue("a", "b", "hello")
        val queue3 = queue2.enqueue("d")
        println(queue2) // Queue(a, b, hello)
        println(queue3) // Queue(a, b, hello, d)
    }
}

并行集合

Scala 为了充分使用多核 CPU,提供了并行集合(有别于前面的串行集合),用于多核环境的并行计算。

object TestParallel {

    def main(args: Array[String]): Unit = {

        val result = (1 to 100).map(
            x => Thread.currentThread().getId
        )
        println(result) // 都是1

        val result2 = (1 to 100).par.map(
            x => Thread.currentThread().getId
        )
        println(result2) // 有很多不一样的线程id
        // ParVector(10, 10, 10, 10, 10, 10, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 12, 12, 12, 13, 13, 13, 14, 14, 14, 14, 14, 14, 15, 15, 15, 14, 14, 14, 13, 13, 13, 13, 13, 13, 13, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13)
    }
}