scala 集合详细 - 码农教程

元组

在scala 中元组可以容纳不同类型元素的类,元组是不可变的,用于函数返回多个值.

创建元组和访问元素

val ingredient = ("Suger", 25)

ingredient._1

解构元组数据

val (name, quantity) = ingredient
name: String = Suger
quantity: Int = 25

val planetDistanceFromSun = List(("Mercury", 57.9), ("Venus", 108.2), ("Earth", 149.6 ), ("Mars", 227.9), ("Jupiter", 778.3))

planetDistanceFromSun.foreach{ tuple => {
  
  tuple match {
    
      case ("Mercury", distance) => println(s"Mercury is $distance millions km far from Sun")
      
      case p if(p._1 == "Venus") => println(s"Venus is ${p._2} millions km far from Sun")
      
      case p if(p._1 == "Earth") => println(s"Blue planet is ${p._2} millions km far from Sun")
      
      case _ => println("Too far....")
      
    }
    
  }
  
}

对元组进行遍历

tuple 不可以通过foreach取出其中的元素,因为它类似于struct,必须清楚它内部有多少元素.

同时不同长度的tuple,类似Tuple2,Tuple3 并没有继承一个公共的抽象父类.

但是Tuple继承了Product特质,在Product提供了一个productIterator的迭代器.

遍历未知长度的tuple可以通过这个迭代器进行遍历.

def foo(tuple: Product) = tuple.productIterator.foreach(print)
foo: (tuple: Product)Unit

scala> foo((1,2,3))
123

使用 -> 也可以定义二元组 "a"->"b"

String 字符串

scala中的字符串,像数组,字符串不是直接的序列,但是他们可以转换为序列.

 str.reverse
res9: String = olleh

scala> str.map(_.toUpper)
res10: String = HELLO

scala> str drop 3
res11: String = lo

scala> str slice (1 , 4)
res12: String = ell

scala> val s : Seq[Char] = str

一个string转换为一个Seq。高优先级转换映射一个string到StringOps 对象，从而在immutable 序列到strings上增加了所有的方法。这种隐式转换插入在reverse，map,drop和slice的方法调用中.

String 会被隐式转换为 StringOps

StringOps extends StringLike

集合

Set

集合是不包含重复元素的可迭代对象.

val fruit = Set("apple","orange","peach","banana")
fruit: scala.collection.immutable.Set[String] = Set(apple, orange, peach, banana)

// apply 方法是类似与 contains 方法,() 默认调用apply方法
fruit contains "orange"
fruit.contains("orange")
fruit("orange")

加法一个加是把其作为一个元素加进去 xs + x 包含 xs 中所有元素以及 x 的集合。

xs + (x, y, z) 包含 xs 中所有元素及附加元素的集合

两个加是把每一个元素进行拆分开加入 xs ++ ys 包含 xs 中所有元素及 ys 中所有元素的集合

fruit + "oppo"
res16: scala.collection.immutable.Set[String] = Set(peach, oppo, banana, orange, apple)

fruit ++ "oppo"
res17: scala.collection.immutable.Set[Any] = Set(peach, banana, orange, p, apple, o)

减法是类似的

交并差集

xs & ys 集合 xs 和 ys 的交集。 xs intersect ys 等同于 xs & ys。 xs | ys 集合 xs 和 ys 的并集。 xs union ys 等同于 xs | ys。 xs &~ ys 集合 xs 和 ys 的差集。 xs diff ys 等同于 xs &~ ys。

mutable.Set

可变集合与不可变的区别是可以将集合元素修改,使用的是 += ++= -= --= 等操作

xs add x    把元素 x 添加到集合 xs 中，如集合 xs 之前没有包含 x，该操作返回 true，否则返回 false。

xs remove x 从集合 xs 中删除元素 x 。如之前 xs 中包含了 x 元素，返回 true，否则返回 false。
xs retain p 只保留集合 xs 中满足条件 p 的元素。
xs.clear()  删除集合 xs 中的所有元素。

xs(x) = b   （ 同 xs.update(x, b) ）参数 b 为布尔类型，如果值为 true 就把元素x加入集合 xs，否则从集合 xs 中删除 x。

创建可变集合,只需要val s = collection.mutable.Set(1,2,3)

sortedSet

SortedSet 的默认表示是有序二叉树，即左子树上的元素小于所有右子树上的元素。

Scala的类 immutable.TreeSet 使用红黑树实现，它在维护元素顺序的同时，也会保证二叉树的平衡，即叶节点的深度差最多为1

先创建排序规则

val myOrdering = Ordering.fromLessThan[String](_ > _)
myOrdering: scala.math.Ordering[String] = scala.math.Ordering$$anon$6@5e91142c

创建排序集

collection.immutable.TreeSet.empty(myOrdering)
res29: scala.collection.immutable.TreeSet[String] = TreeSet()
res29 + ("one", "two", "three", "four")
res30: scala.collection.immutable.TreeSet[String] = TreeSet(two, three, one, four)

Bitset

位集合是由单字或多字的紧凑位实现的非负整数的集合。其内部使用 Long 型数组来表示。第一个 Long 元素表示的范围为0到63，第二个范围为64到127，以此类推（值为0到127的非可变位集合通过直接将值存储到第一个或第两个 Long 字段的方式，优化掉了数组处理的消耗）。对于每个 Long，如果有相应的值包含于集合中则它对应的位设置为1，否则该位为0。这里遵循的规律是，位集合的大小取决于存储在该集合的最大整数的值的大小。假如N是为集合所要表示的最大整数，则集合的大小就是 N/64 个长整形字，或者 N/8 个字节，再加上少量额外的状态信息字节。

因此当位集合包含的元素值都比较小时，它比其他的集合类型更紧凑。位集合的另一个优点是它的 contains 方法（成员测试）、+= 运算（添加元素）、-= 运算（删除元素）都非常的高效。

List

通过List伴生对象的apply方法来创建实例: List("A","B") 过程发生了什么

首先，List伴生对象的apply方法接收的是一个可变参数列表，即数组：

override def apply[A](xs: A*): List[A] = xs.toList

而我们传入的Array("A","B")数组会被隐式转换为 WrappedArray 的子类型,随后对这个WrappedArray 的子类型ofRef[String]类型，调用 toList 方法

不过在进行toList时用到了隐式参数CanBuildFrom，我们先看一下List伴生对象中定义的，用于生成CanBuildFrom信息的隐式

也就是说这个隐式参数构造出来的新容器类型是 ListBuffer 的子类型。

最终，它返回ListBuffer类里的start成员，这个start是一个 :: 类型(List的子类)