Scala集合

Scala提供了一套很好的集合实现,提供了一些集合类型的抽象。

Scala 集合分为可变的和不可变的集合。

可变集合可以在适当的地方被更新或扩展。这意味着你可以修改,添加,移除一个集合的元素。而不可变集合类永远不会改变。不过,你仍然可以模拟添加,移除或更新操作。但是这些操作将在每一种情况下都返回一个新的集合,同时使原来的集合不发生改变。

集合中基本结构:

几种常用集合类型示例:

  1.  
    // 定义整型 List
  2.  
    val x = List(1, 2, 3, 4)
  3.  
     
  4.  
    // 定义 Set
  5.  
    var x = Set(1, 3, 5, 7)
  6.  
     
  7.  
    // 定义 Map
  8.  
    val x = Map("one" -> 1, "two" -> 2, "three" -> 3)
  9.  
     
  10.  
    // 创建两个不同类型元素的元组
  11.  
    val x = (10, "Runoob")
  12.  
     
  13.  
    // 定义 Option
  14.  
    val x: Option[Int] = Some(5)

Scala List(列表)

Scala 列表类似于数组,它们所有元素的类型都相同,但是它们也有所不同:列表是不可变的,值一旦被定义了就不能改变,其次列表 具有递归的结构(也就是链接表结构)而数组不是。

列表的元素类型 T 可以写成 List[T]。例如,以下列出了多种类型的列表:

  1.  
    // 字符串列表
  2.  
    val site: List[String] = List("Sina", "Google", "Baidu")
  3.  
     
  4.  
    // 整型列表
  5.  
    val nums: List[Int] = List(1, 2, 3, 4)
  6.  
     
  7.  
    // 空列表
  8.  
    val empty: List[Nothing] = List()
  9.  
     
  10.  
    // 二维列表
  11.  
    val dim: List[List[Int]] =
  12.  
    List(
  13.  
    List(1, 0, 0),
  14.  
    List(0, 1, 0),
  15.  
    List(0, 0, 1)
  16.  
    )

构造列表的两个基本单位是 Nil 和 ::

Nil 也可以表示为一个空列表。

以上实例我们可以写成如下所示:(::)符号连接顺序是从右到左

  1.  
    // 字符串列表
  2.  
    val site = "Sina" :: ("Google" :: ("Baidu" :: Nil))
  3.  
     
  4.  
    // 整型列表
  5.  
    val nums = 1 :: (2 :: (3 :: (4 :: Nil)))
  6.  
     
  7.  
    // 空列表
  8.  
    val empty = Nil
  9.  
     
  10.  
    // 二维列表
  11.  
    val dim = (1 :: (0 :: (0 :: Nil))) ::
  12.  
    (0 :: (1 :: (0 :: Nil))) ::
  13.  
    (0 :: (0 :: (1 :: Nil))) :: Nil

基本操作

Scala列表有三个基本操作:

  1. head 返回列表第一个元素
  2. tail 返回一个列表,包含除了第一元素之外的其他元素:(是一个列表或者Nil)
  3. isEmpty 在列表为空时返回true

对于Scala列表的任何操作都可以使用这三个基本操作来表达。代码示例如下:

  1.  
    val site = "Sina" :: ("Google" :: ("Baidu" :: Nil))
  2.  
    val nums = Nil
  3.  
    //打印测试head、tail、isEmpty功能
  4.  
    println(site.head)
  5.  
    println(site.tail)
  6.  
    println(site.isEmpty)
  7.  
    println(nums.isEmpty)

打印结果为:

  1.  
    Sina
  2.  
    List(Google, Baidu)
  3.  
    false
  4.  
    true

连接列表

你可以使用  :::  、 List.:::()  或  List.concat()  方法来连接两个或多个列表。

代码示例如下:

  1.  
    val site1 = "Sina" :: ("Google" :: ("Baidu" :: Nil))
  2.  
    val site2 = "Facebook" :: ("Taobao" :: Nil)
  3.  
     
  4.  
    // 使用 ::: 运算符
  5.  
    var combine = site1 ::: site2
  6.  
    println( "site1 ::: site2 : " + combine )
  7.  
     
  8.  
    // 使用 list.:::() 方法,注意:结果为site2列表元素在前,site1在后
  9.  
    combine = site1.:::(site2)
  10.  
    println( "site1.:::(site2) : " + combine )
  11.  
     
  12.  
    // 使用 concat 方法
  13.  
    combine = List.concat(site1, site2)
  14.  
    println( "List.concat(site1, site2) : " + combine )
  15.  
    }

