Scala(四)：集合操作

墨蓝 2022-12-04 01:06 172阅读 0赞

### 文章目录 ###

*  一、基本操作
 *  二、分组groupBy
 *  三、排序sort
 *  四、映射map
 *  五、迭代iterator
 *  六、归约reduce
 *  七、折叠fold
 *  八、其他操作
 *  九、WordCount
 *  十、模式匹配

# 一、基本操作 #

val list = List(1, 2, 3, 4, 1)
        //求和
        println("sum = " + list.sum) //sum = 11
        //最大值
        println("max = " + list.max) //max = 4
        //最小值
        println("min = " + list.min) //min = 1
        //乘积
        println("product = " + list.product) //product = 24
        //反转
        println("reverse = " + list.reverse) //reverse = List(1, 4, 3, 2, 1)
        //集合元素连接
        println("mkString = " + list.mkString(",")) //mkString = 1,2,3,4,1
    	//获取集合前几位
        println("集合前3位 = " + list.take(3)) //集合前3位 = List(1, 2, 3)

# 二、分组groupBy #

val list = List(1, 2, 3, 4, 1)
        val intToInts: Map[Int, List[Int]] = list.groupBy(x => x)
        println(intToInts) //Map(2 -> List(2), 4 -> List(4), 1 -> List(1, 1), 3 -> List(3))
        // 根据字符串的第一个字符分组
        val stringList = List("11", "12", "21", "22")
        val stringToStrings: Map[String, List[String]] = stringList.groupBy(s => s.substring(0, 1))
        println(stringToStrings)

# 三、排序sort #

val list = List(1, 2, 3, 4, 1)
        /** 排序 sortBy */
        val ints = list.sortBy(x => x)
        println(ints) // List(1, 1, 2, 3, 4)
        
        /** 根据规则排序 sortWith */
        val ints1 = list.sortWith((n1, n2) => n1 > n2)
        println(ints1) // List(4, 3, 2, 1, 1)

# 四、映射map #

通过`map`映射操作来解决将集合中的元素通过指定函数映射成新的结果集合，以`HashSet`为例说明：  
![在这里插入图片描述][2020090417015542.png_pic_center]

*  集合类型都有这个`map`映射函数
 *  `[B]`是泛型，`HashSet[B]`就是返回的新的集合
 *  `map()`是一个高阶函数(可以接受一个函数的函数，就是高阶函数)，可以接收函数 `f: (A) => B`

val list = List(1, 2, 3, 4, 1)
        val tuples: Seq[(Int, Int)] = list.map(x => (x, 1))
        println(tuples)//List((1,1), (2,1), (3,1), (4,1), (1,1))
        val wc = tuples.groupBy(x => x._1).map(x => (x._1, x._2.size))
        println(wc) //Map(2 -> 1, 4 -> 1, 1 -> 2, 3 -> 1)

**扁平化操作flatmap**

val lineList = List("Hello World", "Hello Scala", "Hello Spark")
        val strings: Seq[String] = lineList.flatMap(x => x.split(" "))
        println(strings) //List(Hello, World, Hello, Scala, Hello, Spark)

# 五、迭代iterator #

val list = List(1, 2, 3, 4)
        /** 循环方式一 */
        val itr = list.iterator
        while (itr.hasNext) { 
          print(itr.next() + " ")//1 2 3 4
        }
        println("")
        /** 循环方式二 */
        val itr2 = list.iterator
        for (item <- itr2) { 
          print(item + " ")//1 2 3 4
        }

# 六、归约reduce #

![在这里插入图片描述][20200904175409204.png]

//使用reduce求和
        val list = List(1, 2, 3, 4)
        println(list.reduce((n1, n2) => n1 + n2))
        //上面可简写为下面
        println(list.reduce(_ + _))
    
        /** reduceLeft = reduce */
        println(list.reduceLeft(_ + _))
    
        /** reduceRight相当于集合reverse后reduce */
        println(list.reduceRight(_ + _))

# 七、折叠fold #

