Scala之元组和 Map 集合的定义 ,方法 ,遍历(5)

一  元组

scala 中存在一种特殊的集合元组 ,元组中可以存储任意类型的元素 ,但是只能存储 22 个元素 ,其中对偶元组常作键值映射 .

元组是不可变的 ,但可以包含不同类型的元素

  def main(args: Array[String]): Unit = {
    --------------------元组------------------
    元组的定义方法1
    val tuple: (Int, Int, Int) = new Tuple3(1, 2, 3)

    元组的定义方法2
    val tuple1 = ("zss", "lss", "wuu")

    将元组的元素取出来并且转为大写
    println(tuple1.toString().toUpperCase)       // (ZSS,LSS,WUU)

    -----------------取值------------------------
    将元组的第一个元素取出来
    val value = tuple._1  
    println(value)       // 1

    将元组的第二个元素取出来     
    val value1 = tuple1._2
    println(value1)      // lss
}

    ------------------对偶元组----------------------
    对偶元组的定义
    val tuple2 = (("zss", 12), ("lii", 16), ("huu", 18))

    对偶元组的取值-----将对偶元组的第三组第一个元素取出来
    println(tuple2._3._1)               // huu

    -------------------------------------对偶元组的组装方法1-------------------
    var line = "tom,lii,yuu,poo,too"
    将字符串切割 ,变成一个数组 ,装有单词
    val strings: Array[String] = line.split(",")

    遍历数组 ,并将数组的一个个元素变成 (单词,1) 形式的map集合类型
    val tuples: Array[(String, Int)] = strings.map(e => (e, 1))

    然后遍历
    tuples.foreach(println(_))               // (tom,1) (lii,1) (yuu,1) (poo,1) (too,1)

    ------------------------------------对偶元组的组装方法2-----------------------
    line.split(",").map((_,1)).foreach(println(_))     //(tom,1) (lii,1) (yuu,1) (poo,1) (too,1)

二  Map 集合(映射)

map 集合也分为可变 map 和不可变 map ,使用包名来区分是可变的还是不可变的 map 集合

1  不可变的 map 集合

def main(args: Array[String]): Unit = {
    ---------map 集合的定义
    val mp1: Map[String, String] = Map[String, String](("caocao", "wei"), ("qshuang", "qin"), ("liubei", "sanguo"))
    val mp2: Map[String, Int] = Map[String, Int]("liubang" -> 54, "sunxiaomei" -> 21, "zhaoyunfei" -> 24)

    ---------map 集合的遍历
    mp1.foreach(println(_))        //(caocao,wei) (qshuang,qin)  (liubei,sanguo)
    mp2.foreach(println)     // (liubang,54) (sunxiaomei,21)  (zhaoyunfei,24)

    ---------取 map 集合的长度
    println(mp1.size)     // 3
    println(mp2.size)     // 3

    ----------获取所有的 key -----------
    mp1.keys.foreach(println)           // caocao  qshuang liubei
    mp1.keySet.foreach(println(_))       // caocao  qshuang liubei
    mp1.map(e=>e._1).foreach(println(_))  // caocao  qshuang liubei
    mp1.map(_._1).foreach(println)          // caocao  qshuang liubei

    ------------获取所有的 value -----------
    mp1.values.foreach(println(_))         // wei  qin   sanguo
    mp2.valuesIterator.foreach(println(_))    // 54  21  24
    mp2.map(_._2).foreach(println)            // 54  21  24  */
    mp2.keys.map(key=>mp2.get(key)).foreach(println)   // Some(54) Some(21)   Some(24)
    mp2.keys.map(key=>mp2.getOrElse(key,"默认值")).foreach(println)   //  54  21  24


  }

    ------map 集合的定义-------
    val map1=Map[String, Int](("n1", 10), ("n2", 11), ("n3", 12))

    ----------map 集合的遍历-------------for---------------
    for (elem <- map1) {
      val key = elem._1
      val value = elem._2
      println(key)        // n1 n2 n3
      println(value)      // 10 11 12
      println(elem)       // (n1,10) (n2,11) (n3,12)
    }

    for((k,v) <- map1){
      println(k)         // n1 n2 n3
      println(v)         // 10 11 12
      println((k,v))     // (n1,10) (n2,11) (n3,12)
    }   */

    ----------map集合的遍历---------------foreach-------------
    map1.foreach(println)        // (n1,10) (n2,11) (n3,12)

    -----------map集合的遍历---------------map------------------
    map1.map(e=>println(e))
    map1.map(println(_))
    map1.map(println)

    ----------------转 List 和 Array ------------------------
    val list: List[(String, Int)] = map.toList
    val array: Array[(String, Int)] = map.toArray

2  可变的 map 集合

 ---------------不可变的map没有put方法--------------
 -------------------定义可变的集合--------导包---------
 import scala.collection._

 val map = new mutable.HashMap[String, String]()
 map.put("wd", "ssf")
 map.put("sl", "fsy")

3  filter和 filterNot

适用于 : 数组  List  Map

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

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

val ls: List[Int] = List.range(1,10)
ls.filter(x=>x%2==0)
val new_list: List[Int] = ls.filter(_ % 2 == 0)//  _ 代表每个元素
new_list .foreach(x=>print(x+"  "))  // 2  4  6  8
ls.filterNot(_%2!=1).foreach(x=>print(x+"  ")) 1  3  5  7  9  

3.1  每个元素进行过滤

val set = Set("spark" , "scala" , "c++" , "java")

下划线 (_) 代表所有的元素 ,筛选出开头是 "s" 的元素
val new_set: Set[String] = set.filter(_.startsWith("s"))
set.filter(_.length>3)

3.2  多条件 filter 进行条件过滤

val ls = "spark":: "scala" :: "c++"::"java"::1::2::12.34::Nil

过滤出选过滤出String类型的和Double类型的数据
ls.filter{
  case i:String => true
  case i:Int=>false
  case i:Double=>true
}

3.3  连续使用多次 filter 进行条件过滤

连续使用多次filter进行条件过滤
val map = Map[String,Int](("zss" ,91),("zww",89),("zzx",92) , ("ww",23))
map.filter(_._1.startsWith("z")).filter(_._2>90)

​​​​​​​