打印结果:

  1.  
    site1 ::: site2 : List(Sina, Google, Baidu, Facebook, Taobao)
  2.  
    site1.:::(site2) : List(Facebook, Taobao, Sina, Google, Baidu)
  3.  
    List.concat(site1, site2) : List(Sina, Google, Baidu, Facebook, Taobao)

List.fill()

我们可以使用 List.fill() 方法来创建一个指定重复数量的元素列表:

  1.  
    val site = List.fill(3)("Baidu") // 重复 Runoob 3次
  2.  
    println( "site : " + site )
  3.  
     
  4.  
    val num = List.fill(10)(2) // 重复元素 2, 10 次
  5.  
    println( "num : " + num )

打印结果为:

  1.  
    site : List(Baidu, Baidu, Baidu)
  2.  
    num : List(2, 2, 2, 2, 2, 2, 2, 2, 2, 2)

List.tabulate()

List.tabulate() 方法是通过给定的函数来创建列表。

方法的第一个参数为元素的数量,可以是二维的,第二个参数为指定的函数,我们通过指定的函数计算结果并返回值插入到列表中,起始值为 0,实例如下:

  1.  
    // 通过给定的函数创建 5 个元素
  2.  
    val squares = List.tabulate(6)(n => n * n)
  3.  
    println( "一维 : " + squares )
  4.  
     
  5.  
    // 创建二维列表
  6.  
    val mul = List.tabulate( 4,5 )( _ * _ )
  7.  
    println( "二维 : " + mul )

打印结果为:

  1.  
    一维 : List(0, 1, 4, 9, 16, 25)
  2.  
    二维 : List(List(0, 0, 0, 0, 0), List(0, 1, 2, 3, 4), List(0, 2, 4, 6, 8), List(0, 3, 6, 9, 12))

List.reverse

List.reverse 用于将列表的顺序反转,实例如下:

  1.  
    val site = "Sina" :: ("Google" :: ("Baidu" :: Nil))
  2.  
    println( "反转前 : " + site )
  3.  
    println( "反转前 : " + site.reverse )

打印结果为:

  1.  
    反转前 : List(Sina, Google, Baidu)
  2.  
    反转前 : List(Baidu, Google, Sina)

列表缓存(ListBuffer)

List类能够提供对列表头部,而非尾部的快速访问。如果需要向结尾添加对象,则需要先对表头前缀元素方式反向构造列表,完成之后再调用reverse。

上述问题另一种解决方式就是使用ListBuffer,这可以避免reverse操作。ListBuffer是可变对象,它可以更高效的通过添加元素来构建列表。

使用ListBuffer替代List另一个理由是避免栈溢出风险。

ListBuffer使用示例:

  1.  
    val buf: ListBuffer[Int] = new ListBuffer[Int]
  2.  
    //往后添加
  3.  
    buf += 1
  4.  
    buf += 2
  5.  
     
  6.  
    //前缀添加
  7.  
    val buf2 = 3 +: buf
  8.  
    println(buf2.toString())
  9.  
     
  10.  
    //ListBuffer转List
  11.  
    println(buf2.toList.toString())

List常用方法

  • 参考底部附录:

Scala队列和栈

队列

如果你需要先进先出序列,你可以使用Queue(队列)。Scala集合提供了可变和不可变的Queue。

不可变Queue代码示例:

  1.  
    //使用伴生对象创建一个queue
  2.  
    val que = Queue[Int]()
  3.  
     
  4.  
    //使用enqueue为不可变队列添加元素
  5.  
    val que1 = que.enqueue(1)
  6.  
     
  7.  
    //往队列添加多个元素,把集合作为enqueue的参数
  8.  
    val que2 = que1.enqueue(List(2,3,4,5))
  9.  
     
  10.  
    //从队列头部移除元素,使用dequeue
  11.  
    //第一个参数为头部移除的元素,第二个参数为剩下的队列
  12.  
    val (elem1,que3) = que2.dequeue
  13.  
     
  14.  
    //打印移除的元素
  15.  
    println(elem1)
  16.  
     
  17.  
    //打印剩下的队列
  18.  
    println(que3)

