Scala多种集合的使用(2)之集合常用方法

一、常用的集合方法

1.可遍历集合的常用方法

下表列出了Traverable在所有集合常用的方法。接下来的符号：

• c代表一个集合

• f代表一个函数

• p代表一个谓词

• n代表一个数字

• op代表一个简单的操作(通常是一个简单的函数)

方法	描述
c collect f	给集合里所有元素应用一个偏函数来构建一个定义有这个函数的新集合
c count p	对集合里满足谓词条件的元素进行计数
c1 diff c2	返回c1里与c2不同的元素
c drop n	返回集合里除去前n个元素的元素
c dropWhile p	返回“满足谓词的最长前缀元素”的集合
c exists p	如果集合中的每个元素都让谓词为真，则返回true
c filter p	返回集合中让谓词为真的所有元素
c filterNot p	返回集合中的所有让谓词为false的元素
c find p	返回第一个匹配谓词为Some[A]的元素，否则返回None
c flatten	把一个集合的集合（listof lists）变为一个单一的集合（单一list）
c flatMap f	把一个函数应用给集合c的所有元素（就像map），然后把拍平结果集合的结果作为集合返回
c foldLeft(z)(op)	把操作依次应用到元素上，从左到右，由z开始
c foldRight(z)(op)	把操作依次应用到元素上，从右到左，由z开始
c forAll p	如果所有元素都满足谓词返回true，否则false
c foreach f	把函数应用给集合的所有元素
c groupBy f	根据函数把集合归类成一个Map
c hasDefiniteSize	测试集合是否是有限的（比如，对Stream或Iterator返回fase)
c head	返回集合的第一个元素。如果集合为空则抛出NoSuchElementException
c headOption	返回集合的第一个元素，如果元素存在返回Some[A]，否则None
c init	选择集合中除去最后一个元素的所有元素。集合为空则抛出UnsupportedOperationException
c1 intersect c2	在支持的集合上，返回两个集合的交集（共同有的元素）
c isEmpty	如果集合为空返回true，否则返回false
c last	返回集合的最后一个元素，为空则抛出NoSuchElementException
c lastOption	如果集合最后一个元素存在返回Some[A]，否则None
c map f	把应用到集合中所有元素里创建一个新集合
c max	返回集合中最大的元素
c min	返回集合中最小的元素
c nonEmpty	如果集合不为空返回true
c par	返回一个集合的并行实现，比如，Array返回ParArray
c partition p	根据谓词算法返回两个集合
c product	返回集合中所有元素的乘积
c reduceLeft op	和foldLeft一样，但从集合的第一个元素开始
c reduceRight op	和foldRight一样，但从集合的最后一个元素开始
c reverse	返回集合的倒序（Traversable上不可行，但大多数集合都可用，来自GenSeqLike）
c size	返回集合的大小
c slice(from, to)	返回from到to元素的间隔
c sortWith f	返回按函数比较的集合版本
c span p	返回由两个集合组成的一个集合，第一个来自c.takeWhile(p)，第二个来自c.dropWhile(p)
c splitAt n	通过n所在集合c的位置拆分一个集合
c sum	返回集合所有元素的和
c tail	返回集合中除第一个元素外的其他所有元素
c take n	返回集合中头n个元素
c takeWhile p	当谓词为true时返回集合里的元素，为false时停止
c1 union c2	返回两个集合的并集
c unzip	与zip相反，把每个元素分成两份从而将一个集合一分为二，好像把Tuple2位元素的集合拆分开来
c view	返回集合的一个非严格（惰性）视图
c1 zip c2	通过按对匹配来创建一个pair集合。比如c1中的0匹配c2中的0，c1中的1，匹配c2中的1，等等
c zipWithlndex	按照下标遍历集合

2.可变的集合方法

下表里的是可变集合常用的操作符：

操作符（方法）	描述
c+=x	把元素x添加到集合c
c+=(x,y,z)	把元素x,y,z添加到集合c
c1++=c2	把c2里面的元素添加到c1
c-=x	从集合c中删除元素x
c-=（x,y,z）	从集合c中删除元素x,y,z
c1--=c2	从c1中删除c2中的元素
c(n)=x	把值x赋值给元素c(n)
c clear	删除集合中的所有元素
c remove n	删除位置为n的元素
c.remove(n,len)	删除第n位开头并且持续len长度的元素

3.不可变的集合方法

注意不可变集合不可被修改，所以在第一行的每个表达式的结果必须赋给一个新变量。

操作符	描述
c1 ++ c2	把c2集合的元素附加到c1里创造一个新的集合

scala> val c1 = Vector(1,2,3,4,5)
c1: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 4, 5)

scala> val c2 = Vector(6,7,8)
c2: scala.collection.immutable.Vector[Int] = Vector(6, 7, 8)

scala> c1 ++ c2
res35: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 4, 5, 6, 7, 8)

