Scala这一路 之 高级语法3-List、Iterator、Set、Map、元组Tuple

摘要：Scala Collection 提供了一系列集合类型，这些类型又分为可变的与不可变的。可变集合大家可以随意去做增删改集合中的元素，对于不可变集合大家也可以去做增删改，但是每一种操作后都会返回一个新的集合，之前的集合是不会改变的。不过在纯函数式程序是不会使用可变变量的。使用可变变量多加小心！

官网链接：https://www.scala-lang.org/api/current/?_ga=1.178639076.1310790544.1468501313

目录

Scala List

Scala Set

Scala Map

Iterator

元组Tuple

---

• Scala List

  • List元素可重复，可为空，链式存储结构

• # String集合
  scala> var list1:List[String] = List("Java","IE","CE","Scala")
  var list1:List[String] = List("Java","IE","CE","Scala")
  list1: List[String] = List(Java, IE, CE, Scala)
  
  scala> val arrays = "A"::("B" :: ("C":: Nil))
  val arrays = "A"::("B" :: ("C":: Nil))
  arrays: List[String] = List(A, B, C)
  
  scala> println(list1)
  println(list1)
  List(Java, IE, CE, Scala)
  
  # 空集合1
  scala> val emptyList : List[Nothing] = List()
  val emptyList : List[Nothing] = List()
  emptyList: List[Nothing] = List()
  
  scala> println(emptyList)
  println(emptyList)
  List()
  
  #空集合2
  scala> val nums = Nil
  val nums = Nil
  nums: scala.collection.immutable.Nil.type = List()
  
  scala> println(nums)
  println(nums)
  List()
  
  
  
  #二维集合
  
  scala> val twoDimensionalList : List[List[String]] = List(List("Java","JavaEE","Scala"),List("HBase","Hive","Hadoop"),List("Spring","struts"))
  val twoDimensionalList : List[List[String]] = List(List("Java","JavaEE","Scala"),List("HBase","Hive","Hadoop"),List("Spring","struts"))
  twoDimensionalList: List[List[String]] = List(List(Java, JavaEE, Scala), List(HBase, Hive, Hadoop), List(Spring, struts))
  
  scala> println(twoDimensionalList)
  println(twoDimensionalList)
  List(List(Java, JavaEE, Scala), List(HBase, Hive, Hadoop), List(Spring, struts))
  
  
  ###常用语法####
  
  scala> val list1:List[String] = List("Java","IE","CE","Scala")
  val list1:List[String] = List("Java","IE","CE","Scala")
  list1: List[String] = List(Java, IE, CE, Scala)
  
  #返回第一个元素
  scala> println(list1.head)
  println(list1.head)
  Java
  
  #返回一个列表，不包含第一个元素
  scala> println(list1.tail)
  println(list1.tail)
  List(IE, CE, Scala)
  
  #是否为空
  scala> println(list1.isEmpty)
  println(list1.isEmpty)
  false
  
  #反转
  scala> println(list1.reverse)
  println(list1.reverse)
  List(Scala, CE, IE, Java)
  
  #重复3次
  scala> val redundant = List.fill(3)("重复")
  val redundant = List.fill(3)("重复")
  redundant: List[String] = List(重复, 重复, 重复)
  
  #集合连接
  scala> val list12= list1 ::: list2 ::: list1
  val list12= list1 ::: list2 ::: list1
  list12: List[String] = List(Java, IE, CE, Scala, Java1, IE1, CE1, Java, IE, CE, Scala)
  
  

  更多用法参考官网：https://www.scala-lang.org/api/current/scala/collection/immutable/List.html

• Scala Set

• Set 集合的一种，无重复元素，无序；
• 默认情况Scala使用的是不可变Set在scala.collection.immutable包，可变Set在scala.collection.mutable.Set包

• #Set  默认Set   scala.collection.immutable
  scala> val set1 = Set(1,2,3)
  val set1 = Set(1,2,3)
  set1: scala.collection.immutable.Set[Int] = Set(1, 2, 3) 
  
  scala> println(set1)
  println(set1)
  Set(1, 2, 3)
  
  #输出集合第一个元素
  scala> println(set1.head)
  println(set1.head)
  1
  
  #输出集合 不含第一个元素
  scala> println(set1.tail)
  println(set1.tail)
  Set(2, 3)
  
  #判断Set集合是否为空
  scala> println(set1.isEmpty)
  println(set1.isEmpty)
  false
  
  #集合set1最小值
  scala> println(set1.min)
  println(set1.min)
  1
  
  #集合set1最大值
  scala> println(set1.max)
  println(set1.max)
  3
  #连接Set,使用  ++ 符号
  scala> val set2 = Set("4","Scala","Hello")
  val set2 = Set("4","Scala","Hello")
  set2: scala.collection.immutable.Set[String] = Set(4, Scala, Hello)
                           
  
  scala> val setAll = set1 ++ set2
  val setAll = set1 ++ set2
  setAll: scala.collection.immutable.Set[Any] = Set(4, Scala, 1, 2, 3, Hello)
  
  
  #Set集合交集
  scala> val set1 = Set(1,3,5)
  val set1 = Set(1,3,5)
  set1: scala.collection.immutable.Set[Int] = Set(1, 3, 5)
  
  scala> val set2 = Set(1,7,2)
  val set2 = Set(1,7,2)
  set2: scala.collection.immutable.Set[Int] = Set(1, 7, 2)
  
  scala> println(set1.&(set2))
  println(set1.&(set2))
  Set(1)
  
  scala> println(set1.intersect(set2))
  println(set1.intersect(set2))
  Set(1)
  
  

  更多用法参考官网：https://www.scala-lang.org/api/current/scala/collection/immutable/Set.html

