第1节 Scala基础语法：13、list集合的定义和操作；16、set集合；17、map集合

list.+:5 , list.::5： 在list集合头部添加单个元素5 ；

li1.:+(5)：在list集合尾部添加单个元素5；

li1++li2，li1:::li2：在li1集合尾部添加il2集合；

li1.:::(li2)：在li1集合头部添加li2集合。

li1--=li2：可变list集合li1中，减去li2集合中的元素，li1中的元素为减少后的元素。

List：可重复、有序（注意，这里的有序不是指它里面的元素从小到大排序，而是指它里面的元素的位置不会改变，每个元素都有自己的位置序号）、可保证插入顺序；

Set：不可重复、有序、但不保证插入顺序（即插入元素时是乱序的，随机插到一个位置）；

Map：不可重复、有序、但不保证插入顺序。

========================================

5.4.   集合

Scala的集合有三大类：序列Seq、Set、映射Map，所有的集合都扩展自Iterable特质，在Scala中集合有可变（mutable）和不可变（immutable）两种类型，immutable类型的集合初始化后就不能改变了（注意与val修饰的变量进行区别）。

5.4.1.    List

(1)不可变的序列 import scala.collection.immutable._

在Scala中列表要么为空（Nil表示空列表）      要么是一个head元素加上一个tail列表。

9 :: List(5, 2)  :: 操作符是将给定的头和尾创建一个新的列表

注意：:: 操作符是右结合的，如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))

list常用的操作符：

+: (elem: A): List[A] 在列表的头部添加一个元素

:: (x: A): List[A]     在列表的头部添加一个元素

:+ (elem: A): List[A] 在列表的尾部添加一个元素

++[B](that: GenTraversableOnce[B]): List[B] 从列表的尾部添加         另外一个列表

::: (prefix: List[A]): List[A] 在列表的头部添加另外一个列表

val left = List(1,2,3)

val right = List(4,5,6)

//以下操作等价

left ++ right      // List(1,2,3,4,5,6)

right.:::(left)     // List(1,2,3,4,5,6)

//以下操作等价

0 +: left    //List(0,1,2,3)

left.+:(0)   //List(0,1,2,3)

//以下操作等价

left :+ 4    //List(1,2,3,4)

left.:+(4)   //List(1,2,3,4)

//以下操作等价

0 :: left      //List(0,1,2,3)

left.::(0)     //List(0,1,2,3)

例子:

package cn.itcast.collect
/**

 * 不可变List集合操作
 */
object ImmutListDemo {
  def main(args: Array[String]) {
    //创建一个不可变的集合
    val lst1 = List(1,2,3)
    //补充：另一种定义list方法
    val other_lst=2::Nil
    //获取集合的第一个元素
    val first=lst1.head
    //获取集合中除第一个元素外的其他元素集合,
    val tail=lst1.tail
    //补充：其中如果 List 中只有一个元素，那么它的 head 就是这个元素，它的 tail 就是 Nil；
    println(other_lst.head+"----"+other_lst.tail)
    //将0插入到lst1的前面生成一个新的List
    val lst2 = 0 :: lst1
    val lst3 = lst1.::(0)
    val lst4 = 0 +: lst1
    val lst5 = lst1.+:(0)
    

//将一个元素添加到lst1的后面产生一个新的集合
    val lst6 = lst1 :+ 3
    val lst0 = List(4,5,6)         
    //将2个list合并成一个新的List
    val lst7 = lst1 ++ lst0
    //将lst0插入到lst1前面生成一个新的集合
    val lst8 = lst1 ++: lst0
    //将lst0插入到lst1前面生成一个新的集合
    val lst9 = lst1.:::(lst0)

    println(other_lst)
    println(lst1)
    println(first)
    println(tail)
    println(lst2)
    println(lst3)
    println(lst4)
    println(lst5)
    println(lst6)
    println(lst7)
    println(lst8)
    println(lst9)
  }
}

(2)可变的序列 import scala.collection.mutable._

