Scala--集合

一、主要的集合特质

Seq有先后顺序的序列，如数组列表。IndexedSeq通过下标快速的访问元素。不可变：Vector, Range, List 可变：ArrayBuffer, LinkedList

Set一组没有先后顺序的集合，SortedSet排过序的顺序被访问。

Map一组(键，值)对，SortedMap按照键的排序访问值。

+ 用于将元素添加到无次序的集合中，:+ 和 +: 用于将元素添加到有次序的集合中

++无序集合添加无序集合                     ++: 有序集合添加有序集合

　　　　　　　　　　　　　　　　　::: 列表添加列表

　　　　　　　　　　　　　　　　　::  列表添加元素

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

  Iterator(0xFF,0xFFFF,0xFF00).foreach(println(_))
  SortedSet("world","hello").foreach(println(_))
  Map(1 -> "First",2 -> "Second",3 -> "Third")

二、可变和不可变集合

  import scala.collection.immutable.Map  //不可变 map
  import scala.collection.mutable.Map //可变 map

三、序列

不可变序列：Vector,Range

可变序列：ArrayBuffer

ArrayBuffer:

四、列表

 /*
    * 四、列表
    *   不可变列表 List
    *   可变列表 LinkedList
    *
    *   Nil空表
    *   digits.head, digits.tail
    *
    *   不可变列表 元素遍历 list.tail 使用递归调用
    *   可变列表  元素遍历 list.elem  循环lsit.next
    *   ::添加元素 右结合 从末端开始构建，在表头进行插入
    *   :::批量添加元素，两个列表相加
    * */

    val digits = List(4,2)
    println(digits.head)
    println(digits.tail)

    val d1 = 3 :: digits //::右结合， 从末端开始构建，就是在表头进行插入
    println(d1)

    val d2 = d1:+8
    println(d2)

    //递归调用，遍历List
    def sum(lst:List[Int]): Int ={
      if (lst == Nil) 0 else lst.head + sum(lst.tail)
    }
    println(sum(d1))

    //模式匹配，递归调用 遍历List
    def sum1(lst:List[Int]):Int = lst match{
      case Nil =>0
      case h::t => h + sum1(t) // ::表示析构 将列表析构成表头和表尾
    }
    println(sum1(d1))

    //可变列表，通过 .elem获取元素值并进行修改，通过.next进行后移
    val lst = scala.collection.mutable.LinkedList(1,2,-1,-4,6)
    var cur = lst
    while(cur != Nil){
      if(cur.elem < 0) cur.elem = 0
      cur = cur.next
    }

五、可变列表

如上

六、集

 /*
    * 四、集
    *   Set 不重复元素的集合
    *   Set 集合分为可变的和不可变的集合。
    * */

    //集 添加元素 1 由于存在，结果不变
    val s = Set(1,0,2)+1
    println(s)

    //集合顺序
    val set = Set(1,2,3,4,5)+6
    for(i<- set){
      print(i+" ") //查询结果顺序 5 1 6 2 3 4  顺序不是插入顺序，顺序是根据值的hashCode进行组织的
    };println()

    //已经排序的集
    val set1 = scala.collection.mutable.SortedSet(1,2,3,4,5)
    for(i<-set1){
      print(i+" ")
    };println()

七、用于添加或去除元素的操作符

    /*
    * 添加删除元素的操作符
    *   + 无序集合添加元素
    *   :+ 有序集合添加元素
    *   - 移除元素
    *   ++ --批量增加删除
    *   ::,::: 列表 优先使用
    * */

    //向量 不可变 返回新的集合
    val v1 = Vector(1,2,3) :+ 5 // :+ 右加元素
    println(v1)
    var v2 = 0 +: v1   // +: 左加元素
    var v3 = v1 ++ v2  // ++ 两个集合相加，返回新的集合
    println(v2)
    println(v3)

    //ArrayBuffer 可变
    var num1 = ArrayBuffer(1,2,3,4) :+ 4 // :+ 右加元素 返回新的集合
    var num2 = ArrayBuffer(11,22,33)
    num1 += 2 // += 增加元素，修改集合
    num1 -= 2 // -= 删除元素，从头开始
    num1 ++= num2 // ++= 两个集合相加
    println(num1)
    println(num2)

    //Set   |并集 &交集 &~差集
    val s1 = scala.collection.immutable.Set(1,0,2,3)
    val s2 = scala.collection.mutable.Set(2,3,4,5)
    val s3 = s1 + 1  // 无序使用 +
    val s4 = s1 | s2 // 并集 等同于++
    val s5 = s1 & s2 // 交集
    val s6 = s1 &~ s2 // 差集 属于s1不属于s2 等同于--
    var s7= s2 &~ s1 // 差集 属于s2不属于s1 等同于--
    s2 -= 4           //-= 删除元素内容
    //s1 -= 1           //报错， 不可变集合
    println(s2)
    println(s3)
    println(s4)
    println(s5)
    println(s6)
    println(s7)

