Scala学习笔记(八)(Set以及Map)

最新推荐文章于 2025-09-11 17:55:27 发布

weixin_33800593

最新推荐文章于 2025-09-11 17:55:27 发布

阅读量134

点赞数

CC 4.0 BY-SA版权

文章标签： scala

原文链接：http://www.cnblogs.com/yangshuo-w/p/6945571.html

本文介绍了Scala中的集合和映射的基本概念与操作方法，包括不可变与可变集合的区别，集合的操作如查找、串联等，以及映射的键值对操作。

Scala集合为相同类型的配对的不同元素的集合。换句话说，集合是不包含重复元素的集合。有两种集合，不可改变的和可变的。可变和不可变的对象之间的区别在于，当一个对象是不可变的，对象本身不能被改变。

默认情况下，Scala中使用不可变的集。如果想使用可变集，必须明确地导入scala.collection.mutable.Set类。如果想在同一个同时使用可变和不可变的集合，那么可以继续参考不变的集合，但可以参考可变设为mutable.Set。以下是声明不变集合示例：

// Empty set of integer type
var s : Set[Int] = Set()

// Set of integer type
var s : Set[Int] = Set(1,3,5,7)

or 

var s = Set(1,3,5,7)

在定义空集，类型注释是必要的，因为系统需要指定一个具体的类型变量。

集合基本操作：

集合所有操作可以体现在以下三个方法：

方法	描述
head	此方法返回集合的第一个元素。
tail	该方法返回集合由除第一个以外的所有元素。
isEmpty	如果设置为空，此方法返回true，否则为false。

以下是上述方法中的例子显示的用法：

object Test {
   def main(args: Array[String]) {
      val fruit = Set("apples", "oranges", "pears")
      val nums: Set[Int] = Set()

      println( "Head of fruit : " + fruit.head )
      println( "Tail of fruit : " + fruit.tail )
      println( "Check if fruit is empty : " + fruit.isEmpty )
      println( "Check if nums is empty : " + nums.isEmpty )
   }
}

当上述代码被编译和执行时，它产生了以下结果：

C:/>scalac Test.scala
C:/>scala Test
Head of fruit : apples
Tail of fruit : Set(oranges, pears)
Check if fruit is empty : false
Check if nums is empty : true

串联集合：

可以使用++运算符或集。++()方法来连接两个或多个集，但同时增加了集它会删除重复的元素。以下是这个例子来连接两个集合：

object Test {
   def main(args: Array[String]) {
      val fruit1 = Set("apples", "oranges", "pears")
      val fruit2 = Set("mangoes", "banana")

      // use two or more sets with ++ as operator
      var fruit = fruit1 ++ fruit2
      println( "fruit1 ++ fruit2 : " + fruit )

      // use two sets with ++ as method
      fruit = fruit1.++(fruit2)
      println( "fruit1.++(fruit2) : " + fruit )
   }
}

当上述代码被编译和执行时，它产生了以下结果：

C:/>scalac Test.scala
C:/>scala Test
fruit1 ++ fruit2 : Set(banana, apples, mangoes, pears, oranges)
fruit1.++(fruit2) : Set(banana, apples, mangoes, pears, oranges)

C:/>

查找集合中最大，最小的元素：

可以使用Set.min方法找出最小元素，Set.max方法找出一组可用最大元素。以下为例子来说明的用法：

object Test {
   def main(args: Array[String]) {
      val num = Set(5,6,9,20,30,45)

      // find min and max of the elements
      println( "Min element in Set(5,6,9,20,30,45) : " + num.min )
      println( "Max element in Set(5,6,9,20,30,45) : " + num.max )
   }
}

让我们编译和运行上面的程序，这将产生以下结果：

C:/>scalac Test.scala
C:/>scala Test
Min element in Set(5,6,9,20,30,45) : 5
Max element in Set(5,6,9,20,30,45) : 45

C:/>

查找集合的共同值：

可以使用Set.&方法或Set.intersect方法找出两个集合之间的共同值。以下的例子来说明的用法：

bject Test {
   def main(args: Array[String]) {
      val num1 = Set(5,6,9,20,30,45)
      val num2 = Set(50,60,9,20,35,55)

      // find common elements between two sets
      println( "num1.&(num2) : " + num1.&(num2) )
      println( "num1.intersect(num2) : " + num1.intersect(num2) )
   }
}

让我们编译和运行上面的程序，这将产生以下结果：

C:/>scalac Test.scala
C:/>scala Test
num1.&(num2) : Set(20, 9)
num1.intersect(num2) : Set(20, 9)

C:/>

Scala集合方法：

以下是可以同时使用集合的重要方法。有关可用方法的完整列表，请Scala官方文档。