操作符	描述
c :+ e	返回把元素e附加到集合c的新集合

scala> val v1 = Vector(1,2,3,4,5)
c1: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 4, 5)

scala> val e = 10
e: Int = 10

scala> v1 :+ e
res38: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 4, 5, 10)

操作符	描述
e +: c2	返回一个把元素e前插到集合c的新集合

scala> val v1 = Vector(1,2,3,4,5)
c1: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 4, 5)

scala> val e = 10
e: Int = 10

scala> e +: v1
res39: scala.collection.immutable.Vector[Int] = Vector(10, 1, 2, 3, 4, 5)

操作符	描述
e :: list	返回一个把e前插到名为list列表的集合(::只在List集合上用)

scala> val list = List(7,8,9)
list: List[Int] = List(7, 8, 9)

scala> val e = 10
e: Int = 10

scala> e :: list
res75: List[Int] = List(10, 7, 8, 9)

操作符	描述
c drop n	把c2集合的元素附加到c1里创造一个新的集合

scala> val v1 = Vector(1,2,3,4,5)
v1: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 4, 5)

scala> val n = 3
n: Int = 3

scala> v1 drop n
res1: scala.collection.immutable.Vector[Int] = Vector(4, 5)

操作符	描述
c1 take n	把集合的前两个元素列出来

scala> val c1 = Vector(1,2,3,4,5)
c1: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 4, 5)

scala> c1 take 2
res82: scala.collection.immutable.Vector[Int] = Vector(1, 2)

 4.可变和不可变的map的常用方法

• m代表一个不可变map

• mm代表一个可变的map

• k代表一个键

• v代表一个值

• p代表一个谓词

• c代表一个集合

如果是var修饰，引用可变，支持读写。
如果是val修饰，引用不可变，支持读写。

操作符	描述
m - k	返回删除key(以及相应的value的值)后的map

scala> val v1 = Vector(1,2,3,4,5)
v1: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 4, 5)

scala> val map = Map(1 -> "a",2 -> "b",3 -> "c")
map: scala.collection.immutable.Map[Int,String] = Map(1 -> a, 2 -> b, 3 -> c)

scala> map - 1
res5: scala.collection.immutable.Map[Int,String] = Map(2 -> b, 3 -> c)

操作符	描述
m - (k1,k2,k3)	返回删除k1,k2,k3后的map

scala> val map = Map(1 -> "a",2 -> "b",3 -> "c",4 -> "d",5 -> "e",6 -> "f")
map: scala.collection.immutable.Map[Int,String] = Map(5 -> e, 1 -> a, 6 -> f, 2-> b, 3 -> c, 4 -> d)

scala> map - (1,3,5)
res6: scala.collection.immutable.Map[Int,String] = Map(6 -> f, 2 -> b, 4 -> d)

操作符	描述
m -- c	返回删除key后的map，c是指集合

scala> val map = Map(1 -> "a",2 -> "b",3 -> "c",4 -> "d",5 -> "e",6 -> "f")
map: scala.collection.immutable.Map[Int,String] = Map(5 -> e, 1 -> a, 6 -> f, 2-> b, 3 -> c, 4 -> d)

scala> val c = Vector(1,3,5)
c: scala.collection.immutable.Vector[Int] = Vector(1, 3, 5)

scala> map -- c
res7: scala.collection.immutable.Map[Int,String] = Map(6 -> f, 2 -> b, 4 -> d)

操作符	描述
m -- List(k1,k2)	返回删除key后的map

1
scala> val map = Map(1 -> "a",2 -> "b",3 -> "c",4 -> "d",5 -> "e",6 -> "f")
map: scala.collection.immutable.Map[Int,String] = Map(5 -> e, 1 -> a, 6 -> f, 2-> b, 3 -> c, 4 -> d)

scala> val list = List(1,3,5)
list: List[Int] = List(1, 3, 5)

scala> map -- list
res8: scala.collection.immutable.Map[Int,String] = Map(6 -> f, 2 -> b, 4 -> d)
2
scala> val map = Map(1 -> "a",2 -> "b",3 -> "c",4 -> "d",5 -> "e",6 -> "f")
map: scala.collection.immutable.Map[Int,String] = Map(5 -> e, 1 -> a, 6 -> f, 2
-> b, 3 -> c, 4 -> d)

scala> map -- List(1,2,3)
res9: scala.collection.immutable.Map[Int,String] = Map(5 -> e, 6 -> f, 4 -> d)

操作符	描述
m(k)	返回k的value

scala> var map = Map(1 -> 1,2 -> 2,3 -> 3,4 -> 4)
map: scala.collection.immutable.Map[Int,Int] = Map(1 -> 1, 2 -> 2, 3 -> 3, 4 ->4)

scala> map(2)
res34: Int = 2

操作符	描述
m contains k	如果map包含k则返回true

