【Scala】07 集合

分三大类：

序列 Seq

集 Set

映射 Map

所有集合类型都扩展自Iterable特质（可迭代的）

所有集合类型都提供【可变】和【不可变】的版本

归纳在下面两个包中

scala.collections.immutable 不可变的

意思这个集合对象不可改变，每一次修改即返回新的对象，不对原始集合对象修改

等同java.lang.String

scala.collections.mutable 不可变的

意思这个集合对象可改变，每一次修改即返回原始的对象，等同java.lang.StringBuilder

固定数组Array的操作：

package cn

object HelloScala {
  def main(args: Array[String]): Unit = {
    // 推倒类型变量， new 新创建 Array表示数组 [String]表示数组元素的类型 （10） 表示数组的长度
    val strings = new Array[String](10)

    // 数组的长度属性
    val len = strings.length

    // 对指定索引上的元素修改赋值，也可以用来读取
    strings(0) = "aaa"

    // 创建方式2
    val arr1 = Array.apply(10, 20, 30, 40)
    val arr2 = Array(10, 20, 30, 40) // 直接Array就是apply的缩写

    // 遍历
    // for(el <- 0 to arr1.length - 1)
    // for(el <- 0 until arr1.length)
    // for(el <- arr1.indices)
    // for(el <- arr1)
    for(el <- 0 until  arr1.length) println(el)

    // 迭代遍历
    val itr = arr2.iterator
    while (itr.hasNext) println(itr.next())

    // forEach方法
    arr1.foreach(el => {
      println(el)
    })
    arr2.foreach(println)

    // 添加元素
    val newArr1 = arr1.:+(123) // 不可变数组添加元素是一个新的数组 :+(element) 在末尾加
    val newArr2 = newArr1.+:(123) // +:(element) 在开头添加

    // 使用这种添加方式
    val newArr3 = newArr2 :+ 16 // 对象（参数）
    val newArr4 = 16 +: newArr2// （参数） 对象

    // 简洁明了的添加元素操作
    val newArr5 = 10 +: 12 +: 33 +: newArr4 :+ 2 :+ 11 :+ 5; //
  }
}

添加元素的方法：

package cn

import scala.collection.mutable.ArrayBuffer

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

    // 缓冲数组
    val value = new ArrayBuffer[Any]

    // 不要这样赋值 会索引越界， 因为value里面什么都没有，需要存在确定的元素才可以这样去访问
    value(0) = 100 // 访问元素和固定数组是一样的

    // 添加元素
    value += 10 // 使用的是直接加等于
    77 +=: value
    // value.append(100) append方法被移除了？
    value.prepend(12, 22, 33) // prepend方法标记为过时的
    value.insert(1, 0)
    value.insertAll(1, value)
    value.prependAll(value)
  }
}

固定List ：

package cn

import scala.collection.mutable
import scala.collection.mutable.ArrayBuffer

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

    // 创建固定List
    val list = List(false, 10, "string") // 能装填不同数据类型的元素

    println(list) // List(false, 10, string)

    println(list(1)) // 可以读取
    // list(1) = 10 // 但是无法写入

    // 遍历List的每一个元素
    list.foreach(println)

    // 添加元素 因为是固定的对象，所以添加元素就必须要返回新的对象
    val l2 = list.+:(25) // 从头部添加
    val l3 = list :+ 25 // 从尾部添加

    println(l2)
    println(l3)

    val l4 = l3.::(50) // 从头部添加
    println(l4)

    println(Nil) // Nil 是一个空List对象
    val l5 = 40 :: Nil // 参数写前面，对象调用写后面的语法

    // 所以就有像这种数组的声明方式
    val l6 = 100 :: 80 :: 60 :: 40 :: 20 :: Nil
    println(l6) // List(100, 80, 60, 40, 20)

    val l7 = l6 :: l6 // 该方法会把List对象做为元素也装进这个List对象中
    println(l7) // List(List(100, 80, 60, 40, 20), 100, 80, 60, 40, 20)

    // 如果需要装填的是里面得元素 则使用三冒号实现
    val l8 = l6 ::: l6
    println(l8)

    // 或者使用这个符号 ++ 作用和三冒号是一样的
    val l９ = l6 ++l8
  }
}

可变List：

package cn