SN	方法及描述
1	def +(elem: A): Set[A] 创建一组新的具有附加元件，除非该元件已经存在
2	def -(elem: A): Set[A] 创建一个新的从这个集合中删除一个给定的元素
3	def contains(elem: A): Boolean 如果elem包含在这个集合返回true，否则为false。
4	def &(that: Set[A]): Set[A] 返回新的集合组成在这个集合，并在给定的集合，所有的元素。
5	def &~(that: Set[A]): Set[A] 返回此集合和另一个集合的差异
6	*def +(elem1: A, elem2: A, elems: A): Set[A] 创建一个新的不可变的集合与来自传递集合额外的元素**
7	def ++(elems: A): Set[A] 连接此不可变的集合使用另一个集合到这个不可变的集合的元素。
8	*def -(elem1: A, elem2: A, elems: A): Set[A] 返回包含当前不可变的集合，除了每一个给定参数的元素之一，较少出现的所有元素的不可变的集合。**
9	def addString(b: StringBuilder): StringBuilder 这追加不可变的集到一个字符串生成器的所有元素。
10	def addString(b: StringBuilder, sep: String): StringBuilder 这追加不可变的集合使用分隔字符串一个字符串生成器的所有元素。
11	def apply(elem: A) 测试如果一些元素被包含在这个集合。
12	def count(p: (A) => Boolean): Int 计算在不可变的集合满足谓词的元素数。
13	def copyToArray(xs: Array[A], start: Int, len: Int): Unit 这种不可变的集合到一个数组的副本元素。
14	def diff(that: Set[A]): Set[A] 计算这组和另一组的差异。
15	def drop(n: Int): Set[A]] 返回除了第n个的所有元素。
16	def dropRight(n: Int): Set[A] 返回除了最后的n个的所有元素。
17	def dropWhile(p: (A) => Boolean): Set[A] 丢弃满足谓词的元素最长前缀。
18	def equals(that: Any): Boolean equals方法的任意序列。比较该序列到某些其他对象。
19	def exists(p: (A) => Boolean): Boolean 测试谓词是否持有一些这种不可变的集合的元素。
20	def filter(p: (A) => Boolean): Set[A] 返回此不可变的集合满足谓词的所有元素。
21	def find(p: (A) => Boolean): Option[A] 找到不可变的集合满足谓词，如有第一个元素
22	def forall(p: (A) => Boolean): Boolean 测试谓词是否持有这种不可变的集合中的所有元素。
23	def foreach(f: (A) => Unit): Unit 应用一个函数f这个不可变的集合中的所有元素。
24	def head: A 返回此不可变的集合的第一个元素。
25	def init: Set[A] 返回除了最后的所有元素。
26	def intersect(that: Set[A]): Set[A] 计算此set和另一组set之间的交叉点。
27	def isEmpty: Boolean 测试此集合是否为空。
28	def iterator: Iterator[A] 创建一个新的迭代器中包含的可迭代对象中的所有元素。
29	def last: A 返回最后一个元素。
30	def map[B](f: (A) => B): immutable.Set[B] 通过应用函数这一不可变的集合中的所有元素构建一个新的集合。
31	def max: A 查找最大的元素。
32	def min: A 查找最小元素。
33	def mkString: String 显示此不可变的集合字符串中的所有元素。
34	def mkString(sep: String): String 显示此不可变的集合在一个字符串使用分隔字符串的所有元素。
35	def product: A *返回此不可变的集合相对于操作在num的所有元素的产物。**
36	def size: Int 返回此不可变的集合元素的数量。
37	def splitAt(n: Int): (Set[A], Set[A]) 返回一对不可变的集合组成这个不可变的集的前n个元素，以及其他元素。
38	def subsetOf(that: Set[A]): Boolean 返回true，如果此set就是一个子集，也就是说，如果这集合的每个元素也是一个元素。
39	def sum: A 返回此不可变的集合的所有元素的总和使用对于+运算符在num。
40	def tail: Set[A] 返回一个不可变的集合组成这个不可变的集合的所有元素，除了第一个。
41	def take(n: Int): Set[A] 返回前n个元素。
42	def takeRight(n: Int):Set[A] 返回最后n个元素。
43	def toArray: Array[A] 返回一个包含此不可变的集合的所有元素的数组。
44	def toBuffer[B >: A]: Buffer[B] 返回一个包含此不可变的集合中的所有元素的缓冲区。
45	def toList: List[A] 返回一个包含此不可变的集合中的所有元素的列表。
46	def toMap[T, U]: Map[T, U] 这种不可变的集合转换为映射
47	def toSeq: Seq[A] 返回一个包含此不可变的集的所有元素的序列。
48	def toString(): String 返回对象的字符串表示。

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Scala Map[K, V]