打印结果为:

  1.  
    1
  2.  
    Queue(2, 3, 4, 5)

可变Queue代码示例:

  1.  
    //使用伴生对象创建一个可变queue
  2.  
    var que = scala.collection.mutable.Queue[String]()
  3.  
     
  4.  
    //使用 += 符号添加单个元素
  5.  
    que += "A"
  6.  
     
  7.  
    //使用 ++= 符号添加多个元素
  8.  
    que ++= List("B","C","D")
  9.  
     
  10.  
    //使用dequeue移除头部元素
  11.  
    val a = que.dequeue
  12.  
     
  13.  
    //打印移除的元素
  14.  
    println(a)
  15.  
     
  16.  
    //打印队列中剩下的元素
  17.  
    print(que)

打印结果:

  1.  
    A
  2.  
    Queue(B, C, D)

如果需要的是后进先出,你可以使用Stack,它同样在Scala的集合中有可变和不可变版本。元素的推入使用push,弹出用pop,只获取栈顶元素而不移除可以使用top。

可变栈示例:

  1.  
    //使用Stack类的伴生对象创建Stack对象
  2.  
    var stack = scala.collection.mutable.Stack[Int]()
  3.  
     
  4.  
    //往栈stack中压如元素
  5.  
    stack.push(1)
  6.  
    stack.push(2)
  7.  
    stack.push(3)
  8.  
     
  9.  
    //打印查看栈内元素
  10.  
    println(stack)
  11.  
     
  12.  
    //获取栈顶元素的值
  13.  
    val tval = stack.top
  14.  
    println("栈顶元素为 : " + tval)
  15.  
     
  16.  
    //移除栈顶元素
  17.  
    val pval = stack.pop()
  18.  
    println("移除的栈顶元素为 : " + pval)
  19.  
     
  20.  
    //打印移除栈顶元素后,剩下的栈内元素
  21.  
    println(stack)

打印结果:

  1.  
    Stack(3, 2, 1)
  2.  
    栈顶元素为 : 3
  3.  
    移除的栈顶元素为 : 3
  4.  
    Stack(2, 1)

队列和栈常用操作

  • 参考底部附录:

Scala Set(集)

  1. Scala Set(集)是没有重复的对象集合,所有的元素都是唯一的。
  2. Scala 集合分为可变的和不可变的集合。
  3. 默认情况下,Scala 使用的是不可变集合,如果想使用可变集合,需引用 scala.collection.mutable.Set 包。
  4. 默认引用 scala.collection.immutable.Set。

不可变集合实例如下:

  1.  
    val set = Set(1,2,3)
  2.  
    println(set.getClass.getName) //
  3.  
     
  4.  
    println(set.exists(_ % 2 == 0)) //true
  5.  
    println(set.drop(1)) //Set(2,3)

打印结果为:

  1.  
    scala.collection.immutable.Set$Set3
  2.  
    true
  3.  
    Set(2, 3)

如果需要使用可变集合需要引入 scala.collection.mutable.Set:

  1.  
    import scala.collection.mutable.Set // 可以在任何地方引入 可变集合
  2.  
     
  3.  
    val mutableSet = Set(1,2,3)
  4.  
    println(mutableSet.getClass.getName) // scala.collection.mutable.HashSet
  5.  
    //往集合内添加元素4
  6.  
    mutableSet.add(4)
  7.  
    //删除值为1的元素
  8.  
    mutableSet.remove(1)
  9.  
    //添加元素5
  10.  
    mutableSet += 5
  11.  
    //删除值为3的元素
  12.  
    mutableSet -= 3
  13.  
     
  14.  
    println(mutableSet) // Set(5, 3, 4)
  15.  
     
  16.  
    val another = mutableSet.toSet
  17.  
    println(another.getClass.getName) // scala.collection.immutable.Set

注意: 虽然可变Set和不可变Set都有添加或删除元素的操作,但是有一个非常大的差别。对不可变Set进行操作,会产生一个新的set,原来的set并没有改变,这与List一样。 而对可变Set进行操作,改变的是该Set本身,与ListBuffer类似。

 

Set集合基本操作

