这是我参与2022首次更文挑战的第8天，活动详情查看：2022首次更文挑战」

常用集合操作

Map

map 对列表中的每个元素应用一个函数，返回应用后的元素所组成的列表。

def main(args: Array[String]): Unit = {
    import scala.collection.mutable._
    val numbers=mutable.Seq(1,2,3,4,5,6)
    val result = numbers.map((i: Int) => i * 2)
    result.foreach(println)
  }

或者传入一个函数：

def main(args: Array[String]): Unit = {
    def timesTwo(i: Int): Int = i * 2
    val numbers=mutable.Seq(1,2,3,4,5,6)
    val result = numbers.map(timesTwo)
    result.foreach(println)
}
______________________________________________
输出：
2
4
6
8
10
12

foreach

foreach 很像 map ，但没有返回值。 foreach 仅用于有副作用的函数。

def main(args: Array[String]): Unit = {
  val numbers=mutable.Seq(1,2,3,4,5,6)
  numbers.foreach((i: Int) =>  println(s"当前遍历的数值为$i"))
}
__________________________________________________________
输出：
当前遍历的数值为1
当前遍历的数值为2
当前遍历的数值为3
当前遍历的数值为4
当前遍历的数值为5
当前遍历的数值为6

该函数返回值为Unit类型。

filter

filter 移除任何对传入函数计算结果为 false 的元素。返回一个布尔值的函数通常被称为谓词函数[或判定函数]。

def main(args: Array[String]): Unit = {
    val numbers=mutable.Seq(1,2,3,4,5,6)
    val result_1 = numbers.filter((i: Int) => i % 2 == 0)
    result_1.foreach(println)
    println("_____________或者传入一个方法________________")
    def computed(i: Int): Boolean = i % 3 == 0
    val result_2 = numbers.filter(computed)
    result_2.foreach(println)
  }
————————————————————————————————————————————————————————————————
输出：
2
4
6
_____________或者传入一个方法________________
3
6

zip

zip 将两个列表的内容聚合到一个对偶列表中。

def main(args: Array[String]): Unit = {
    val value = List(1, 2, 3).zip(List"a", "b", "c"))
    value.foreach(deep)
    def deep(value:Any): Unit ={
      println(value)
      println(value.getClass)
    }
    println(s"value = ${value}")
  }
____________________________________________
输出：
(1,a)
class scala.Tuple2
(2,b)
class scala.Tuple2
(3,c)
class scala.Tuple2
value = List((1,a), (2,b), (3,c))

partition

partition 将使用给定的谓词函数分割列表。

def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    val result = numbers.partition(_ % 2 == 0)
    println(result)
  }
_____________________________
**输出：(可以看出List被依据的条件分割为2个List)**
(List(2, 4, 6, 8, 10),List(1, 3, 5, 7, 9))

find

find 返回集合中第一个匹配判断函数的元素。返回的元素被some包裹也就是Java中的Optional

def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
     println(numbers.find((i: Int) => i >= 5))
     println(numbers.find((i: Int) => i >= 11))
    println("_____________________________________")
    //可以使用getOrElse对Some进行Null的默认值设置
    println(numbers.find((i: Int) => i >= 5).getOrElse(0))
    println(numbers.find((i: Int) => i >= 11).getOrElse(0))
  }
输出：
Some(5)
None
_____________________________________
5
0

drop & dropWhile

drop 将删除前i个元素

def main(args: Array[String]): Unit = {
  val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
  val value = numbers.drop(5)
  println(value)
}

dropWhile 将删除元素直到找到第一个匹配谓词函数的元素。例如，如果我们在numbers列表上使用 dropWhile。

def main(args: Array[String]): Unit = {
  val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
  val result_1 = numbers.dropWhile(_+1<=5)
   **//由于从1开始就不满足条件所以不会有数据删除**
  val result_2 = numbers.dropWhile(_+1>5)
println(result_1)
println(result_2)
}
____________________________________________
输出：
List(5, 6, 7, 8, 9, 10)
List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

foldLeft & foldRight

0为初始值（记住numbers是 List[Int] 类型），m作为一个累加器。

foldRight 和 foldLeft 一样，只是运行过程相反。

def main(args: Array[String]): Unit = {
  def logger(m: Int, n: Int,info:String ):Int={
    println(s"$info,m的值$m,n的值$n")
    m + n
  }
  val logger_result1=logger(_:Int,_:Int,"result1")
  val logger_result2=logger(_:Int,_:Int,"result2")
  val numbers = List(1, 2, 3, 4, 5)
  val result_1 = numbers.foldLeft(0)(logger_result1)
  val result_2 = numbers.foldRight(0)( logger_result2)
  println(s"最后得出的值为$result_1")
  println("---------------------------")
  println(s"最后得出的值为$result_2")
}
__________________________________________________
输出：
result1,m的值0,n的值1
result1,m的值1,n的值2
result1,m的值3,n的值3
result1,m的值6,n的值4
result1,m的值10,n的值5
result2,m的值5,n的值0
result2,m的值4,n的值5
result2,m的值3,n的值9
result2,m的值2,n的值12
result2,m的值1,n的值14
最后得出的值为15
---------------------------
最后得出的值为15

flatten

flatten 将嵌套结构扁平化为一个层次的集合。

def main(args: Array[String]): Unit = {
    val flatten = List(List(1, 2), List(3, 4), List(5, 6)).flatten
    println(flatten)
  }
——————————————————————————————————————————————————————————————————
输出：
List(1, 2, 3, 4, 5, 6)

flatMap

flatMap 是一种常用的组合子，结合映射 [mapping] 和扁平化 [flattening] 。 flatMap 需要一个处理嵌套列表的函数，然后将结果串连起来。

def main(args: Array[String]): Unit = {
    val names = List("Alice", "Bon", "Nick")

    //需求是将 List 集合中的所有元素, 进行扁平化的操作, 即把所有的元素打散
    val names2: Any = names.flatMap(upper)
    println(s"names2: ${names2}")

    val list1 = List("hello world", "kino hello", "hello hello hello")
    //val list2: List[List[String]] = list1.map(x => x.split(" ").toList)
    val list2: List[String] = list1.flatMap(x => x.split(" "))
    println(s"list2: ${list2}")
  }

  def upper(s: String): String = {
    s.toUpperCase()
  }
______________________________________________________________
输出：
names2: List(A, L, I, C, E, B, O, N, N, I, C, K)
list2: List(hello, world, kino, hello, hello, hello, hello)

Scala——集合（下）