Scala中的映射是键/值对的集合。任何值可以根据它的键进行检索。键是在映射唯一的，但值不一定是唯一的。映射也被称为哈希表。有两种类型的映射，不可变以及可变的。可变和不可变的对象之间的区别在于，当一个对象是不可变的，对象本身不能被改变。

默认情况下，Scala中使用不可变的映射。如果想使用可变集，必须明确地导入scala.collection.mutable.Map类。如果想在同一个同时使用可变和不可变的映射，那么可以继续参考不可变的映射作为映射，但可以参考可变集合为mutable.Map。以下是该示例声明不可变的映射如下：

// Empty hash table whose keys are strings and values are integers:
var A:Map[Char,Int] = Map()

// A map with keys and values.
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")

在定义空映射，类型注释是必要的，因为系统需要指定一个具体的类型变量。如果我们要一个键值对添加到映射，我们可以使用运算符+如下：

A += ('I' -> 1)
A += ('J' -> 5)
A += ('K' -> 10)
A += ('L' -> 100)

映射的基本操作：

在映射上的所有操作可被表示在下面的三种方法：

方法	描述
keys	这个方法返回一个包含映射中的每个键的迭代。
values	这个方法返回一个包含映射中的每个值的迭代。
isEmpty	如果映射为空此方法返回true，否则为false。

以下是上述方法中的例子显示的用法：

object Test {
   def main(args: Array[String]) {
      val colors = Map("red" -> "#FF0000",
                       "azure" -> "#F0FFFF",
                       "peru" -> "#CD853F")

      val nums: Map[Int, Int] = Map()

      println( "Keys in colors : " + colors.keys )
      println( "Values in colors : " + colors.values )
      println( "Check if colors is empty : " + colors.isEmpty )
      println( "Check if nums is empty : " + nums.isEmpty )
   }
}

当上述代码被编译和执行时，它产生了以下结果：