Scala Set集合有三个基本操作:

  1. head 返回集合第一个元素
  2. tail 返回一个集合,包含除了第一元素之外的其他元素
  3. isEmpty 在集合为空时返回true

对于Scala集合的任何操作都可以使用这三个基本操作来表达。

代码示例如下:

  1.  
    val site = Set("Sina", "Google", "Baidu")
  2.  
    val nums: Set[Int] = Set()
  3.  
     
  4.  
    println( "head : " + site.head )
  5.  
    println( "tail : " + site.tail )
  6.  
    println( "isEmpty : " + site.isEmpty )
  7.  
    println( "isEmpty : " + nums.isEmpty )

打印结果为:

  1.  
    head : Sina
  2.  
    tail : Set(Google, Baidu)
  3.  
    isEmpty : false
  4.  
    isEmpty : true

连接集合

你可以使用 ++ 运算符或 Set.++() 方法来连接两个集合。如果元素有重复的就会移除重复的元素。实例如下:

  1.  
    val site1 = Set("Sina", "Google", "Baidu")
  2.  
    val site2 = Set("Faceboook", "Taobao")
  3.  
     
  4.  
    // ++ 作为运算符使用
  5.  
    var site = site1 ++ site2
  6.  
    println( "site1 ++ site2 : " + site )
  7.  
     
  8.  
    // ++ 作为方法使用
  9.  
    site = site1.++(site2)
  10.  
    println( "site1.++(site2) : " + site )

打印结果为:

  1.  
    site1 ++ site2 : Set(Faceboook, Taobao, Sina, Google, Baidu)
  2.  
    site1.++(site2) : Set(Faceboook, Taobao, Sina, Google, Baidu)

 

查找集合中最大与最小元素

你可以使用 Set.min 方法来查找集合中的最小元素,使用 Set.max 方法查找集合中的最大元素。实例如下:

  1.  
    val num = Set(5,6,9,20,30,45)
  2.  
     
  3.  
    // 查找集合中最大与最小元素
  4.  
    println( "Set(5,6,9,20,30,45) 最小元素是 : " + num.min )
  5.  
    println( "Set(5,6,9,20,30,45) 最大元素是 : " + num.max )

打印结果为:

  1.  
    Set(5,6,9,20,30,45) 最小元素是 : 5
  2.  
    Set(5,6,9,20,30,45) 最大元素是 : 45

交集

你可以使用 Set.& 方法或 Set.intersect 方法来查看两个集合的交集元素。实例如下:

  1.  
    val num1 = Set(5,6,9,20,30,45)
  2.  
    val num2 = Set(50,60,9,20,35,55)
  3.  
     
  4.  
    // 交集
  5.  
    println( "num1.&(num2) : " + num1.&(num2) )
  6.  
    println( "num1.intersect(num2) : " + num1.intersect(num2) )

打印结果为:

  1.  
    num1.&(num2) : Set(20, 9)
  2.  
    num1.intersect(num2) : Set(20, 9)

Scala Set 常用方法

  • 参考底部附录:

Scala Map(映射)

  1. Map(映射)是一种可迭代的键值对(key/value)结构。
  2. 所有的值都可以通过键来获取。
  3. Map 中的键都是唯一的。
  4. Map 也叫哈希表(Hash tables)。
  5. Map 有两种类型,可变与不可变,区别在于可变对象可以修改它,而不可变对象不可以。
  6. 默认情况下 Scala 使用不可变 Map。如果你需要使用可变集合,你需要显式的引入 import scala.collection.mutable.Map 类
  7. 在 Scala 中 你可以同时使用可变与不可变 Map,不可变的直接使用 Map,可变的使用 mutable.Map。

以下实例演示了不可变 Map 的应用:

  1.  
    // 空哈希表,键为字符串,值为整型
  2.  
    var A:Map[Char,Int] = Map()
  3.  
     
  4.  
    // Map 键值对演示
  5.  
    val lang= Map("Java" -> "Oracle", "C#" -> "Microsoft")
  6.  
    或者
  7.  
    val lang= Map(("Java","Oracle"), ("C#" , "Microsoft"))

定义 Map 时,需要为键值对定义类型。如果需要添加 key-value 对,可以使用 + 号,如下所示:

A += ('t' ->10 )

Map 基本操作

Scala Map 几种基本操作:keys、values、isEmpty、赋值(可变映射)

代码示例:

Keys:

  1.  
    val lang = Map("Java" -> "Oracle",
  2.  
    "C#" -> "Microsoft",
  3.  
    "Swift" -> "Apple")
  4.  
    Values:
  5.  
    val nums: Map[Int, Int] = Map()
  6.  
    println( "lang 中的键为 : " + lang.keys )
  7.  
    println( "lang 中的值为 : " + lang.values )

isEmpty:

  1.  
    println( "lang 是否为空 : " + lang.isEmpty )
  2.  
    println( "nums 是否为空 : " + nums.isEmpty )

keys和isEmpty的打印结果为:

  1.  
    lang 中的键为 : Set(Java, C#, Swift)
  2.  
    lang 中的值为 : MapLike(Oracle, Microsoft, Apple)
  3.  
    lang 是否为空 : false
  4.  
    nums 是否为空 : true

赋值:

  1.  
    var lang= scala.collection.mutable.Map("Java" -> "Oracle", "C#" -> "Microsoft")
  2.  
    lang("Java") = "sun"
  3.  
    println(lang)

打印结果为:

Map(C# -> Microsoft, Java -> sun)

Map 合并

你可以使用 ++ 运算符或 Map.++() 方法来连接两个 Map,Map 合并时会移除重复的 key。以下演示了两个 Map 合并的实例:

  1.  
    val lang =Map("Java" -> "Oracle",
  2.  
    "C#" -> "Microsoft",
  3.  
    "Swift" -> "Apple")
  4.  
    val color = Map("blue" -> "#0033FF",
  5.  
    "yellow" -> "#FFFF00",
  6.  
    "red" -> "#FF0000")
  7.  
     
  8.  
    // ++ 作为运算符
  9.  
    var colors = lang ++ color
  10.  
    println( "lang ++ colors : " + colors )
  11.  
     
  12.  
    // ++ 作为方法
  13.  
    colors = lang.++(colors)
  14.  
    println( "lang.++(colors)) : " + colors )

打印结果为:

  1.  
    lang ++ colors : Map(blue -> #0033FF, C# -> Microsoft, yellow -> #FFFF00, Java -> Oracle, red -> #FF0000, Swift -> Apple)
  2.  
    lang.++(colors)) : Map(blue -> #0033FF, C# -> Microsoft, yellow -> #FFFF00, Java -> Oracle, red -> #FF0000, Swift -> Apple)

输出 Map 的 keys 和 values

以下通过 foreach 循环输出 Map 中的 keys 和 values:

  1.  
    val lang =Map("Java" -> "Oracle",
  2.  
    "C#" -> "Microsoft",
  3.  
    "Swift" -> "Apple")
  4.  
     
  5.  
    lang.keys.foreach{ i =>
  6.  
    print( "Key = " + i )
  7.  
    println("\tValue = " + lang(i) )}

打印结果为:

  1.  
    Key = JavaValue = Oracle
  2.  
    Key = C#Value = Microsoft
  3.  
    Key = SwiftValue = Apple

查看 Map 中是否存在指定的 Key

你可以使用 Map.contains 方法来查看 Map 中是否存在指定的 Key。实例如下:

  1.  
    val lang =Map("Java" -> "Oracle",
  2.  
    "C#" -> "Microsoft",
  3.  
    "Swift" -> "Apple")
  4.  
     
  5.  
    if(lang.contains("Swift")) {
  6.  
    println(lang("Swift")+"创造了 Swift 语言")
  7.  
    }

打印结果为:

Apple创造了 Swift 语言

迭代映射

  1.  
    val lang = Map("Java" -> "Oracle", "C#" -> "Microsoft")
  2.  
    for ((k, v) <- lang) {
  3.  
    println(k + " : " + v)
  4.  
    }

打印结果为:

  1.  
    Java : Oracle
  2.  
    C# : Microsoft

映射中K,V反转

  1.  
    val lang = Map("Java" -> "Oracle", "C#" -> "Microsoft")
  2.  
    val lang2 = for ((k, v) <- lang) yield (v, k)
  3.  
    for ((k, v) <- lang2) {
  4.  
    println(k + " : " + v)
  5.  
    }

打印结果为:

  1.  
    Oracle : Java
  2.  
    Microsoft : C#

已排序映射

  1.  
    //按照key的字典顺序排序。
  2.  
    val scores = scala.collection.immutable.SortedMap(("Bob", 8), ("Alice", 21), ("Fred", 17), ("Cindy", 15))
  3.  
    scores.foreach(person => println(person._1 + " : " + person._2))

打印结果为:

  1.  
    Alice : 21
  2.  
    Bob : 8
  3.  
    Cindy : 15
  4.  
    Fred : 17

Scala Map常用方法

  • 参考底部附录:

Scala Tuple(元组)

与列表一样,元组也是不可变的,但与列表不同的是元组可以包含不同类型的元素。

元组的值是通过将单个的值包含在圆括号中构成的。例如:

  1.  
    //元组中定义了三个元素,对应的类型分别为[Int, Double, java.lang.String]。
  2.  
    val tuple1 = (1, 5.20, "Spark")
  3.  
    //或者
  4.  
    val tuple2 = new Tuple3(1,5.20,"Spark")

我们可以使用 tuple1._1 访问第一个元素, tuple1._2 访问第二个元素,如下所示:

  1.  
    //元组中定义了三个元素,对应的类型分别为[Int, Double, java.lang.String]。
  2.  
    val tuple1 = (1, 5.20, "Spark")
  3.  
     
  4.  
    println(tuple1._1 + " : " + tuple1._2 + " : " + tuple1._3)

打印结果为:

1 : 5.2 : Spark

迭代元组

你可以使用 Tuple.productIterator() 方法来迭代输出元组的所有元素:

  1.  
    //元组中定义了三个元素,对应的类型分别为[Int, Double, java.lang.String]。
  2.  
    val tuple1 = (1, 5.20, "Spark")
  3.  
     
  4.  
    tuple1.productIterator.foreach{i => println("value : " + i)}

打印结果为:

  1.  
    value : 1
  2.  
    value : 5.2
  3.  
    value : Spark

元组转为字符串

你可以使用 Tuple.toString() 方法将元组的所有元素组合成一个字符串,实例如下:

  1.  
    //元组中定义了三个元素,对应的类型分别为[Int, Double, java.lang.String]。
  2.  
    val tuple1 = (1, 5.20, "Spark")
  3.  
     
  4.  
    println(tuple1.toString())

打印结果为:

(1,5.2,Spark)

元素交换

你可以使用 Tuple.swap 方法来交换元组的元素。如下实例:

  1.  
    //元组中定义了两个元素,对应的类型分别为[Int, java.lang.String]。
  2.  
    val tuple1 = (1, "Spark")
  3.  
    //注意:swap函数只能用于两个元素元组
  4.  
    println(tuple1.swap)

打印结果为:

(Spark,1)

使用模式匹配获取元组

代码示例:

  1.  
    val t = (1, 3.14, "Fred")
  2.  
    val (first, second, third) = t
  3.  
    println(first + " : " + second + " : " + third)

打印结果:

1 : 3.14 : Fred

拉链操作

  1.  
    val num = Array(1, 2, 3)
  2.  
    val str = Array("first", "second", "third")
  3.  
    val com = num.zip(str).toMap
  4.  
    println(com(1)+" : "+com(2)+" : "+com(3))

打印结果为:

first : second : third

元组常用方法

  • 参考底部附录:

Scala Option(选项)

Scala Option(选项)类型用来表示一个值是可选的(有值或无值)。

Option[T] 是一个类型为 T 的可选值的容器: 如果值存在, Option[T] 就是一个 Some[T] ,如果不存在, Option[T] 就是对象 None 。

代码示例:

  1.  
    val myMap: Map[String, String] = Map("key1" -> "value")
  2.  
    val value1: Option[String] = myMap.get("key1")
  3.  
    val value2: Option[String] = myMap.get("key2")
  4.  
     
  5.  
    println(value1) // Some("value1")
  6.  
    println(value2) // None

打印结果为:

  1.  
    Some(value)
  2.  
    None

Option 有两个子类别,一个是 Some,一个是 None,当他回传 Some 的时候,代表这个函式成功地给了你一个 String,而你可以透过 get() 这个函式拿到那个 String,如果他返回的是 None,则代表没有字符串可以给你。

通过模式匹配来输出匹配值。

代码示例:

  1.  
    val lang =Map("Java" -> "Oracle",
  2.  
    "C#" -> "Microsoft",
  3.  
    "Swift" -> "Apple")
  4.  
     
  5.  
    println(show(lang.get("Swift")))
  6.  
    println(show(lang.get("Scala")))
  7.  
     
  8.  
    def show(x:Option[String]) = x match {
  9.  
    case Some(s) => s
  10.  
    case None => "?"
  11.  
    }

打印结果为:

  1.  
    Apple
  2.  
    ?

getOrElse() 方法

你可以使用 getOrElse() 方法来获取元组中存在的元素或者使用其默认的值,实例如下:

  1.  
    val a:Option[Int] = Some(5)
  2.  
    val b:Option[Int] = Some(7)
  3.  
    val c:Option[Int] = None
  4.  
     
  5.  
    println("a.getOrElse(0): " + a.getOrElse(0) )
  6.  
    println("b.getOrElse(1): " + b.getOrElse(1) )
  7.  
    println("c.getOrElse(10): " + c.getOrElse(10))

打印结果为:

  1.  
    a.getOrElse(0): 5
  2.  
    b.getOrElse(1): 7
  3.  
    c.getOrElse(10): 10

isEmpty() 方法

你可以使用 isEmpty() 方法来检测元组中的元素是否为 None,实例如下:

  1.  
    val a:Option[Int] = Some(5)
  2.  
    val b:Option[Int] = None
  3.  
    println("a.isEmpty: " + a.isEmpty )
  4.  
    println("b.isEmpty: " + b.isEmpty )

打印结果为:

  1.  
    a.isEmpty: false
  2.  
    b.isEmpty: true

Scala Option 常用方法

  • 参考底部附录:

Scala Iterator(迭代器)

  1. Scala Iterator(迭代器)不是一个集合,它是一种用于访问集合的方法。
  2. 迭代器 it 的两个基本操作是 next 和 hasNext。
  3. 调用 it.next() 会返回迭代器的下一个元素,并且更新迭代器的状态。
  4. 调用 it.hasNext() 用于检测集合中是否还有元素。

让迭代器 it 逐个返回所有元素最简单的方法是使用 while 循环:

  1.  
    val it = Iterator("Baidu", "Google", "Tencent", "Taobao")
  2.  
     
  3.  
    while (it.hasNext){
  4.  
    println(it.next())
  5.  
    }

打印结果为:

  1.  
    Baidu
  2.  
    Google
  3.  
    Tencent
  4.  
    Taobao

查找最大与最小元素

你可以使用 it.min 和 it.max 方法从迭代器中查找最大与最小元素,实例如下:

  1.  
    val ita = Iterator(20, 40, 2, 50, 69, 90)
  2.  
    val itb = Iterator(20, 40, 2, 50, 69, 90)
  3.  
     
  4.  
    println("最大元素是:" + ita.max)
  5.  
    println("最小元素是:" + itb.min)

执行结果为:

  1.  
    最大元素是:90
  2.  
    最小元素是:2

获取迭代器的长度

你可以使用 it.size 或 it.length 方法来查看迭代器中的元素个数。实例如下:

  1.  
    val ita = Iterator(20, 40, 2, 50, 69, 90)
  2.  
    val itb = Iterator(20, 40, 2, 50, 69, 90)
  3.  
     
  4.  
    println("ita.size : " + ita.size)
  5.  
    println("itb.length : " + itb.length)

打印结果为:

  1.  
    ita.size : 6
  2.  
    itb.length : 6

Scala Iterator 常用方法

  • 参考底部附录:

附录:

List常用方法

队列和栈常用操作

Scala Set 常用方法

 

Scala Map常用方法

元组常用方法

Scala Option 常用方法

Scala Iterator 常用方法

Scala集合类型详解的更多相关文章

  1. JAVA集合类型详解

    一.前言 作为java面试的常客[集合类型]是永恒的话题:在开发中,主要了解具体的使用,没有太多的去关注具体的理论说明,掌握那几种常用的集合类型貌似也就够使用了:导致这一些集合类型的理论有可能经常的忘 ...

  2. C#进阶系列——WebApi 接口返回值不困惑:返回值类型详解

    前言:已经有一个月没写点什么了,感觉心里空落落的.今天再来篇干货,想要学习Webapi的园友们速速动起来,跟着博主一起来学习吧.之前分享过一篇 C#进阶系列——WebApi接口传参不再困惑:传参详解  ...

  3. Java集合中List,Set以及Map等集合体系详解

    转载请注明出处:Java集合中List,Set以及Map等集合体系详解(史上最全) 概述: List , Set, Map都是接口,前两个继承至collection接口,Map为独立接口 Set下有H ...

  4. (转)C# WebApi 接口返回值不困惑:返回值类型详解

    原文地址:http://www.cnblogs.com/landeanfen/p/5501487.html 正文 前言:已经有一个月没写点什么了,感觉心里空落落的.今天再来篇干货,想要学习Webapi ...

  5. Scala进阶之路-Scala函数篇详解

    Scala进阶之路-Scala函数篇详解 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.传值调用和传名调用 /* @author :yinzhengjie Blog:http: ...

  6. (转)MySQL字段类型详解

    MySQL字段类型详解 原文:http://www.cnblogs.com/100thMountain/p/4692842.html MySQL支持大量的列类型,它可以被分为3类:数字类型.日期和时间 ...

  7. [转]C#进阶系列——WebApi 接口返回值不困惑:返回值类型详解

    本文转自:http://www.cnblogs.com/landeanfen/p/5501487.html 阅读目录 一.void无返回值 二.IHttpActionResult 1.Json(T c ...

  8. Mybatis----resultMap类型详解

    Mybatis----resultMap类型详解 这篇文章主要给大家介绍了关于Mybatis中强大的resultMap功能的相关资料,文中通过示例代码介绍的非常详细,对大家学习或者使用Mybatis具 ...

  9. MySQL中tinytext、text、mediumtext和longtext等各个类型详解

    转: MySQL中tinytext.text.mediumtext和longtext等各个类型详解 2018年06月13日 08:55:24 youcijibi 阅读数 26900更多 个人分类: 每 ...

随机推荐

  1. Brute Force Sorting(HDU6215)

    题意:给你长度为n的数组,定义已经排列过的串为:相邻两项a[i],a[i+1],满足a[i]<=a[i+1].我们每次对当前数组删除非排序过的串,合并剩下的串,继续删,直到排序完成. 题解:用双 ...

  2. Autofac解耦事件总线

    事件总线之Autofac解耦 事件总线是通过一个中间服务,剥离了常规事件的发布与订阅(消费)强依赖关系的一种技术实现.事件总线的基础知识可参考圣杰的博客[事件总线知多少] 本片博客不再详细概述事件总线 ...

  3. (11)线程池(最新的concurrent.futures包去开启)

    '''concurrent.futures是最新的开启线程池的包'''import timefrom concurrent.futures import ThreadPoolExecutor #开启线 ...

  4. LG4781 【模板】拉格朗日插值

    题意 题目描述 由小学知识可知,$n$个点$(x_i,y_i)$可以唯一地确定一个多项式 现在,给定$n$个点,请你确定这个多项式,并将$k$代入求值 求出的值对$998244353$取模 输入输出格 ...

  5. c# 复制文件夹

    调用VB.NET方法最便捷 引入 Microsoft.VisualBasic.dll 调用 Microsoft.VisualBasic.FileIO.FileSystem.CopyDirectory( ...

  6. tile38 复制配置

    基于复制我们可以保证tile38 server 的ha 环境准备 docker-compose 文件 说明里面多了一个webhook 的服务,可以不用管   version: "3" ...

  7. Delphi中Json格式读写

    Json是一种轻量级传输数据格式,广泛应用互联网和各应用中.json主要採用键值对来表示数据项.多个数据项之间用逗号分隔,也能够用于数组.以下注重介绍一下在delphi中使用json,在delphi中 ...

  8. Python_getter和setter方法

    当给属性赋值的时候,使用实例.属性=属性值的方式显然把属性暴露出来了,并且也无法对属性值进行限制检查,java中提供了setter和getter方法,那么python是如何做的呢?更多内容请参考:Py ...

  9. script标签的同步和异步

    1).把<script>标签放在<head>中意味着必须等到全部的js代码都下载解析和执行完成以后,才开始展现页面内容,为避免这个问题一般把js代码全部放在<body&g ...

  10. springfox+swagger2生成API文档

    1.建立一个spring mvc工程: 2.添加POM依赖: <properties> <springfoxversion>2.6.1</springfoxversion ...