scala> var map = Map(1 -> 1,2 -> 2,3 -> 3,4 -> 4)
map: scala.collection.immutable.Map[Int,Int] = Map(1 -> 1, 2 -> 2, 3 -> 3, 4 ->4)

scala> map contains 3
res36: Boolean = true

操作符	描述
m get k	如果k存在返回Some[A]作为key的值，否则None

scala> var map = Map(1 -> "a",2 -> "b",3 -> "c",4 -> "d")
map: scala.collection.immutable.Map[Int,String] = Map(1 -> a, 2 -> b, 3 -> c, 4-> d)

scala> map get 2
res44: Option[String] = Some(b)

scala> map get 5
res45: Option[String] = None

操作符	描述
m getOrElse(k,d)	如果k找到的话，返回k的值，否则返回默认值d

scala> var map = Map(1 -> "a",2 -> "b",3 -> "c",4 -> "d")
map: scala.collection.immutable.Map[Int,String] = Map(1 -> a, 2 -> b, 3 -> c, 4-> d)

scala> map getOrElse(2,"hello")
res46: String = b

scala> map getOrElse(5,"hello")
res47: String = hello

操作符	描述
m isDefinedAt k	如果map包含k则返回true

scala> var map = Map(1 -> "a",2 -> "b",3 -> "c",4 -> "d")
map: scala.collection.immutable.Map[Int,String] = Map(1 -> a, 2 -> b, 3 -> c, 4-> d)

scala> map isDefinedAt 2
res48: Boolean = true

scala> map isDefinedAt 5
res49: Boolean = false

操作符	描述
m keys	把map中的keys作为Iterable返回

scala> var map = Map(1 -> "a",2 -> "b",3 -> "c",4 -> "d")
map: scala.collection.immutable.Map[Int,String] = Map(1 -> a, 2 -> b, 3 -> c, 4-> d)

scala> map keys
warning: there was one feature warning; re-run with -feature for details
res50: Iterable[Int] = Set(1, 2, 3, 4)

操作符	描述
m keySet	把map中的keys作为Set返回

scala> var map = Map(1 -> "a",2 -> "b",3 -> "c",4 -> "d")
map: scala.collection.immutable.Map[Int,String] = Map(1 -> a, 2 -> b, 3 -> c, 4-> d)

scala> map keySet
warning: there was one feature warning; re-run with -feature for details
res54: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 4)

操作符	描述
m values	把map中的value作为Iterable返回

scala> var map = Map(1 -> "a",2 -> "b",3 -> "c",4 -> "d")
map: scala.collection.immutable.Map[Int,String] = Map(1 -> a, 2 -> b, 3 -> c, 4-> d)

scala> map values
warning: there was one feature warning; re-run with -feature for details
res56: Iterable[String] = MapLike(a, b, c, d)

二、在创建集合时声明一个类型

想要创建一个混合型的集合，scala不会自动分配想要的类型。

创建一个手动的集合如下：

scala> trait Animal
defined trait Animal

scala> trait FurryAnimal extends Animal
defined trait FurryAnimal

scala> case class Dog(name: String) extends Animal
defined class Dog

scala> case class Cat(name: String) extends Animal
defined class Cat

scala> val x = Array(Dog("Fido"),Cat("Felix"))
x: Array[Product with Serializable with Animal] = Array(Dog(Fido), Cat(Felix))

如上所示，scala给product指定了Serializable和Animal类型。如果想要一个Array[Animal],手动需要指定类型：

scala> val x = Array[Animal](Dog("Fido"),Cat("Felix"))
x: Array[Animal] = Array(Dog(Fido), Cat(Felix))

三、可变变量集合与不可变量集合

但把一个不可变的Vector赋给一个可变的var时，似乎可以给它添加元素。

scala> var sisters = Vector("Melinda")
sisters: scala.collection.immutable.Vector[String] = Vector(Melinda)

scala> sisters = sisters :+ "Melissa"
sisters: scala.collection.immutable.Vector[String] = Vector(Melinda, Melissa)

scala> sisters = sisters :+ "Marisa"
sisters: scala.collection.immutable.Vector[String] = Vector(Melinda, Melissa, Ma
risa)

scala> sisters.foreach(println)
Melinda
Melissa
Marisa

尽管你看起来改变了一个不可改变的集合，但实际上是每次用:+方法时sisters变量会指向一个新的集合。sisters变量是可变的，所以每次执行时相当于重新赋值一个新的集合。

四、总结

• 一个可变的变量var可以被赋予一个新的数据。
• 一个不可变的变量val就如java中的final变量，不可能被重新赋值。
• 在可变集合的元素中可以被改变（ArrayBuffer）。
• 在不可被改变的集合元素中不可被改变（Vector）。

所谓的人生开挂，不过是厚积薄发！ 欢迎评论和转载！