Scala集合(一）

            val coll = ... // 某种Iterable
val iter = col.iterator

while(iter.hasNext)

  iter.next()
        

            
                每个Scala集合特质或类，都有一个带有apply方法的伴生对象，这个apply方法可以用来构建该集合中的实例。

Iterable(
                0xFF, 0xFF00, 0xFF0000)

set(color.RED, color.GREEN, Color.BLUE)

Map(color.RED -> -0xFF0000, Color.GREEN -> 0xFF00, Color.BLUE -> 0xFF)

SortedSet("Hello" , "World")
        

            scala.collection.mutable.Map    //可变
scala.collection.immutable.Map //不可变 
scala.collection.Map //超类
Scala优先采用不可变集合， scala.collection 包中的伴生对象产出不可变的集合

scala.collection.Map("Hello" -> 42) //不可变映射
因为Scala包和Predef对象总是被引入，他们都指向不可变特质的类型别名List、Set和Map.

Preedef.Map和scala.collection.immutable.Map是一回事

import scala.collection.mutable

用Map得到不可变，用mutable.Map得到可变的。
        

            Vector是ArrayBuffer的不可变版本，一个带下标的序列，支持快捷的随机访问，以树形结构的形式实现。

Range表示一个整数序列，只存储起始值，结束值和增值， 用 to 和 until 方法来构造Range对象。
        

            
                列表要么是Nil(空表)，要么是一个head元素和一个tail，tail又是一个列表。

val digits = List(4,2)

digits.head //4
digits.tail// List(2)
digits.tail.head// 2
digits.tail.tail //Nil

:: 操作符从给定的头和尾创建一个新的列表。

9 :: List(4,2) // List(9,4,2)9 :: 4 :: 2 :: Nil  // :: 是右结合，列表从末端开始构建9 :: ( 4 :: (2 :: Nil ) )

迭代， 除了遍历外，可以用 递归 模式匹配

def sum(lst : List[Int]): Int = 

  if( lst == Nil) 0else lst.head + sum(lst.tail)

 

def sum(lst:List[Int]): Int = lst match{

  case Nil => 0case h :: t => h+sum(t) // h 是 lst.head， 而t是lst.tail, ::将列表“析构”成头部和尾部
}

直接使用List的方法

List(9,4,2).sum
        

            
                LinkedList, elem指向当前值，next指向下一个元素

DoubleLinkedList多带一个prev

val lst = scala.collection.mutable.LinkedList(1,-2,7,-9)

var cur = lst

while(cur != Nil){

  if(cur.elem<0) cur.elem = 0

  cur = cur.next

} // (1,0,7,0) ，将所有负值改为0var cur = lst 

while(cur != Nil && cur.next != Nil){

  cur.next = cur.next.next

  cur = cur.next

}// 去除每两个元素中的一个
注：当要把某个节点变为列表中的最后一个节点，不能将next 设为Nil 或 null, 而将它设为LinkedList.empty。
        

            
                不重复元素的集合，以哈希集实现，元素根据hashCode方法的值进行组织

Set(
                2,0,1) + 1// (2,0,1)

LinkedHashSet，链式哈希集 记住元素被插入的顺序

val weekdays = scala.collection.mutable.LinkedHashSet(1,2,3,4)


排序的集

scala.collection.immutable.SortedSet(1,2,3,4) // 用红黑树实现的
Scala 2.9没有可变的已排序集，用java.util.TreeSet


位集(bit set), 以一个字位序列的方式存放非负整数，如果集中有i，则第i个字位是1

高效的实现，只要最大元素不是特别大。

Scala提供 可变和不可变的两个 BitSet类


contains 检查是否包含， subsetOf 检查集的所有元素是否被另一个集包含

val digits = Set(1,7,2,9)

digits contains 0// false
Set(1,2) subsetOf digits // true
        

            union intersect diff 方法，也可写作| ,&, &~

union 还可以写成 ++, diff 写作 --

val primes = Set(2, 3, 5, 7)

digits union primes // Set(1,2,3,5,7,9)
digits & primes // Set (2,7)
digits -- primes // Set(1,9)
        

            一般而言，+用于将元素添加到无先后次序的集合，而+:和:+则是将元素添加到有先后次序的集合的开头或末尾。

Vector(1,2,3) :+ 5//Vector(1,2,3,5)1 +: Vector(1,2,3) //Vector(1,1,2,3) 
以冒号结尾的操作符，+:是右结合的，这些操作符都返回新的集合


可变集合有 +=操作符 用于修改左侧操作元

val numbers = ArrayBuffer(1,2,3)

numbers += 5// 将 5 添加到 numbers

不可变集合，可以在var上使用+=或:+=

var numbers = Set(1,2,3)

numbers += 5// numbers 设为不可变的集numbers + 5var numberVector = Vector(1,2,3)

numbersVector :+= 5// 向量没有+操作符，只有:+
 
移除元素

Set(1,2,3) -2// Set(1,3)


++来一次添加多个元素， -- 一次移除多个元素

col1 ++ col2