import scala.collection.mutable
import scala.collection.mutable.{ArrayBuffer, ListBuffer}

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

    // 可变list

    // 创建
    val lb1 : ListBuffer[Int] = new ListBuffer[Int]() // 方式1
    val lb2 = ListBuffer(12, 30, 50) // 方式2 （推荐这种伴生对象实现）

    // 添加元素
    lb1.append(112) // 后置追加

    lb2.prepend(122) // 前置追加

    lb1.insert(0, 123) // 指定索引位置追加 教程上可以追加多个，但是这个版本好像不支持了

    // +=: 表示前置追加， += 表示后置追加
    31 +=: 33 +=: lb1 += 12 += 35

    // 合并两个List并且返回一个新的List对象
    val lb3 = lb1 ++ lb2

    // 把lb2的元素合并到lb1中
    lb1 ++= lb2

    // 反过来lb1的元素合并到lb2中
    lb1 ++=: lb2

    // 和固定List不一样，ListBuffer是支持修改的
    lb1(1) = 100
  }
}

不可变Set & 可变Set

package cn

import scala.collection.mutable
import scala.collection.mutable.{ArrayBuffer, ListBuffer}

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

    // Set会覆盖重复的元素 不可变类型
    val set = Set(12, 33, 44, 44)

    // 添加元素
    val set2 = set.+(11)
    val set3 = set2 + 22

    // 合并Set对象
    val set4 = set2 ++ set3

    // 删除元素
    val set5 = set4 - 100

    // 可变Set
    val mtbSet = mutable.Set(10, 10, 40)

    mtbSet + 33

    // 推荐直接调用方法

    mtbSet += 45
    mtbSet.add(45) // 返回添加结果

    mtbSet -= 45
    mtbSet.remove(45) // 返回添加结果

    // 合并Set

    // 合并两个Set返回到新Set对象中
    val mtbSet1 = mtbSet ++ mtbSet

    // 合并到 Set1对象数组
    mtbSet ++= mtbSet

  }
}

不可变Map

package cn

import scala.collection.mutable
import scala.collection.mutable.{ArrayBuffer, ListBuffer}

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

    // 创建Map // 支持多个键值对创建
    val map : Map[String, Integer] = Map(
      "A" -> 0,
      "B" -> 12,
      "C" -> 33
    )

    println(map) // Map(A -> 0, B -> 12, C -> 33)

    println(map.getClass) // class scala.collection.immutable.Map$Map3

    // 遍历，元素是每一个键值对
    map.foreach(println)

    // 扩展
    map.foreach( (keyValue : (String, Integer)) => println(keyValue) )

    // 按Key遍历
    for(key <-  map.keys) {
      println(s"key : $key & value : ${map.get(key)}")
    }

    // 要直接获取Value -> map.get(Key).get
    for(key <-  map.keys) {
      println(s"key : $key & value : ${map.get(key).get}")
    }

    // 如果Value是空的，可能发生异常，采用安全的获取方法是 map.getOrElse(key, defaultValue) 设置缺省值
    for(key <-  map.keys) {
      println(s"key : $key & value : ${map.getOrElse(key, 0)}")
    }

    /**
     * key : A & value : Some(0)
     * key : B & value : Some(12)
     * key : C & value : Some(33)
     *
     * Value可能是一个NULL值，所以使用Option封装了一层 Some是一个Option子类
     */

    // Map 也支持像数组或者List那种方式访问值
    println(map("A"))
  }
}

可变Map和不可变Map调用的操作方法一样

多了可操作的方法

package cn

import scala.collection.mutable
import scala.collection.mutable.{ArrayBuffer, ListBuffer}

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

    // 创建可变Map // 支持多个键值对创建
    val map : mutable.Map[String, Integer] = mutable.Map(
      "A" -> 0,
      "B" -> 12,
      "C" -> 33
    )
    println(map) // Map(A -> 0, B -> 12, C -> 33)
    println(map.getClass) // class scala.collection.mutable.HashMap

    // 可变Map就支持元素的添加和移除
    map.put("D", 22) // 添加元素1
    map += ("E", 33) // 添加元素2

    map.remove("D") // 移除元素1
    map -= "E" // 移除元素2
    map -= ("E", 33) // 移除元素3

    // 遍历，元素是每一个键值对
    map.foreach(println)

    val map2 : mutable.Map[String, Integer] = mutable.Map(
      "A" -> 0,
      "B" -> 12,
      "C" -> 33
    )

    map ++= map2 // 合并Map2的元素给Map(覆盖已存在的Key&Value)

    // 或者合并返回新的map对象
    val map3 = map ++ map2
    // 扩展
    map.foreach( (keyValue : (String, Integer)) => println(keyValue) )

    // 按Key遍历
    for(key <-  map.keys) {
      println(s"key : $key & value : ${map.get(key)}")
    }

    // 要直接获取Value -> map.get(Key).get
    for(key <-  map.keys) {
      println(s"key : $key & value : ${map.get(key).get}")
    }

    // 如果Value是空的，可能发生异常，采用安全的获取方法是 map.getOrElse(key, defaultValue) 设置缺省值
    for(key <-  map.keys) {
      println(s"key : $key & value : ${map.getOrElse(key, 0)}")
    }

    /**
     * key : A & value : Some(0)
     * key : B & value : Some(12)
     * key : C & value : Some(33)
     *
     * Value可能是一个NULL值，所以使用Option封装了一层 Some是一个Option子类
     */

    // Map 也支持像数组或者List那种方式访问值
    println(map("A"))
  }
}

