Scale编程基础（三）-- 集合相关

package cn.itcast.scala

import scala.collection.mutable.ArrayBuffer

object ArrayDemo {
  def main(args: Array[String]) {

    //初始化一个长度为8的定长数组，其所有元素均为0
    val arr1 = new Array[Int](8)
    //直接打印定长数组，内容为数组的hashcode值
    println(arr1)
    //将数组转换成数组缓冲，就可以看到原数组中的内容了
    //toBuffer会将数组转换长数组缓冲
    println(arr1.toBuffer)

    //注意：如果new，相当于调用了数组的apply方法，直接为数组赋值
    //初始化一个长度为1的定长数组
    val arr2 = Array[Int](10)
    println(arr2.toBuffer)

    //定义一个长度为3的定长数组
    val arr3 = Array("hadoop", "storm", "spark")
    //使用()来访问元素
    println(arr3(2))

    //变长数组（数组缓冲）
    //如果想使用数组缓冲，需要导入import scala.collection.mutable.ArrayBuffer包
    val ab = ArrayBuffer[Int]()
    //向数组缓冲的尾部追加一个元素
    //+=尾部追加元素
    ab += 1
    //追加多个元素
    ab += (2, 3, 4, 5)
    //追加一个数组++=
    ab ++= Array(6, 7)
    //追加一个数组缓冲
    ab ++= ArrayBuffer(8,9)
    //打印数组缓冲ab

    //在数组某个位置插入元素用insert，从某下标插入
    ab.insert(0, -1, 0)
    //删除数组某个位置的元素用remove  按照下标删除
    ab.remove(0)
    ab -=3
    ab --=Array(1,2)
    println(ab)

  }
}

5.1.2 遍历数组

1.增强for循环

2.根据脚标遍历使用until会生成脚标，0 until 10 包含0不包含10

package cn.itcast.scala

object ForArrayDemo {
  def main(args: Array[String]) {
    //初始化一个数组
    val arr = Array(1,2,3,4,5,6,7,8)
    //增强for循环
    for(i <- arr)
      println(i)

    //好用的until会生成一个Range
    //reverse是将前面生成的Range反转
    for(i <- (0 until arr.length).reverse)
      println(arr(i))
  }
}

5.1.3 数组转换

yield关键字将原始的数组进行转换会产生一个新的数组，原始的数组不变

package cn.itcast.scala

object ArrayYieldDemo {
  def main(args: Array[String]) {
    //定义一个数组
    val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
    //将偶数取出乘以10后再生成一个新的数组
    val res = for (e <- arr if e % 2 == 0) yield e * 10
    println(res.toBuffer)
    //运行结果：ArrayBuffer(20, 40, 60, 80)

    //更高级的写法,用着更爽
    //filter是过滤，接收一个返回值为boolean的函数
    //map相当于将数组中的每一个元素取出来，应用传进去的函数
    val r = arr.filter(_ % 2 == 0).map(_ * 10)
    println(r.toBuffer)
    //运行结果：ArrayBuffer(20, 40, 60, 80)

  }
}

5.1.4 数组常用算法

在Scala中，数组上的某些方法对数组进行相应的操作非常方便！

5.2 映射

在Scala中，把哈希表这种数据结构叫做映射。

5.2.1 构建映射

（1）构建映射格式

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

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

5.2.2 获取和修改映射中的值

（1）获取映射中的值：

值=map(键)

好用的getOrElse

注意：

在Scala中，有两种Map，一个是immutable包下的Map，该Map中的内容不可变；

另一个是mutable包下的Map，该Map中的内容可变

例子：

注意：通常我们在创建一个集合是会用val这个关键字修饰一个变量（相当于java中的final），那么就意味着该变量的引用不可变，该引用中的内容是不是可变，取决于这个引用指向的集合的类型

5.3 元组

映射是K/V对偶的集合，对偶是元组的最简单形式，元组可以装着多个不同类型的值。

5.3.1 创建元组

（1）元组是不同类型的值的聚集；对偶是最简单的元组。

（2）元组表示通过将不同的值用小括号括起来，即表示元组。

创建元组格式：

val tuple=(元素,元素...)

