Scala的Set+Map+Tuple

1、Set

（1）、创建无序的set

object lesson_set {
  def main(args: Array[String]): Unit = {
    val set = Set[Int](1,2,3,4,5)
    set.foreach(println)
  }
}

结果：

（2）交集

object lesson_set {
  def main(args: Array[String]): Unit = {
    val set = Set[Int](1,2,3,4,5)
    val set1 = Set[Int](3,4,5,6)
    val result1:Set[Int] = set.diff(set1) //set有set1没有的 = val result1 = set &~ set1
//    val result1:Set[Int] = set1.diff(set)  set1有，set没有
    val result2:Set[Int] = set.intersect(set1) set和set1交集
//   val result = set & set1 也是取交集
    result1.foreach(println)
    println()
    result2.foreach(println)
  }
}

结果：

（3）过滤filter

object lesson_set {
  def main(args: Array[String]): Unit = {
    val set = Set[Int](1,2,3,4,5)
    val ints:Set[Int] = set.filter(elem=>{
      elem >2
    })
    ints.foreach(println)
  }
}

结果：换行输出345

（4）、可变长set

object lesson_set {
  def main(args: Array[String]): Unit = {
    import scala.collection.mutable.Set  //可变的
//    import scala.collection.immutable.Set 不可变的
    val set = Set[Int](1,2,3) //找最近的导包
    set.+= (100)
    set.foreach(println)
  }
}

结果：

2、Map（后面的键相同则取后面的值）
（1）、创建一个map

object Lesson_Map {
  def main(args: Array[String]): Unit = {
    val map = Map[String,Int]("a"->100,"b"->200,("c",300),("c",400))
    println(map)
    map.foreach(println)
    
  }
}

结果：

（2）、获取对应的值

object Lesson_Map {
  def main(args: Array[String]): Unit = {
    val map = Map[String,Int]("a"->100,"b"->200,("c",300),("c",400))
    val value:Int = map.get("a").get
    println(value)
  }
}

结果：输出100
（3）、有值则返回，无值返回 no value

object Lesson_Map {
  def main(args: Array[String]): Unit = {
    val map = Map[String,Int]("a"->100,"b"->200,("c",300),("c",400))
    val value = map.get("aa").getOrElse(("no value"))
    println(value)
  }
}

结果：no value
（4）、遍历Map

object Lesson_Map {
  def main(args: Array[String]): Unit = {
    val map = Map[String,Int]("a"->100,"b"->200,("c",300),("c",400))
    val keys:Iterable[String] = map.keys
    keys.foreach(key=>{
      val value = map.get(key).get
      println(s"key = $key,value = $value")
    })
  }
}

结果：

（5）、值遍历

object Lesson_Map {
  def main(args: Array[String]): Unit = {
    val map = Map[String,Int]("a"->100,"b"->200,("c",300),("c",400))
    val values:Iterable[Int] = map.values
    values.foreach(println)
  }
}

结果：

6、Map2替换Map1

object Lesson_Map {
  def main(args: Array[String]): Unit = {
    val map1 = Map[String,Int](("a",1),("b",2),("c",3),("d",4))
    val map2 = Map[String,Int](("a",100),("b",2),("c",300),("e",500))
    val result:Map[String,Int] = map1.++(map2)
    result.foreach(println)
  }
}

结果：

（7）、可变长的Map

object Lesson_Map {
  def main(args: Array[String]): Unit = {
    import scala.collection.mutable.Map
    val map = Map[String,Int]()
    map.put("a",100)
    map.put("b",200)
    map.foreach(println)
  }
}

结果：

object Lesson_Map {
  def main(args: Array[String]): Unit = {
    import scala.collection.mutable.Map
    val map = Map[String,Int]()
    map.put("a",100)
    map.put("b",200)
    val result: mutable.Map[String,Int] = map.filter(tp=>{
      val key = tp._1
      val value = tp._2
      value == 200
    })
    result.foreach(println)
  }
}

结果：(b,200)

3、元组
（1）、创建元组，最多有22个元素

object Lesson_Tuple {
  def main(args: Array[String]): Unit = {
    val tuple1:Tuple1[String] = new Tuple1[String]("hello")
    val tuple2:(String,Int) = new Tuple2("a",100)
    val tuple3:(Int,Boolean,Char) = new Tuple3(1,true,'C')
    val tuple4:(Int,Double,String,Boolean) = Tuple4(1,3.4,"abc",false)
    val tuple6:(Int,Int,Int,Int,Int,String) = (1,2,3,4,5,"abc")
    //最多Tuple22
    val value:String = tuple4._3
    println(value)
  }
}

结果：输出abc
（2）、遍历元组

object Lesson_Tuple {
  def main(args: Array[String]): Unit = {
    val tuple4:(Int,Double,String,Boolean) = Tuple4(1,3.4,"abc",false)
    val iter: Iterator[Any] = tuple4.productIterator
    iter.foreach(println)
  }
}

结果：

（3）元组反转（只针对二元组）

object Lesson_Tuple {
  def main(args: Array[String]): Unit = {
    val tuple2:(String,Int) = new Tuple2("a",100)
    println(tuple2.swap)
  }
}

结果：