元组操作：

package cn

object HelloScala {
  def main(args: Array[String]): Unit = {
    // 元组 通用数据类型容器，没有数据类型限制，但是最多存放22个元素？
    val tuple = ("String", 100, false, 3.14, "C")

    // 显式要求数据类型
    val tuple2 : (String, Int, Boolean, Double, Char) = ("String", 100, false, 3.14, 'C')

    // Map的键值对就是元组，只是个数固定是2 一个Key 一个Value

    // 访问元组的元素可以直接调用 tuple._index
    println(tuple._2) // 这种方式第一个是 _1 从1开始
    println(tuple2.productElement(0)) // 调用productElement(index) 是从0开始

    // 使用迭代器遍历访问
    for (elem <- tuple.productIterator) println(elem)

    // 元组支持嵌套元组，元组本身也算一种类型
    val tuple3 = (1, true, tuple, tuple2)

    for (elem <- tuple3.productIterator) println(elem)

    // 同样的操作可以连续调用
    println(tuple3._3._2)
  }
}

通用集合操作：

package cn

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

    // 集合类型通用操作
    val list = List(1, 2, 3, 4, 5)
    println(list.length) // 获取长度

    val set = Set(1, 2, 3, 4, 5)
    println(set.size) // set不是长度属性，获取的是Size大小

    // 数组或者List可以直接遍历拿到元素
    for(el <- list) println(el)

    // set没有长度一说，需要通过迭代器执行
    for(el <- set.iterator) println(el)

    // 使用mkString转换为字符串
    println(list.mkString(","))

    // 判断是否包含某元素
    println(set.contains(23))
  }
}

衍生集合操作

package cn.dzz

object Main {

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

    // 衍生集合操作
    val list1 = List(1, 3, 5, 7, 8, 10, 113)
    val list2 = List(2, 4, 5, 7, 9, 10, 11)

    // 获取集合的头
    println(list1.head)

    // 获取集合的尾部 （不是头就是尾？） 意思是返回除了头部 返回后面所有的元素（新的List对象）
    println(list1.tail)

    // 获取集合的最后一个元素
    println(list1.last)

    // 获取集合除最后一个元素的所有元素
    println(list1.init)

    // 反转
    println(list1.reverse)

    // 获取指定位置长度的元素1
    println(list1.take(3)) // 获取前面3个元素

    // 获取指定位置长度的元素2
    println(list1.takeRight(3)) // 从右边开始获取3个元素

    // 移除前后的元素
    println(list1.drop(3)) // 从左边移除3个元素
    println(list1.dropRight(3)) // 从右边移除三个元素

    // 并集  A集合和B集合相同的元素原封不动  Set类会做去重处理
    val unionList = list1.union(list2)
    val unionList2 = list1 ::: list2

    // 交集 取出AB集合共同的部分
    val intersectList = list1.intersect(list2)

    // 差集 取出AB集合所独有的部分
    val diffList = list1.diff(list2) // 属于List1,但是不属于List2的元素

    // 拉链 ？ 将两个集合合并成一个二元组集合
    println(list1.zip(list2))

    // 滑窗 固定筛选长度，可以偏移量的获取集合中的元素
    println(list1.sliding(3)) // 返回的是一个Iterator 默认步长是1，可调用重载  println(list1.sliding(3), 3)这样

    // 获取滑窗筛选的元素
    for (el <- list1.sliding(3)) println(el)
  }

}

集合计数方法：

简单的聚合计算和排序处理：

package cn.dzz

object Main {

