Scala学习笔记--集合类型Queue,Set

补充知识：http://www.importnew.com/4543.html

正文开始

scala.collection.immutable

scala.collection.mutable

队列Queue

    val emp = scala.collection.immutable.Queue[Int]();
    val has1 = emp.enqueue(1)
    val has123=has1.enqueue(List(2,3))
    println(has1)　　　　　　//Queue(1)
    println(has123)　　　　 //Queue(1,2,3)

    val emp2 = scala.collection.mutable.Queue[Int]();
    emp2.enqueue(1);
    emp2.enqueue(2);
    println(emp2.dequeue());　　　　//1

使用集Set

使用集注意需要添加包

import scala.collection.mutable.Set

import scala.collection.immutable.Set

默认为不可变集

 val test = "aa,bb,cc,dd..eee!ff";
    //val t =test.split(",")
    //println(t)
    //t.foreach(x=>print(x+" "))

    //把字符串分割成单词，用正则表达式[,!.]+可以完成功能：字符串可以在1到多个标点符号处分割开来
    val wordArray = test.split("[,!.]+") //+号表示可以有多个标点符号
    wordArray.foreach(x=>println(x))
    

集的常用操作

    val nums = Set(1,2,3)    //创建不可变集，(nums.toString,返回Set(1,2,3))
    nums+5        //添加元素，返回Set(1,2,3,5)
    nums-3        //删除元素，返回Set(1,2)
    nums++List(5,6)//添加多个元素
    nums--List(1,2)//删除多个元素
    nums.size//返回元素大小
    nums.contains(2)//返回元素是否包含2

    import scala.collection.mutable//引入可变集合类型
    val words  = mutable.Set.empty[String]//创建空可变集合，（words.toString,返回Set()）
    words+="the"//添加元素，words.toString,返回Set(the)
    words-="the"//删除元素，words.toString,返回Set()
    words++=List("do","well","in")//添加多个元素 返回words.toString,返回Set(do,well,in)
    words--=List("do","in")//删除多个元素
    words.clear()//删除所有元素

使用映射

  def countWords(text:String)={
    /**
     * 计算字符串的单词字数
     */
    val counts = mutable.Map.empty[String,Int];
    for(rawWord<-text.split("[ ,.!]+")){ //text.split返回一个字符串数组
      val word = rawWord.toLowerCase()//变为小写
      val oldCount =
        if (counts.contains(word)) counts(word)
        else 0
      counts+=(word->(oldCount+1))
    }
    counts;
  }

映射的常见操作

//常见的映射操作
val nums = Map("i"->1,"ii"->2); //创建不可变映射
val nums2 = nums +("vi"->6);    //添加条目，返回一个映射赋值给nums2
val nums3 = nums -"ii"//删除条目，返回一个映射赋值给nums3
val nums22= nums++List("iii"->3,"iv"->4)//添加多个条目
val nums33 = nums--List("i","ii")//删除多个条目
nums.size//映射包含条目数量

nums.contains("ii")//检查是否包含 返回true
nums("ii")//获取指定键的关键值 返回2
var it1 =nums.keys //返回键枚举器， （返回字符串i、ii的Iterator）
//iterator 迭代器模式：提供一种方法访问一个容器对象中的各个元素，而不暴露该对象的细节
var it2 = nums.values//返回值枚举器（返回整数1、2的Iterator）
nums.keySet//返回键集Set(i,ii)

import scala.collection.mutable
val words = mutable.Map.empty[String,Int]//创建空的可变映射
words+=("one"->1)//添加映射条目
words-="one"//删除条目
words++=List("one"->1,"two"->2)//添加多个条目
words--=List("one","two")//删除多个条目

默认的集和映射

/**
* scala.collection.immutable.Set()返回的类取决于你传递给它多少元素
* 默认的不可变映射实现
* scala.collection.immutable.EmptyMap
* scala.collection.immutable.Set1
* scala.collection.immutable.Set2
* scala.collection.immutable.Set3
* scala.collection.immutable.Set4
* scala.collection.immutable.HashSet
*/

有序的集和映射

有时,可能你需要集或映射的枚举器能够返回按特定顺序排列的元素，为此，Scala的集合库提供了
SortedSet和SortedMap特质，这两个特质分别由类TreeSet和TreeMap实现。
它们都使用了红黑树有序地保存元素或键。

  import scala.collection.immutable.TreeSet
  import scala.collection.immutable.TreeMap

  val ts = TreeSet(5,4,2,9,8,7,6,3,1)
  println(ts)
  val cs = TreeSet("f","u","n")
  println(cs)
  val tm = TreeMap(2->"two",1->"one",3->"three")
  println(tm)

结果：

TreeSet(1, 2, 3, 4, 5, 6, 7, 8, 9)
TreeSet(f, n, u)
Map(1 -> one, 2 -> two, 3 -> three)

同步的集和映射

可变映射

//如果需要线程安全的映射，可以把SynchronizedMap特质混入到你想要的特定类实现中。
  import scala.collection.mutable.{Map,SynchronizedMap,HashMap}
  object MapMaker{
     def makeMap:Map[String,String]={
       //构造新的可变HashMap，并且混入了SynchronizedMap特质
       new HashMap[String,String] with SynchronizedMap[String,String]{
         //重载名为default的方法，方法将在查询不存在的键值时，返回英文字符串
         //原来的default为抛出NoSuchElementException
         override def default(key:String)={"Why do you want to know"}//返回一个value
       }
     }
  }

//使用可变映射
val captial = MapMaker.makeMap
    captial++=List("China"->"Beijing","US"->"Washington","Paris"->"France")
    println(captial("China"))　　　　//输出Beijing
    println(captial("New Zealand")) //输出Why do you want to know

可变集

val synchroSet = new mutable.HashSet[Int] with mutable.SynchronizedSet[Int]