八、常用方法

九、将函数映射到集合

    /*
    * 将函数映射到集合
    *   map, flatMap, foreach...
    *
    * */

    //map
    val name = List("Jim","Rob","Tom")
    println(name.map(_.toUpperCase))

    //flatMap
    def as(s:String) = List(s.toUpperCase,s.toLowerCase())
    println(name.flatMap(as))

    //foreach
    name.foreach(println)

    //collect
    val col= "+4-3".collect{case '+'=> 1;case '-'=> -1; case _ => 0}
    println(col)

List(JIM, ROB, TOM)
List(JIM, jim, ROB, rob, TOM, tom)
Jim
Rob
Tom
Vector(1, 0, -1, 0)

十、化简、折叠和扫描

    /*
    * 十、化简、折叠和扫描
    *   reduce
    *   fold
    *   scan
    * */

    //reduceLeft 从左侧两元素互操作 1-7-2-9  -17
    val li = List(1,7,2,9)
    var re =li.reduceLeft(_ - _)
    println(re)
    //reduceRight 从右侧两元素互操作 (1-(7-(2-9))) -13
    re = li.reduceRight(_-_)
    println(re)

    //foldLeft 初始值为0，从左侧开始 0-1-7-2-9  -19
    val f = List(1,7,2,9)
    var re1 = f.foldLeft(0)(_-_)
    println(re1)
    //foldRight 初始值为0，从右侧开始  (1-(7-(2-(9-0)))) -13
    re1 = f.foldRight(0)(_-_)
    println(re1)

    // /: 表示 foldLeft   :\ 表示 foldRight   树：  树的左侧/:   树的右侧:\
    val f1 = (0 /: List(1,7,2,9))(_-_)
    val f2 = (List(1,7,2,9) :\ 0)(_-_)
    println(f1)
    println(f2)

    //计算字符串中字母出现的频率
    //方法1：通过可变map循环字符串，累加计数进行计算
    val freq = scala.collection.mutable.Map[Char,Int]()
    for(c<- "Mississippi"){
      freq(c) = freq.getOrElse(c,0) + 1
    };println(freq)

    //方法2：通过foldLeft对数据进行计算，
    val m1 = (Map[Char,Int]() /: "Mississippi"){
      (m, c) => m + (c -> (m.getOrElse(c,0)+1)) //m代表map, c代表字符 每次一个字符进来持续计算，然后结果加入到map中，然后返回map
    };println(m1)

    //scanLeft scanRight 得到计算中间结果
    val ran = (1 to 10).scanLeft(0)(_+_)
    println(ran) //Vector(0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55)

-17
-13
-19
-13
-19
-13
Map(M -> 1, s -> 4, p -> 2, i -> 4)
Map(M -> 1, i -> 4, s -> 4, p -> 2)
Vector(0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55)

十一、拉链操作

    /*
    * 十一、拉链
    *   zip
    *   zipAll
    *   zipWithIndex
    * */

    //zip
    val prices = List(5.0, 20.0, 9.95)
    val quantities = List(10, 2)

    println(prices.zip(quantities))
    println(prices.zip(quantities).map{p=>(p._1 * p._2)})
    //zipWithIndex
    println("Scala".zipWithIndex)

    //zipAll
    println(prices.zipAll(quantities,0,1))  //全部zip,缺少元素使用默认值；that 少用0，this 少用1

    println("Scala".zipWithIndex.max)
    println("Scala".zipWithIndex.max._2)

List((5.0,10), (20.0,2))
List(50.0, 40.0)
Vector((S,0), (c,1), (a,2), (l,3), (a,4))
List((5.0,10), (20.0,2), (9.95,1))
(l,3)
3

十二、迭代器

十三、流

十四、懒视图

十五、与Java集合的互操作

十六、线程安全的集合

十七、并行集合

参考《快学Scala》