  def main(args: Array[String]): Unit = {
    // 集合的聚合处理
    val list = List(2, 42, 1213, 33, 44)

    // 求和
    println(list.sum)

    // 最大值
    println(list.max)

    val list2 = List(("A", 2), ("B", 42), ("C", 1213), ("D", 33), ("E", 44))
    // 如果是复杂类型的元素。 可以重写maxBy方法来执行排序
    list2.maxBy( (tuple :(String, Int)) => tuple._2) // 按照元组的第二元素类型获取最大值（作为排序的标准）
    list2.maxBy(_._2) // 可以缩写成这样

    // 乘积
    println(list.product)

    // 最小值
    println(list.min)

    // 排序
    println(list.sorted) // 升序排序
    println(list.sorted.reverse) // 降序排序

    // 复杂类型按指定元素类型排序
    println(list2.sortBy(_._2))

    println(list2.sortBy(_._2).reverse)

    // 指定排序方式
    println(list.sortWith(_ > _))

    // 复杂类型的话
    /**
     *     list2.sortWith( (a : (String, Int), b : (String, Int)) => {
     *       a._2 > b._2
     *     })
     */
    println(list2.sortWith(_._2 > _._2))
    // 其实像这种排序和比较大小的，在JS里面就是存在的，包括Jquery，也不是什么新鲜的东西了，语法很类似，
    // 只是JS还是比较强调方法，不允许这种极致的缩写语法
  }

}

复杂函数处理：

package cn

import scala.collection.mutable

object HelloScala {
  def main(args: Array[String]): Unit = {
    val list = List(1, 2, 3, 4, 6, 10, 22)

    // - - - - - 过滤 - - - - -
    // 只获取偶数元素
    val evenList = list.filter(el => el % 2 == 0) // filter方法 自定义过滤的条件，函数结果必须是一个Boolean，符合条件的元素会被收集
    println(evenList)
    // 只获取奇数
    println(list.filter(_ % 2 == 1))

    // - - - - - 转换 toMap - - - - -
    // 将List的每个元素乘2处理
    println(list.map(el => el * 2))

    // - - - - - 扁平化 - - - - -
    val nestedList : List[List[Int]] = List(
      List(1, 2, 3, 4, 5, 10),
      List(1, 2, 3, 4, 5, 9),
    )
    // 把一个立体的数据类型合并成一个简单List对象

    // 常规处理
    val flatList = nestedList(0) ::: nestedList(1)
    println(flatList)

    // 直接调用已封装好的参数
    val flatList2 = nestedList.flatten
    println(flatList2)

    // - - - - -  扁平化和映射 - - - - -
    val strList = List(
      "username root",
      "password 123456",
      "host 127.0.0.1",
      "port 3308"
    )
    val splitList: List[Array[String]] = strList.map(str => str.split(" ")) // 分词
    println(splitList)

    val flattenList = splitList.flatten
    println(flattenList)

    // 换成flatMap直接处理完成
    val flatMapList = strList.flatMap(_.split(" "))
    println(flatMapList)

    // - - - - - 分组 GROUP BY - - - - -

    val list2 = List(1, 2, 3, 4, 5, 6, 7, 8, 9)

    // 将List直接变成奇偶两组
    val groupMap = list2.groupBy(_ % 2)
    println(groupMap) // HashMap(0 -> List(2, 4, 6, 8), 1 -> List(1, 3, 5, 7, 9))   Map[Int, List[Int]]

    val groupMap2 = list2.groupBy(data => {
      if (data % 2 == 0) "偶" else "奇"
    })
    println(groupMap2) //  Map[String, List[Int]] HashMap(偶 -> List(2, 4, 6, 8), 奇 -> List(1, 3, 5, 7, 9))

    // 给定一组词，按首次母进行区分
    val countryList = List(
      "China",
      "America",
      "Canada",
      "Japan",
      "India",
      "Australia",
      "Russia",
    )
    println(countryList.groupBy(_.charAt(0)))
    // HashMap(J -> List(Japan), A -> List(America, Australia), I -> List(India), C -> List(China, Canada), R -> List(Russia))

    // - - - - - 简化，规约 reduce - - - - -
    val list4 = List(1, 2, 3, 4)

    println(list4.reduce(_ + _)) // 10
    println(list4.reduceRight(_ + _)) // 从右边开始执行
    println(list4.reduceLeft(_ + _)) // 从左边开始执行

    println(list4.reduce(_ - _)) // -8
    println(list4.reduceRight(_ - _)) // -2
    println(list4.reduceLeft(_ - _)) // 从左边开始执行 -8

    // - - - - - 折叠？ fold Reduce扩展 - - - - -
    println(list4.fold(10)(_ + _)) // 10 + 1 + 2 + 3 + 4
    println(list4.foldLeft(10)(_ + _))
    println(list4.foldLeft(10)(_ - _))
    println(list4.foldRight(10)(_ - _)) // 1 - (2 - (3 - (4 - 10)))

    // - - - - - Map合并 - - - - -
    val map1 = Map(
      "A" -> 1,
      "B" -> 2,
      "C" -> 3,
    )
    val map2 = mutable.Map(
      "A" -> 4,
      "B" -> 5,
      "C" -> 6,
      "D" -> 9,
    )
    println(map1 ++ map2) // Map(A -> 4, B -> 5, C -> 6, D -> 9)
    // 要实现Value相加，而不是进行覆盖

    val map3 = map1.foldLeft(map2)( (mergedMap, mp) => {
        val key = mp._1
        val value = mp._2
        mergedMap(key) = mergedMap.getOrElse(key, 0) + value
        mergedMap
    })
  }
}