5.3.2 获取元组中的值

(1) 获取元组中的值格式：

使用下划线加脚标，例如 t._1 t._2 t._3

注意：元组中的元素脚标是从1开始的

5.3.3 将对偶的集合转换成映射

将对偶的集合转换成映射：

调用其toMap 方法

5.3.4 拉链操作

1.使用zip命令可以将多个值绑定在一起

注意：如果两个数组的元素个数不一致，拉链操作后生成的数组的长度为较小的那个数组的元素个数

2.如果其中一个元素的个数比较少，可以使用zipAll用默认的元素填充

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
    println(other_lst)
    //运行结果：List(2)

    //获取集合的第一个元素
    val first=lst1.head
    println(first)
    //运行结果：1
 
    //获取集合中除第一个元素外的其他元素集合,
    val tail=lst1.tail
    println(tail)
    //运行结果：List(2, 3)
 
    //补充：其中如果 List 中只有一个元素，那么它的 head 就是这个元素，它的 tail 就是 Nil；
    println(other_lst.head+"----"+other_lst.tail)
    //运行结果：2----List()

    //将0插入到lst1的前面生成一个新的List
    val lst2 = 0 :: lst1
    println(lst2)
    //运行结果：List(0, 1, 2, 3)


    val lst3 = lst1.::(0)
    println(lst3)
    //运行结果：List(0, 1, 2, 3)

    val lst4 = 0 +: lst1
    println(lst4)
    //运行结果：List(0, 1, 2, 3)

    val lst5 = lst1.+:(0)
    println(lst5)
    //运行结果：List(0, 1, 2, 3)
 
    //将一个元素添加到lst1的后面产生一个新的集合
    val lst6 = lst1 :+ 3
    println(lst6)
    //运行结果：List(1, 2, 3, 3)

    val lst0 = List(4,5,6) 
 
    //将2个list合并成一个新的List
    val lst7 = lst1 ++ lst0
    println(lst7)
    //运行结果：List(1, 2, 3, 4, 5, 6)

    //将lst0插入到lst1前面生成一个新的集合
    val lst8 = lst1 ++: lst0
    println(lst8)
    //运行结果：List(1, 2, 3, 4, 5, 6)
 
    //将lst0插入到lst1前面生成一个新的集合
    val lst9 = lst1.:::(lst0)
    println(lst9)
    //运行结果：List(4, 5, 6, 1, 2, 3)
 
  }
}

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

package cn.itcast.collect

import scala.collection.mutable.ListBuffer

object MutListDemo extends App{
  //构建一个可变列表，初始有3个元素1,2,3
  val lst0 = ListBuffer[Int](1,2,3)
  println(lst0)
  //运行结果：ListBuffer(1, 2, 3)

  //创建一个空的可变列表
  val lst1 = new ListBuffer[Int]
  //向lst1中追加元素，注意：没有生成新的集合
  lst1 += 4
  lst1.append(5)
  println(lst1)
  //运行结果：ListBuffer(4, 5)

  //将lst1中的元素添加到lst0中， 注意：没有生成新的集合
  lst0 ++= lst1
  println(lst0)
  //运行结果：ListBuffer(1, 2, 3, 4, 5)

  //将lst0和lst1合并成一个新的ListBuffer 注意：生成了一个集合
  val lst2= lst0 ++ lst1
  println(lst2)
  //运行结果：ListBuffer(1, 2, 3, 4, 5, 4, 5)

  //将元素追加到lst0的后面生成一个新的集合
  val lst3 = lst0 :+ 5
  println(lst3)
  //运行结果：ListBuffer(1, 2, 3, 4, 5, 5)

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

  //删除一个集合列表,生成了一个新的集合
  val lst5=lst4--List(1,2)
  println(lst5)
  //运行结果：ListBuffer(3, 4)

  //把可变list 转换成不可变的list 直接加上toList
  val lst6=lst5.toList
  println(lst6)
  //运行结果：List(3, 4)

  //把可变list 转变数组用toArray
  val lst7=lst5.toArray
  println(lst7)
  //运行结果：[I@79698539

  println(lst7.toList)
  //运行结果：List(3, 4)

}

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