scala（七）：集合常用函数

基本属性和常用操作

object SetTest01 {
  def main(args: Array[String]): Unit = {
    //创建集合
    val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8)
    println(list)
    //获取长度
    println(list.length)
    //获取集合大小
    println(list.size)
    println("============")
    //循环遍历
    list.foreach(println)
    println("============")
    //迭代器
    for (e <- list.iterator) {
      println(e)
    }
    println("============")
    //生成字符串
    println(list.mkString(","))
    //是否包含
    println(list.contains(4))
  }
}

衍生集合

object SetTest02 {
  def main(args: Array[String]): Unit = {
    //创建集合
    val list: List[Int] = List(1, 2, 3, 4, 5, 6)
    val list1: List[Int] = List(4, 5, 6, 7, 8, 9)
    println(list)
    println(list1)
    //获取集合头
    println(list.head)
    //获取集合尾
    println(list.tail)
    //集合最后一个数据
    println(list.last)
    //集合最初数据(没有最后一个)
    println(list.init)
    //反转
    println(list.reverse)
    //取前（后）n个数据
    println(list.take(3))
    println(list.takeRight(3))
    //去前（后）n个数据
    println(list.drop(3))
    println(list.dropRight(3))
    //并集
    println(list.union(list1))
    //交集
    println(list.intersect(list1))
    //差集
    println(list.diff(list1))
    println(list1.diff(list))
    //拉链
    //如果两个集合的元素个数不相等，那么会将同等数量的数据进行拉链，多余的数据省略不用
    println(list.zip(list1))
    //滑窗
    list.sliding(3,1).foreach(println)
  }
}

集合计算简单函数

（1）sorted对一个集合进行自然排序，通过传递隐式的Ordering。

（2）sortBy对一个属性或多个属性进行排序，通过它的类型。

（3）sortWith基于函数的排序，通过一个comparator函数，实现自定义排序的逻辑。

object SetTest03 {
  def main(args: Array[String]): Unit = {
    // 创建集合
    val list: List[Int] = List(-8,1, 2, 3, 4, -5,-5)
    println(list)
    //求和
    println(list.sum)
    //求乘积
    println(list.product)
    //最大值
    println(list.max)
    //最小值
    println(list.min)
    //排序
    //按照元素大小排序
    println(list.sortBy(x => x))
    //按照元素绝对值大小排序
    println(list.sortBy(x => x.abs))
    //按照元素大小升序排序
    println(list.sortWith((x, y)=> x < y))
    //按照元素大小降序排序
    println(list.sortWith((x, y) => x >y))
  }
}

集合计算高级函数

过滤filter，映射/转换map，扁平化flatten，扁平化+映射flatMap，分组groupBy，简化/归约reduce，折叠fold。

object SetTest04 {
  def main(args: Array[String]): Unit = {
    // 创建集合
    val list: List[Int] = List(-8,1, 2, 3, 4, -5,-5)
    val list1: List[List[Int]] = List(List(1, 2, 3, 4), List(5, 6, 7, 8), List(9, 10, 11, 12))
    val list2: List[String] = List("hello scala.", "hello world!", "hello jeffry")
    println(list)
    println(list1)
    println(list2)
    //过滤
    println(list.filter(x => x % 2 == 0))
    //转化/映射
    println(list.map(x => x + 2))
    //扁平化
    println(list1.flatten)
    //扁平化+映射 注：flatmap相当于先进行map，再进行flatten操作
    println(list2.flatMap(x => x.split(" ")))
    //分组
    println(list.groupBy(x => x % 2))
  }
}

Reduce简化（归约）：通过指定的逻辑将集合的数据进行聚合，从而减少数据，最终获取结果。

Fold折叠：化简的一种特殊情况。

import scala.collection.mutable

object SetTest05 {
  def main(args: Array[String]): Unit = {
    // 创建集合
    val list: List[Int] = List(-8,1, 2, 3, 4, -5,-5)
    println(list)
    println(list.reduce( _ + _))
    //Reduce简化（归约）：通过指定的逻辑将集合的数据进行聚合，从而减少数据，最终获取结果
    //将数据两两结合，实现运算规则
    val i = list.reduce((x, y) => x - y)
    println(i)
    val i1 = list.reduceLeft((x, y) => x-y)
    println(i1)
    val i2 = list.reduceRight((x, y) => x - y)
    println(i2)
    //Fold折叠：化简的一种特殊情况
    //fold方法使用了函数柯里化，存在两个参数列表
    //第一个参数列表为：零值（初始值）
    //第二个参数列表为：简化规则
    val i3 = list.fold(2)((x, y) => x + y)
    println(i3)
    val i4 = list.foldRight(8)((x, y) => x + y)
    println(i4)
    val map = mutable.Map("a" -> 1, "b" -> 2, "c" -> 3,"d" -> 4)
    val map1 = mutable.Map("a" -> 4, "b" -> 5, "c" -> 6)
    println(map)
    println(map1)
    val function: mutable.Map[String, Int] = map1.foldLeft(map) {
      (map,kv) => {
        val k = kv._1
        val v = kv._2
        map(k) = map.getOrElse(k, v) + v
        map
      }
    }
    println(function)
  }
}

案例：WordCount

object WordCount {
  def main(args: Array[String]): Unit = {
    // 单词计数：将集合中出现的相同的单词，进行计数，取计数排名前三的结果
    //创建数据
    val worldlist = List("hello world", "hello scala", "hello java", "scala and java")
    println(worldlist)
    //1.将每一个字符串转化成为一个一个的单词
    val list = worldlist.flatMap(x => x.split(" "))
    println(list)
    //2.将相同的单词放在一起
    val stringToStrings = list.groupBy(x => x)
    println(stringToStrings)
    //3.对相同的单词进行计数
    val map = stringToStrings.map(tuple => (tuple._1, tuple._2.size))
    println(map)
    //4.对计数完成后的结果进行排序
    val list1 = map.toList.sortWith(
      (left, right) => {
        left._2 > right._2
      }
    )
    println(list1)
    //5.取结果前3
    val list2 = list1.take(3)
    println(list2)
  }
}