Scala 集合的常用方法

计算类

声明一个集合

val listInt: List[Int] = List(1, 2, 3, 4, 5)

最大值

max

println( "Max = "+ listInt.max)
-------------------------------
Max = 5

最小值

min

println("Min = " + listInt.min)
-------------------------------
Min = 1

乘积

product

println("product = "+ listInt.product)
--------------------------------------
product = 120

排序

创建一个集合

val listStr: List[String] = List("21", "22", "33", "11", "aa")
val listInt: List[Int] = List(1, 2, 3, 4, 5)

sortBy()

按照某个标准排序，参数传入一个函数

按照大小排序

val value2: List[Int] = listInt.sortBy(x => x)
println(value2.mkString(","))
-----------------------------
1,2,3,4,5

按照个位的大小排序

val value3: List[String] = listStr.sortBy((s) => s.substring(1, 2))
println(value3.mkString(","))
-----------------------------
21,11,22,33,aa

sortWith()

指定排序规则

创建集合

val listInt: List[Int] = List(1, 2, 3, 4, 5)
val listStr1: List[String] = List("21", "22", "33", "11")

大小排序

把 > 改成 <就是升序

val value4: List[Int] = listInt.sortWith((left, right) => {
        left > right  // 左边的大于右边的 降序
    })
println(value4.mkString(","))
-----------------------------
5,4,3,2,1

按照个位排序

val value5: List[String] = listStr1.sortWith((left, right) => {
            left.substring(1, 2).toInt < right.substring(1, 2).toInt
    })
println(value5.mkString(","))
-----------------------------
21,11,22,33

结构类

对集合中的每个元素进行操作，每个元素的结构映射（变换）

集合反转

创建集合

val listInt: List[Int] = List(1, 2, 3, 4, 5)

反转

val reverse: List[Int] = listInt.reverse
println(reverse.mkString(","))
------------------------------
5,4,3,2,1

groupBy()

分组，传入函数是需要指定 Key 值，会返回一个 (K,List()),(K1,List()),..，这的Map集合

创建集合

val listStr: List[String] = List("21", "22", "33", "11", "aa")

按照自身分组

private val value: Map[String, List[String]] = listStr.groupBy((x) => {x})
value.foreach(println)
----------------------
(11,List(11))
(33,List(33))
(22,List(22))
(21,List(21))
(aa,List(aa))

按照首位数字分组

val value1: Map[String, List[String]] = listStr.groupBy(x => x.substring(0, 1))
value1.foreach(println)
-----------------------
(a,List(aa))
(1,List(11))
(2,List(21, 22))
(3,List(33))

map()

映射，元素结构转换

创建集合

val listStr2 = List("a", "a", "c", "c", "b", "a")

把每个元素转换成 (元素,1)

val value6: List[(String, Int)] = listStr2.map((x) => (x, 1))
println(value6.mkString(","))
-----------------------------
(a,1),(a,1),(c,1),(c,1),(b,1),(a,1)

偏平化

创建集合

val listStr3 = List("Hello Scala", "Hello Python", "Hello Java")

扁平化

val value9: List[String] = listStr3.flatMap(x => x.split(" "))
println(listStr3.mkString(","))
println(value9.mkString(","))
-------------------------------
Hello Scala,Hello Python,Hello Java
Hello,Scala,Hello,Python,Hello,Java

如果集合里的元素不太规律，就需要把进行判断处理

val listAny: List[Any] = List(1, List(2, 3), List(4, 5),66)
    val value12: List[Any] = listAny.flatMap((Any) => {
        if (Any.isInstanceOf[List[Int]]) {
            Any.asInstanceOf[List[Int]]  // 转换成可迭代的类型
        } else {
            List(Any)
        }
    })
println(value12)
------------------------------
List(1, 2, 3, 4, 5, 66)

过滤

判断为 True 的留下，False 的去掉

val ListToInt: List[Int] = List(1, 2, 3, 4)

过滤大于 2 的数

val value10: List[Int] = ListToInt.filter(x => x > 2)
println(value10.mkString(","))
------------------------------
3,4

zip

创建集合

val ListToInt: List[Int] = List(1, 2, 3, 4)
val ListToInt1: List[Int] = List(2, 3, 4, 5)

zip 操作

val value11: List[(Int, Int)] = ListToInt.zip(ListToInt1)
println(value11.mkString(","))
------------------------------
(1,2),(2,3),(3,4),(4,5)

其他(待补充)

reduce()

会对集合元素进行两两操作，最后得出一个值

创建一个集合

 val listInt: List[Int] = List(1, 2, 3, 4, 5)

实现集合相加，跟 sum() 一样

val i: Int = listInt.reduce((right, left) => {
        right + left
    })
println(i)
----------
15
// 实际逻辑
（（（（1+ 2）+ 3）+ 4）+ 5）+ 6