元组
在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的子类)