ackage cn.itcast.collect
import scala.collection.mutable.ListBuffer

object MutListDemo extends App{
  //构建一个可变列表，初始有3个元素1,2,3
  val lst0 = ListBuffer[Int](1,2,3)
  //创建一个空的可变列表
  val lst1 = new ListBuffer[Int]
  //向lst1中追加元素，注意：没有生成新的集合
  lst1 += 4
  lst1.append(5)

  //将lst1中的元素添加到lst0中， 注意：没有生成新的集合
  lst0 ++= lst1

  //将lst0和lst1合并成一个新的ListBuffer 注意：生成了一个集合
  val lst2= lst0 ++ lst1

  //将元素追加到lst0的后面生成一个新的集合
  val lst3 = lst0 :+ 5

  //删除元素,注意：没有生成新的集合
  val lst4 = ListBuffer[Int](1,2,3,4,5)
  lst4 -= 5

  //删除一个集合列表,生成了一个新的集合
  val lst5=lst4--List(1,2)

  //把可变list 转换成不可变的list 直接加上toList
  val lst6=lst5.toList

  //把可变list 转变数组用toArray
  val lst7=lst5.toArray

  println(lst0)
  println(lst1)
  println(lst2)
  println(lst3)
  println(lst4)
  println(lst5)
  println(lst6)
  println(lst7)

}

5.4.2.    Set

(1)不可变的Set    import scala.collection.immutable._

Set代表一个没有重复元素的集合；将重复元素加入Set是没有用的，而且 Set 是不保证插入顺序的，即 Set 中的元素是乱序的。

定义：val set=Set(元素,元素,.....)

//定义一个不可变的Set集合

scala> val set =Set(1,2,3,4,5,6,7)

set: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 4)

//元素个数

scala> set.size

res0: Int = 7

//取集合最小值

scala> set.min

res1: Int = 1

//取集合最大值

scala> set.max

res2: Int = 7

//将元素和set1合并生成一个新的set，原有set不变

scala> set + 8

res3: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 8, 4)

scala> val set1=Set(7,8,9)

set1: scala.collection.immutable.Set[Int] = Set(7, 8, 9)

//两个集合的交集

scala> set & set1

res4: scala.collection.immutable.Set[Int] = Set(7)

//两个集合的并集

scala> set ++ set1

res5: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 9, 2, 7, 3, 8, 4)

//在第一个set基础上去掉第二个set中存在的元素

scala> set -- set1

res6: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)

//返回第一个不同于第二个set的元素集合

scala> set &~ set1

res7: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)

//计算符合条件的元素个数

scala> set.count(_ >5)

res8: Int = 2

/返回第一个不同于第二个的元素集合

scala> set.diff(set1)

res9: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)

/返回第一个不同于第二个的元素集合

scala> set1.diff(set)

res10: scala.collection.immutable.Set[Int] = Set(8, 9)

//取子set(2,5为元素位置, 从0开始，包含头不包含尾)

scala> set.slice(2,5)

res11: scala.collection.immutable.Set[Int] = Set(6, 2, 7)

//迭代所有的子set，取指定的个数组合

scala> set1.subsets(2).foreach(x=>println(x))

Set(7, 8)

Set(7, 9)

Set(8, 9)

(2)可变的Set  import scala.collection.mutable._

//导入包

scala> import scala.collection.mutable.HashSet

import scala.collection.mutable.HashSet

//定义一个可变的Set

scala> val set1=new HashSet[Int]()

set1: scala.collection.mutable.HashSet[Int] = Set()

//添加元素

scala> set1 += 1

res1: set1.type = Set(1)

//添加元素  add等价于+=

scala> set1.add(2)

res2: Boolean = true

scala> set1

res3: scala.collection.mutable.HashSet[Int] = Set(1, 2)

//向集合中添加元素集合

scala> set1 ++=Set(1,4,5)

res5: set1.type = Set(1, 5, 2, 4)

//删除一个元素

scala> set1 -=5

res6: set1.type = Set(1, 2, 4)