• Scala Map

• Map ,<键，值>=> <K , V > 结构，K 唯一
• 默认scala使用的是不可变Map,在包scala.collection.immutable   ，如果要使用可变Map，引用包 import scala.collection.mutable.Map

• #Map scala默认引用的是不可变Map ， 包位置 scala.collection.immutable.Map
  #添加元素后会提示错误
  scala> val map1:Map[String,String] = Map()
  val map1:Map[String,String] = Map()
  map1: Map[String,String] = Map()
  
  scala> map1 += ("a" -> "A")
  map1 += ("a" -> "A")
  <console>:13: error: value += is not a member of Map[String,String]
    Expression does not convert to assignment because receiver is not assignable.
         map1 += ("a" -> "A")
  
  #导入可变Map  
  scala> import scala.collection.mutable.Map
  import scala.collection.mutable.Map
  import scala.collection.mutable.Map
  
  #再次声明map1,就可以成功了
  scala> val map1:Map[String,String] = Map()
  val map1:Map[String,String] = Map()
  map1: scala.collection.mutable.Map[String,String] = Map()
  
  scala> map1 += ("a" -> "A")
  map1 += ("a" -> "A")
  res29: map1.type = Map(a -> A)
  
  scala> println(map1)
  println(map1)
  Map(a -> A)
  
  #map2
  scala> val map2 = Map("java"-> "面向对象语言", "scala" -> "函数式编程语言")
  val map2 = Map("java"-> "面向对象语言", "scala" -> "函数式编程语言")
  map2: scala.collection.mutable.Map[String,String] = Map(scala -> 函数式编程语言, java -> 面向对象语言)
  
  #map keys
  scala> println(map2.keys)
  println(map2.keys)
  Set(scala, a, java)
  
  #map values
  scala> println(map2.values)
  println(map2.values)
  HashMap(函数式编程语言, A, 面向对象语言)
  
  #Map 是否为空
  scala> println(map2.isEmpty)
  println(map2.isEmpty)
  false
  
  #遍历mapALL  key 获取value
  scala> mapAll.keys.foreach{ i => println("key:"+ i +" Value: "+ mapAll(i) )}
  mapAll.keys.foreach{ i => println("key:"+ i +" Value: "+ mapAll(i) )}
  key:scala Value: 函数式编程语言
  key:java Value: 面向对象语言
  key:a Value: A
  
  #map 连接
  
  scala> val mapAll = map1 ++ map2
  val mapAll = map1 ++ map2
  mapAll: scala.collection.mutable.Map[String,String] = Map(scala -> 函数式编程语言, java -> 面向对象语言, a -> A)
  
  

  更多用法参考官网：https://www.scala-lang.org/api/current/scala/collection/immutable/Map.html

• Iterator

• 迭代器，非集合，属于访问集合的工具方法
• 牢记两个基本操作
  • it.next()： 返回下一个元素
  • it.hasNext: 判断是否还有元素（注，没有括号哦）

  • #Iterator 迭代器 hasNext   next()
    scala> val it = Iterator("a","b","c","d")
    val it = Iterator("a","b","c","d")
    it: Iterator[String] = non-empty iterator
    
    scala> println(it)
    println(it)
    non-empty iterator
    
    #输出
    scala> while(it.hasNext){println(it.next())}
    while(it.hasNext){println(it.next())}
    a
    b
    c
    d

    更多用法参考官网：https://www.scala-lang.org/api/current/scala/collection/Iterator.html

• 元组Tuple

• 元组是一个容器，存放多种类型元素，且不可变。
• 元素是通过将单个的值包含在圆括号中构成的

• #元组Tuple
  #写法1
  scala> val tuple1 = (1,"test",2.31,19.99f)
  val tuple1 = (1,"test",2.31,19.99f)
  tuple1: (Int, String, Double, Float) = (1,test,2.31,19.99)
  
  #写法2 
  scala> val tuple1 = Tuple4(1,"test",2.31,19.99f)
  val tuple1 = Tuple4(1,"test",2.31,19.99f)
  tuple1: (Int, String, Double, Float) = (1,test,2.31,19.99)
  
  #输出具体位置 数组元素   ._i
  scala> println(tuple1._1 +"|" +  tuple1._3)
  println(tuple1._1 +"|" +  tuple1._3)
  1|2.31
  
  #输出全部数组元素
  scala> tuple1.productIterator.foreach( i => println("value ="+ i))
  tuple1.productIterator.foreach( i => println("value ="+ i))
  value =1
  value =test
  value =2.31
  value =19.99

  Tuple更多用法见官网：

  •  https://www.scala-lang.org/api/current/scala/Tuple1.html  

  • https://www.scala-lang.org/api/current/scala/Tuple2.html

 

END~