C:/>scalac Test.scala
C:/>scala Test
Keys in colors : Set(red, azure, peru)
Values in colors : MapLike(#FF0000, #F0FFFF, #CD853F)
Check if colors is empty : false
Check if nums is empty : true

C:/>

串联映射

可以使用++运算符或映射。++()方法来连接两个或更多的映射，但同时增加了映射，将删除重复的键。下面是一个例子来连接两个映射：

object Test {
   def main(args: Array[String]) {
      val colors1 = Map("red" -> "#FF0000",
                        "azure" -> "#F0FFFF",
                        "peru" -> "#CD853F")
      val colors2 = Map("blue" -> "#0033FF",
                        "yellow" -> "#FFFF00",
                        "red" -> "#FF0000")

      // use two or more Maps with ++ as operator
      var colors = colors1 ++ colors2
      println( "colors1 ++ colors2 : " + colors )

      // use two maps with ++ as method
      colors = colors1.++(colors2)
      println( "colors1.++(colors2)) : " + colors )

   }
}

当上述代码被编译和执行时，它产生了以下结果：

C:/>scalac Test.scala
C:/>scala Test
colors1 ++ colors2 : Map(blue -> #0033FF, azure -> #F0FFFF, 
                     peru -> #CD853F, yellow -> #FFFF00, red -> #FF0000)
colors1.++(colors2)) : Map(blue -> #0033FF, azure -> #F0FFFF, 
                     peru -> #CD853F, yellow -> #FFFF00, red -> #FF0000)

C:/>

打印映射的键和值：

可以通过使用foreach循环重复Map的键和值。以下为例子来说明的用法：

object Test {
   def main(args: Array[String]) {
      val colors = Map("red" -> "#FF0000",
                       "azure" -> "#F0FFFF",
                       "peru" -> "#CD853F")

      colors.keys.foreach{ i =>  
                           print( "Key = " + i )
                           println(" Value = " + colors(i) )}
   }
}

在这里，我们使用迭代器相关的foreach遍历键方法。当上述代码被编译和执行时，它产生了以下结果：

C:/>scalac Test.scala
C:/>scala Test
Key = red Value = #FF0000
Key = azure Value = #F0FFFF
Key = peru Value = #CD853F

C:/>

检查映射中的键：

可以使用 Map.contains 方法来测试，如果给定的键存在于映射或没有。以下为例子来说明的用法：

bject Test {
   def main(args: Array[String]) {
      val colors = Map("red" -> "#FF0000",
                       "azure" -> "#F0FFFF",
                       "peru" -> "#CD853F")

      if( colors.contains( "red" )){
           println("Red key exists with value :"  + colors("red"))
      }else{
           println("Red key does not exist")
      }
      if( colors.contains( "maroon" )){
           println("Maroon key exists with value :"  + colors("maroon"))
      }else{
           println("Maroon key does not exist")
      }
   }
}

当上述代码被编译和执行时，它产生了以下结果：

C:/>scalac Test.scala
C:/>scala Test
Red key exists with value :#FF0000
Maroon key does not exist

C:/>

Scala映射的方法：

以下是可以使用映射的重要方法。有关可用方法的完整列表，请Scala的官方文件。

SN	方法及描述
1	def ++(xs: Map[(A, B)]): Map[A, B] 返回包含此映射的映射和那些xs提供了一个新的映射。
2	*def -(elem1: A, elem2: A, elems: A): Map[A, B] 返回包含除具有一个键等于映射elem1，elem2时或任何元素此映射的所有映射的新映射。**
3	def --(xs: GTO[A]): Map[A, B] 返回此映射，除映射一键等于从遍历对象xs的一个键所有键/值映射的新映射。
4	def get(key: A): Option[B] 可选择返回一个包含键关联的值。
5	def iterator: Iterator[(A, B)] 创建一个新的迭代器的所有键/值对在此映射
6	def addString(b: StringBuilder): StringBuilder 追加可收缩集合到一个字符串生成器的所有元素。
7	def addString(b: StringBuilder, sep: String): StringBuilder 追加可收缩集合到使用分隔字符串一个字符串生成器的所有元素。
8	def apply(key: A): B 返回给定键或者映射的默认方法的结果相关联的，如果不存在值。
9	def clear(): Unit 从映射中删除所有绑定。在此之后操作已完成时，映射将是空的。
10	def clone(): Map[A, B] 创建接收器对象的副本。
11	def contains(key: A): Boolean 如果有一个绑定在该映射的键返回true，否则为false。
12	def copyToArray(xs: Array[(A, B)]): Unit 复制这个可收缩集合值的数组。填充给定的数组xs与此可收缩集合值。
13	def count(p: ((A, B)) => Boolean): Int 计算满足谓词在可收缩集合元素的数量。
14	def default(key: A): B 定义默认值计算为映射，当找不到一个键返回。
15	def drop(n: Int): Map[A, B] 返回除了第n个的所有元素。
16	def dropRight(n: Int): Map[A, B] 返回除了最后n个的所有元素
17	def dropWhile(p: ((A, B)) => Boolean): Map[A, B] 丢弃满足谓词的元素最长前缀。
18	def empty: Map[A, B] 返回相同类型的，因为这映射的空映射。
19	def equals(that: Any): Boolean 返回true，如果两个映射包含完全相同的键/值，否则为false。
20	def exists(p: ((A, B)) => Boolean): Boolean 返回true如果给定的断言p成立了一些这方面可收缩集合的元素，否则为false。
21	def filter(p: ((A, B))=> Boolean): Map[A, B] 返回此可收缩集合满足谓词的所有元素。
22	def filterKeys(p: (A) => Boolean): Map[A, B] 返回一个不可变的映射只包含那些键值对这个映射，重点满足谓词p
23	def find(p: ((A, B)) => Boolean): Option[(A, B)] 查找可收缩集合满足谓词，任何的第一要素
24	def foreach(f: ((A, B)) => Unit): Unit 应用一个函数f这种可收缩集合中的所有元素
25	def init: Map[A, B] 返回除了最后的所有元素
26	def isEmpty: Boolean 测试映射是否为空
27	def keys: Iterable[A] 返回迭代所有键
28	def last: (A, B) 返回最后一个元素
29	def max: (A, B) 查找最大的元素
30	def min: (A, B) 查找最小元素
31	def mkString: String 显示此可收缩集合字符串中的所有元素
32	def product: (A, B) *返回此可收缩集合相对于所述运算符在num所有元素的乘积**
33	def remove(key: A): Option[B] 移除此映射一个键，返回先前与该键作为一个选项相关联的值
34	def retain(p: (A, B) => Boolean): Map.this.type 只保留那些映射其中谓词p返回true
35	def size: Int 返回在此映射的元素的数量。
36	def sum: (A, B) 返回此可收缩集合中的所有元素的总和使用+运算符在num
37	def tail: Map[A, B] 返回除了第一元素外的所有元素
38	def take(n: Int): Map[A, B] 返回前n个元素
39	def takeRight(n: Int): Map[A, B] 返回最后n个元素
40	def takeWhile(p: ((A, B)) => Boolean): Map[A, B] 满足谓词的元素最长前缀
41	def toArray: Array[(A, B)] 这个可收缩集合转换成数组
42	def toBuffer[B >: A]: Buffer[B] 返回包含此映射中的所有元素的缓冲区
43	def toList: List[A] 返回包含此映射中的所有元素的列表
44	def toSeq: Seq[A] 返回包含此映射中的所有元素的序列
45	def toSet: Set[A] 返回一组包含此映射中的所有元素
46	def toString(): String 返回对象的字符串表示