/** * fold：对集合数据进行简化，获取最终的一条数据 * fold方法可以传递2个部分的参数，第一个部分为集合外的数据 * 第二部分的参数表数数据进行逻辑处理 */
        val i = list.fold(5)(_ - _) //(((5-4)-3)-2)-1=-5
        val i2 = list.foldLeft(5)(_ - _) //(((5-4)-3)-2)-1=-5
        val i3 = list.foldRight(5)(_ - _) //1-(2-(3-(4-5)))=3
        
        /** 将两个Map进行合并，相同的key做累加，不同的key直接增加 */
        val map1 = mutable.Map("a" -> 1, "b" -> 2, "c" -> 3)
        val map2 = mutable.Map("a" -> 3, "c" -> 2, "d" -> 1)
        val stringToInt = map1.foldLeft(map2)((map, t) => { 
          map(t._1) = map.getOrElse(t._1, 0) + t._2
          map
        })
        println(stringToInt)//Map(b -> 2, d -> 1, a -> 4, c -> 5)

# 八、其他操作 #

/** 过滤 filter */
        val ints2 = list.filter(x => x % 2 == 0)
        println(ints2) //List(2, 4)
    
        /** 拉链 zip */
        val list1 = List(1, 2, 3)
        val list2 = List(3, 4, 5, 6)
        val tuples1: Seq[(Int, Int)] = list1.zip(list2)
        println(tuples1) //List((1,3), (2,4), (3,5))
    
        /** 集合并集、交集、差集 */
        val ints3: Seq[Int] = list1.union(list2)
        println(ints3) //List(1, 2, 3, 3, 4, 5, 6)
    
        val ints4: Seq[Int] = list1.intersect(list2)
        println(ints4) //List(3)
    
        val ints5: Seq[Int] = list1.diff(list2)
        println(ints5) //List(1, 2)

# 九、WordCount #

val lineList = List(("Hello Scala World", 4), ("Hello World", 3), ("Hello Spark", 2), ("Hello Flink", 1))
    
        /** floatMap 扁平化操作 */
        val tuples: Seq[(String, Int)] = lineList.flatMap(x => { 
          val words: Array[String] = x._1.split(" ")
          words.map(w => (w, x._2))
        })
        println(tuples)
    
        /** groupBy 分组 */
        val stringToTuples = tuples.groupBy(t => t._1)
        println(stringToTuples)
    
        /** map 映射 */
        val wordCount = stringToTuples.map(t => (t._1, t._2.map(t => t._2).sum))
        println(wordCount)
    
        /** mapValues 针对Map中的value进行操作 */
        println(stringToTuples.mapValues(t => t.map(tt => tt._2).sum))
    
        /** sortWith 排序 */
        val tuples1 = wordCount.toList.sortWith((left, right) => left._2 > right._2)
        println(tuples1)

# 十、模式匹配 #

`scala`中的模式匹配类似于`Java`中的`switch`语法，但是更加强大。

例:

val oper = '+'
        val n1 = 10
        val n2 = 20
        var res = 0
        oper match { 
          case '+' => res = n1 + n2
          case '-' => res = n1 - n2
          case '*' => res = n1 * n2
          case '/' => res = n1 / n2
          case _  => println("error")
        }
        println("res = "+ res)

说明：

*  如果所有`case`都不匹配，那么执行`case _`分支，类似于`Java`中`default`语句；又没有写`case _`分支，那么会抛出`MatchError`
 *  每个`case`中，不用`break`语句，自动中断`case`
 *  `=>`类似于`java swtich`的`:`，`=>`后面的代码块到下一个`case`， 是作为一个整体执行，可以使用`{}`括起来，也可以不括。
 *  可以在`match`中使用其它类型，而不仅仅是字符，可以是表达式

[2020090417015542.png_pic_center]: /images/20221123/c53413b1deda4e1299f4bfb7ef6ad98a.png
[20200904175409204.png]: /images/20221123/b3b7fa455a9a4432910dcd882de12315.png