单词计数案例

package cn

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

    // 单词计数 案例
    val stringList = List(
      "hello",
      "hello scala",
      "hello world",
      "hello spark",
      "hello flink",
    )

    // 对字符串进行切分，得到所有单词的列表
    val strList = stringList.flatMap(_.split(" "))
    println(strList)

    // 对相同的单词进行分组处理
    // println(strList.groupBy(_)) // 这里不能直接这样写，编译器报错了
    /**
     * missing parameter type for expanded function ((<x$2: error>) => strList.groupBy(x$2))
     * println(strList.groupBy(_))
     */
    val groupMap = strList.groupBy(el => el)
    println(groupMap)

    // 对Map中的每个Value取长度，得到每个单词的个数
    val groupMap2 = groupMap.map(tp => (tp._1, tp._2.length))
    println(groupMap2)

    // map转List 排序取前3
    val sortedList = groupMap2.toList.sortWith(_._2 > _._2).take(3)
    println(sortedList)
  }
}

单词计数，复杂案例：

package cn

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

    // 单词计数 复杂案例
    val stringList : List[(String, Int)] = List(
      ("hello", 1),
      ("hello world", 2),
      ("hello scala", 3),
      ("hello spark from scala", 4),
      ("hello flink from scala", 5)
    )

    // 展开成普通的集合
    val strList = stringList.map(tuple => (tuple._1.trim + " ") * tuple._2)
    println(strList)

    val finalList = strList
      .flatMap(_.split(" "))
      .groupBy(el => el)
      .map(tuple => (tuple._1, tuple._2.length))
      .toList
      .sortWith(_._2 > _._2)
      .take(3)
    println(finalList)

    // 方式2 直接基于预计统计的结果进行转换
    val preCountList = stringList.flatMap( tuple => {
      val strings = tuple._1.split(" ")
      strings.map(word => (word, tuple._2))
    })
    println(preCountList)

    val preCountMap : Map[String, List[(String, Int)]] = preCountList.groupBy(_._1)
    println(preCountMap)

    // 这一段操作被Scala2.13版本弃用了，
    val countMap = preCountMap.mapValues(
      stringList => stringList.map(_._2).sum
    )
    println(countMap) // 这段打印拿不到对象信息

    println(countMap.toList.sortWith(_._2 > _._2).take(3)) // 但是最后调用不影响
  }
}

队列操作：

package cn

import scala.collection.immutable.Queue
import scala.collection.mutable

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

    // 队列
    val que = new mutable.Queue[String]() // 空字符串元素类型队列
    println(que)
    que.enqueue( // 入队操作
      "A",
      "B",
      "C",
      "D"
    )
    println(que)

    println(que.dequeue()) // 出列操作
    println(que)
    println(que.dequeue())
    println(que)
    println(que.dequeue())
    println(que)
    println(que.dequeue())
    println(que)

    // 不可变队列
    val que2:Queue[String] = Queue("C", "D", "E")
    val que3 = que2.enqueue("F")
    println(que3)
  }
}

并行集合：

package cn

import scala.collection.immutable.Queue
import scala.collection.mutable

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

    // 并行集合 多核优化
//    val idxSeq = (1 to 100).map(i => {
//      s"currThreadName = ${Thread.currentThread.getName}, currThreadId = ${Thread.currentThread.getId}"
//    })
//    println(idxSeq)

//    val idxSeq = (1 to 100).par.map(i => { // 这一段并行集合的已经不能使用了？
//      s"currThreadName = ${Thread.currentThread.getName}, currThreadId = ${Thread.currentThread.getId}"
//    })
//    println(idxSeq)
  }
}