Scala 集合常用方法

1. foreach

迭代遍历集合中的每个元素,对每个元素进行处理 ,但是没有返回值 ,常用于打印结果数据 !

适用于所有的集合类型，Array、List、Set、Iterator、Map

object Foreach {
  def main(args: Array[String]): Unit = {
    // List
    val ls1 = List(1,2,3,4,5)
    ls1.foreach(e=>println(e))
    ls1.foreach(e=>print(e+"   "))
    ls1.foreach(e=>println(e*10))
    ls1.foreach(println(_))
    ls1.foreach(println)
    // Map
    val map1 = Map(("a",1),"b"->2,"c"->3)
    map1.foreach(tp=>println(tp))
    map1.foreach(tp=>println(tp._1))
    map1.foreach(tp=>println(tp._2))

    map1.foreach(e=>{
      val k = e._1
      val v = e._2
      println((k, v))
    })
    })
  }
}

2. Map

适用于任意集合

注意Map集合的用法

 map函数遍历每个元素处理返回原集合类型的新集合 , 也可以不返回数据

列表,数组,Map中都有map函数  元组中没有map函数

object MapDemo {
  def main(args: Array[String]): Unit = {
    val ls = List(1, 2, 3, 4)
    val mp = Map[String, Int](("a", 1), "b" -> 2, "c" -> 3)
    ls.map(e=>e*10).foreach(println)
    val ls1 = ls.map(e=>e*10)
    ls1.foreach(println)
    // 可嵌套的 更加灵活
    val ls2: List[Int] = for (elem <- ls) yield elem * 10
    // 处理每个元素，返回的数据结构没有发生变化
    mp.map(ele=>{
      (ele._1.toUpperCase,ele._2*10)
    }).foreach(println)
    val mp4 = mp.map(e=>{
      (e._1,e._1.toUpperCase,e._2,e._2*10)
    })
    mp.map(e=>{
      (e._1,e._1.toUpperCase,e._2,e._2*10)
    }).foreach(println)
    // 处理每个元素，返回的数据结构发生变化，只返回V
    val map3 = mp.map(e=>e._2)
  }
}

3. Filter/FilterNot

适用于 数组  List  Map

filter返回符合自己条件的新的集合, filterNot返回不符合自己条件的新的集合

object FilterDemo {
  def main(args: Array[String]): Unit = {
    val ls = List(1, 2, 3, 4)
    val arr = Array("spark" , "scala" , "c++" , "java")
    val mp = Map[String, Int](("a", 1), "b" -> 2, "c" -> 3)
    // 取list中大于3的数
    val ls1 = ls.filter(e=>e>3)
    ls1.foreach(println)
    // 取偶数
    ls.filter(_%2==0).foreach(println)
    // 多条件过滤，使用&符号
    ls.filter(e=>e>3 && e <6).foreach(println)
    // 多条件过滤，还可以多次调用filter
    ls.filter(_>3).filter(_<6).foreach(print)
    // 筛选出以“s”开头的单词
    arr.filter(_.startsWith("s")).foreach(println)
    val map1: Map[String, Int] = mp.filter(_._1.startsWith("a")).filter(_._2 > 0)
    map1.foreach(println)
  }
}

案例：

object FilterTest1 {
  def main(args: Array[String]): Unit = {
    val mp = Map[String, Array[String]](
      ("sl", Array("ts", "zbj", "hhs", "shaseng")),
      ("em", Array()),
      ("gb", Array("hg", "tg"))
    )
    mp.filter(_._2.length>0).foreach(tp=>println(tp._1+"   "+tp._2.toList))
    val ls = List("abc", "java", "", "\t\t ")
    ls.filter(! _.trim.isEmpty).foreach(println)
  }
}

 

// 筛选出数字，并*10
object FilterTest2 {
  def main(args: Array[String]): Unit = {
    val ls = List(1,2,3,4,5,"jim","jack")
    ls.filter(_.isInstanceOf[Int]*10).foreach(println)
  }
}

4. Collect

常用于 数组  List  Map

collect函数也可以遍历集合中的每个元素处理返回新的集合

def map[B](f: (A) ⇒ B): List[B]
def collect[B](pf: PartialFunction[A, B]): List[B]

主要支持偏函数

object CollectDemo {
  def main(args: Array[String]): Unit = {
    val ls = List[Any](1, 2, 3, 4, 5, 6, 7, "hello", "jim")
    // 偏函数，对集合中的某一种数据类型进行处理
    val pf = new PartialFunction[Any,Int] {
      // 遍历集合中的每个元素，如果为指定的类型返回true，否则返回false
      override def isDefinedAt(x: Any): Boolean = {
        x.isInstanceOf[Int]
      }
      // 上面方法返回true，执行这个方法，对数据进行操作
      override def apply(v1: Any): Int = {
        v1.asInstanceOf[Int]*10  // 将数据强转为Int类型，因为原类型为Any
      }
    }
//    ls.collect(pf).foreach(println)
    val ls2: List[Int] = ls.collect(pf)
    ls2.foreach(println)
//    ls.map(pf).foreach(println)    //  map() 不支持偏函数
  }
}

5. Min/Max/Sum

适用于 数组  List  Map，map 默认按照key排序获取最大和最小数据 

 

7. MinBy/MaxBy

 

 

8. 

9. 

10.