Scala-17：集合-常用函数

桃扇骨 2023-10-04 16:54 158阅读 0赞

## Scala-17：集合-常用函数 ##

### 一、基本属性和常用操作 ###

**（1）获取集合长度**

//（1）获取集合长度 
    println(list.length)

**（2）获取集合大小**

//（2）获取集合大小,等同于 length 
    println(list.size)

**（3）循环遍历**

//（3）循环遍历 
    list.foreach(println)

**（4）迭代器**

//（4）迭代器 
    for (elem <- list.itera tor) {
         
        println(elem) 
    }

**（5）生成字符串**

//（5）生成字符串 
    println(list.mkString(","))

**（6）是否包含**

//（6）是否包含 
    println(list.contains(3))

### 二、衍生集合 ###

**（1）获取集合的头**

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

**（2）获取集合的尾（不是头的就是尾）**

//（2）获取集合的尾（不是头的就是尾） 
    println(list1.tail)

**（3）集合最后一个数据**

//（3）集合最后一个数据 
    println(list1.last)

**（4）集合初始数据（不包含最后一个）**

//（4）集合初始数据（不包含最后一个） 
    println(list1.init)

**（5）反转**

//（5）反转 
    println(list1.reverse)

**（6）取前（后）n 个元素**

//（6）取前（后）n 个元素 
    println(list1.take(3)) println(list1.takeRight(3))

**（7）去掉前（后）n 个元素**

//（7）去掉前（后）n 个元素 
    println(list1.drop(3)) println(list1.dropRight(3))

**（8）并集**

//（8）并集 
    println(list1.union(list2))

**（9）交集**

//（9）交集 
     println(list1.intersect(list2))

**（10）差集**

//（10）差集 
    println(list1.diff(list2))

**（11）拉链**

//（11）拉链 注:如果两个集合的元素个数不相等，那么会将同等数量的数据进行拉链，多余的数据省略不用 
    println(list1.zip(list2))

**（12）滑窗**

//（12）滑窗 
    list1.sliding(2, 5).foreach(println)

### 三、集合计算简单函数 ###

**（1）求和**

//（1）求和 
    println(list.sum)

**（2）求乘积**

//（2）求乘积 
    println(list.product)

**（3）最大值**

//（3）最大值 	
    println(list.max)

**（4）最小值**

//（4）最小值 
    println(list.min)

**（5）排序**

//（5）排序 
    // （5.1）按照元素大小排序 
    println(list.sortBy(x => x)) 
    
    // （5.2）按照元素的绝对值大小排序 
    println(list.sortBy(x => x.abs)) 
    
    // （5.3）按元素大小升序排序 
    println(list.sortWith((x, y) => x < y)) 
    
    // （5.4）按元素大小降序排序 
    println(list.sortWith((x, y) => x > y))

**（1）sorted**

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

**（2）sortBy**

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

**（3）sortWith**

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

### 四、集合计算高级函数 ###

**（1）过滤**

遍历一个集合并从中获取满足指定条件的元素组成一个新的集合

//（1）过滤 
    println(list.filter(x => x % 2 == 0))

**（2）转化/映射（map）**

将集合中的每一个元素映射到某一个函数

//（2）转化/映射 
    println(list.map(x => x + 1))

**（3）扁平化**

//（3）扁平化
    println(nestedList.flatten)

**（4）扁平化+映射 注**

flatMap 相当于先进行 map 操作，在进行 flatten 操作 集合中的每个元素的子元素映射到某个函数并返回新集合

//（4）扁平化+映射 注：flatMap 相当于先进行 map 操作，在进行 flatten操作 
    println(wordList.flatMap(x => x.split(" ")))

**（5）分组(group)**

按照指定的规则对集合的元素进行分组

//（5）分组 
    println(list.groupBy(x => x % 2))

**（6）简化（归约）**

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

val list = List(1,2,3,4) 
     
    // 将数据两两结合，实现运算规则 
    val i: Int = list.reduce( (x,y) => x-y ) 
    println("i = " + i) 
    
    // 从源码的角度，reduce 底层调用的其实就是 reduceLeft 
    //val i1 = list.reduceLeft((x,y) => x-y) 
    
    // ((4-3)-2-1) = -2 
    val i2 = list.reduceRight((x,y) => x-y) 
    println(i2)

**（7）折叠**

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

val list = List(1,2,3,4) 
     
    // fold 方法使用了函数柯里化，存在两个参数列表 
    // 第一个参数列表为 ： 零值（初始值） 
    // 第二个参数列表为： 简化规则 
    
    // fold 底层其实为 foldLeft 
    val i = list.foldLeft(1)((x,y)=>x-y) 
    
    val i1 = list.foldRight(10)((x,y)=>x-y) 
    
    println(i) 
    println(i1)

**两个集合合并**

// 两个 Map 的数据合并 
    val map1 = mutable.Map("a"->1, "b"->2, "c"->3) 
    val map2 = mutable.Map("a"->4, "b"->5, "d"->6) 
    
    val map3: mutable.Map[String, Int] = map2.foldLeft(map1) 
    {
         
        (map, kv) => {
         
            val k = kv._1 
            val v = kv._2 
    
            map(k) = map.getOrElse(k, 0) + v 
    
            map 
        } 
    } 
    
    println(map3)