一 集合简介

• 三大类：序列Seq、集Set、映射Map

• 分为可变（scala.collection.immutable）和不可变（scala.collection.mutable）

  • 可变类似于StringBuilder
  • 不可变类似于String(任何修改都会返回一个新集合

  [ 特例：Array 可以修改 ] ，并无法删除集合中的元素)

二 不可变和可变集合API

不可变（Array、List、Set）

添加

//头插法
newC = c.+:(item)
//尾插法
newC = c.:+(item)
//集合拼接
newC = c ++ c
val li = c1 :: c2 :: Nil

特例 ：不可变Set中 添加是 newS = s.+(item) ==> newS = s + item 、 删除是 newS = s.-(item) ===> newS = s - item

可变（ArrayBuffer、ListBuffer、mutable.Set）

添加

//尾插法
c.+=(item)   ===>  c += item
//集合拼接
val li : List[ListBuffer[Int]] = c1 :: c2 :: Nil

删除

c.-=(item)  ====> c -= item

三 集合

1.1 Array（不可变）

val arr : Array[Int] = Array(1,2,3) 指定一个类型（除了超类） 每个元素占据的内存空间是一样的

//增
arr.:+(item) //返回一个新的集合
arr.+:(item)
//改
arr(index) = newItem
//查
for( item <- arr ){
   println(item)
}

1.2 ArrayBuffer（可变）

val arr : ArrayBuffer[ Int ] = ArrayBuffer( 1 , 2 ,3 )

//增
arr += item //尾插法
item +=: arr //头插法
arr.append(item)
arr.preappend(item)
arr.insert(index,item) 
arr.insertAll(index,arr2)
arr.prependAll(arr2)

//删除
arr.remove(index)
arr.remove(index,count) // 从 index 开始 删除 count数量的元素
arr -= item

相互转换

arr.toArray()
arr.toBuffer()

二维数组-五维数组

//二维数组
val array1: Array[Array[Int]] = Array.ofDim(2, 2)
array1(1)(1) = item
//三维数组
val array2: Array[Array[Array[Int]]] = Array.ofDim(2,2,2)
array2(1)(1)(1) = item

2.1 List（不可变）

val list : List [ Int ] = List( 1 , 2 , 3 )

插入元素

//增
list.+:(item)
list.:+(item)

//头插法
val list2=list.::(item)
/** 源码 **/
    //方法
def :: [B >: A](elem: B): List[B] =  new ::(elem, this) 
    //类
final case class :: [+A](override val head: A, private[scala] var next: List[A @uncheckedVariance]) extends List[A] {
  releaseFence() // java 中的本地方法
  override def headOption: Some[A] = Some(head)
  override def tail: List[A] = next
}

创建集合

//另类创建集合
val nilList: List[Int] = Nil.::(1).::(2)
println(nilList) // List(2, 1)
//源码
case object Nil extends List[Nothing] {                   //类
}

�

合并集合

//合并集合
val newList = list1 ::: list2
val newList1 = list1 ++ list2
//源码
def ::: [B >: A](prefix: List[B]): List[B] =
    if (isEmpty) prefix
    else if (prefix.isEmpty) this
    else {
      val result = new ::[B](prefix.head, this)
      var curr = result
      var that = prefix.tail
      while (!that.isEmpty) {
        val temp = new ::[B](that.head, this)
        curr.next = temp
        curr = temp
        that = that.tail
      }
      releaseFence()
      result
    }

访问元素

//查
list(index)

2.2 ListBuffer（可变）

val list : ListBuffer[ Int ] = ListBuffer( 1 , 2 , 3 )

插入元素

list.append(item*)
list += item
item :+= list  // 看到 ： 从右到左执行
list.prepend(item)
list.insert(index,item*)

合并集合

val newList = list1 ++ list2
list1 ++= list2

修改元素

list(index) = newItem
list.update(index,newItem)

删除元素

list.remove(index)
list -= item

3.1 Set（不可变）

val set：Set [ Int ] = Set ( 1 , 2 , 3 )

插入元素

val newSet = set + item

合并集合

val newSet = set1 ++ set2

删除元素

val newSet = set - item

3.2 mutable.Set（可变）

val s : Set [ Int ] = Set ( 1 , 2 , 3 )

插入元素

s.add(item)
s += item

删除元素

s.remove(item)
s -= item

合并集合

s3 = s1 ++ s2
s1 ++= s2

4.1 Map

val map : Map [ String , Int ] = Map ( “a” -> 1 , “b” -> 2 , “c” -> 3 )

删除元素

val newMap = map.reoved(key)

访问元素

map(key)

map.getOrElse(key,0)

val m = Map(("a",1),("b",2))
for(item <- m){
  println(item._1)
  println(item._2)
}
for(key <- m.keys){
  println(key)
  println(m(key))
}

4.2 mutable.Map

val map : mutable.Map [ String , Int ] = mutable.Map ( “a” -> 1 , “b” -> 2 )

插入元素

map.put(key,value) // put底层调用的是update，如果key存在相当于就是修改 不存在就是新增

删除元素

map.remove(key)
map -= key

修改元素

map.update(key,newValue)

访问元素

map.getOrElse(key)
map(key)
// keys
for(key <- map.keys){
  println(s" $key => ${map(key)}")
}
// values
for(item <- map.values){
  println(item)
}

合并集合

map1 ++= map2

5. Tuple(长度最多22)

val tuple: (Int,String,Booleam) = ( 1, “hello” , true )

访问元素

t._1  =====> t.productElement(0)

多维元组

val mulTuple = ((1,0.1),2,("a",false))

四 集合常用函数

1.基本操作和常用操作

获取长度

list.length()
set.size()

生成字符串

mkstring

2.衍生集合(返回一个新的集合)

2.1 获取集合的头

list.head()

2.2 获取集合的尾（除了首个元素）

list.tail()

2.3 集合最后一个元素

list.last()

2.4 集合初始元素 (除了最后一个元素)

list.init()

2.5 反转

list.reverse()

2.6 取前（后）n 个元素

//从左
list.take(n)
//从右
list.takeRight(n)

2.7 去掉前（后）n 个元素

list.drop(n)
list.dropRight(n)

2.8 并集

list.union(list2)

2.9 交集

list.intersect(list2)

2.10 差集

list.diff(list2) // list独有的，排除list和list2共有的元素

2.11 拉链

list.zip(list1) // 生成二元组
(item._1,item._2)

2.12 滑窗

list.siding(size)       //默认步长为1，每次滑动的范围
list.siding(size,step)