//删除一个元素

scala> set1.remove(1)

res7: Boolean = true

scala> set1

res8: scala.collection.mutable.HashSet[Int] = Set(2, 4)

5.4.3.    Map

(1)不可变的Map   import scala.collection.immutable._

定义Map集合

1.val map=Map(键 -> 值 , 键 -> 值...)

2.利用元组构建  val map=Map((键，值), (键，值) , (键，值)....)

展现形式：

val  map = Map(“zhangsan”->30,”lisi”->40)

val  map = Map((“zhangsan”,30),(“lisi”,40))

3.操作map集合

获取值： 值=map(键)

原则：通过先获取键，在获取键对应值。

4.遍历map集合

scala> val imap=Map("zhangsan" -> 20,"lisi" ->30)

imap: scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 20, lisi -> 30)

//方法一：显示所有的key

scala> imap.keys

res0: Iterable[String] = Set(zhangsan, lisi)

//方法二：显示所有的key

scala> imap.keySet

res1: scala.collection.immutable.Set[String] = Set(zhangsan, lisi)

//通过key获取value

scala> imap("lisi")

res2: Int = 30

//通过key获取value 有key对应的值则返回，没有就返回默认值0，

scala> imap.getOrElse("zhangsan",0)

res4: Int = 20

//没有对应的key，返回默认0

scala> imap.getOrElse("zhangsan1",0)

res5: Int = 0

//由于是不可变map,故不能向其添加、删除、修改键值对

(2)可变的Map  import scala.collection.mutable._

//导包

import scala.collection.mutable

//声明一个可变集合

scala> val user =mutable.HashMap("zhangsan"->50,"lisi" -> 100)

user: scala.collection.mutable.HashMap[String,Int] = Map(lisi -> 100, zhangsan -> 50)

//添加键值对

scala> user +=("wangwu" -> 30)

res0: user.type = Map(lisi -> 100, zhangsan -> 50, wangwu -> 30)

//添加多个键值对

scala> user += ("zhangsan0" -> 30,"lisi0" -> 20)

res1: user.type = Map(zhangsan0 -> 30, lisi -> 100, zhangsan -> 50, lisi0 -> 20,wangwu -> 30)

//方法一：显示所有的key

scala> user.keys

res2: Iterable[String] = Set(zhangsan0, lisi, zhangsan, lisi0, wangwu)

//方法二：显示所有的key

scala> user.keySet

res3: scala.collection.Set[String] = Set(zhangsan0, lisi, zhangsan, lisi0, wangwu)

//通过key获取value

scala> user("zhangsan")

res4: Int = 50

//通过key获取value 有key对应的值则返回，没有就返回默认值0，

scala> user.getOrElse("zhangsan",0)

res5: Int = 50

//没有对应的key，返回默认0

scala> user.getOrElse("zhangsan1",0)

res6: Int = 0

//更新键值对

scala> user("zhangsan") = 55

scala> user("zhangsan")

res8: Int = 55

//更新多个键值对

scala> user += ("zhangsan" -> 60, "lisi" -> 50)

res9: user.type = Map(zhangsan0 -> 30, lisi -> 50, zhangsan -> 60, lisi0 -> 20,wangwu -> 30)

//删除key

scala> user -=("zhangsan")

res14: user.type = Map(zhangsan0 -> 30, lisi -> 50, lisi0 -> 20, wangwu -> 30)

//删除key

scala>user.remove("zhangsan0")

//遍历map 方法一：通过key值

scala> for(x<- user.keys) println(x+" -> "+user(x))

lisi -> 50

lisi0 -> 20

wangwu -> 30

//遍历map 方法二：模式匹配

scala> for((x,y) <- user) println(x+" -> "+y)

lisi -> 50

lisi0 -> 20

wangwu -> 30

//遍历map 方法三：通过foreach

scala>  user.foreach{case (x,y) => println(x+" -> "+y)}

lisi -> 50

lisi0 -> 20

wangwu -> 30