(四)Scala集合

1.Scala 集合概述

Scala有三类集合：序列Seq、Set、映射Map。
Scala中，几乎所有的集合，都提供可变和不可变两个版本。

一般，我们根据集合所在的包来区分是可变集合还是不可变集合。

• scala.collection.immutable 不可变集合
• scala.collection.mutable 可变集合

2.Scala 集合

2.1 数组

2.1.1 不可变数组

object Scala_Coll {
  def main(args: Array[String]): Unit = {
    // Scala 数组 - 不可变
    // 1. 创建数组对象
    // 方式一
    // new Array[String](5) 编译后会生成java的数组代码
    val array = new Array[String](5)
    // 方式二
    val array1 = Array(1,2,3,4)

    // 2. 打印数组
    println(array) // 输出结果 [Ljava.lang.Object;@4cdbe50f
    // 3.数组赋值，Scala下标索引使用小括号
    array(0) = "张三"
    array(1) = "李四"
    array(2) = "王五"
    array(3) = "赵六"
    // 4.采用update方式修改数组的值
    array.update(4,"哈哈")
    // 5.查看数组
    println(array.mkString(","))
    // 6.遍历数组- 方式1
    for(i<-array){
      println(i)
    }
    // 7.遍历数组 - 方式2
    //  array.foreach(i => println(i)) 精简为
    array.foreach(println)

    /////// 数组操作 ///////
    // 1)添加数组元素，不可变数组添加数组元素后，返回一个新的数组，本身不会发生改变
    // :+ 添加元素到尾部
    val arr1 = array :+ 5
    // +: 添加元素到首部
    val arr2 = arr1.+:(5)
    // ++ 添加数组
    val arr3 = arr1 ++ arr2
    
  }
}

2.1.2 可变数组

import scala.collection.mutable.ArrayBuffer

object Scala_Coll {
  def main(args: Array[String]): Unit = {
    // 1.声明可变数组：scala.collection.mutable.ArrayBuffer
    // 方式1
    val arr1 = new ArrayBuffer[Int]()
    // 方式2
    val arr2 = ArrayBuffer(1,2,3,4)

    // 2.增加数据
    arr1.append(4,5,6,7)
    println(arr1.mkString(","))

    // 3.修改数据
    arr1.update(1,10)
    println(arr1.mkString(","))

    // 4.删除数据
    arr1.remove(1,2) //从索引位置1开始删除2个数据
    println(arr1.mkString(","))

    // 5.查询数据
    println(arr1(1))

    // 6.遍历集合
    arr1.foreach(println)

    // 7. ++ 运算符会产生新的集合数组
    val arr3 = arr1 ++ arr2
    println(arr3.mkString(","))

    // 8. ++= 运算符则更新之前集合，并不产生新的数组
    arr1 ++= arr2
    println(arr1.mkString(","))
    
  }
}

2.1.3 可变数组和不可变数组的互相转换

import scala.collection.mutable.ArrayBuffer

object Scala_Coll {
  def main(args: Array[String]): Unit = {
    val arr1 = Array(1,2,3,4)
    // 将不可变数组arr1转换为可变数组
    val arr2 = arr1.toBuffer
    // 将可变数组arr2转换为不可变数组
    val arr3 = arr2.toArray

  }
}

2.2 Seq集合

2.2.1 不可变list

object Scala_Coll {
  def main(args: Array[String]): Unit = {
    // 不可变list
    // 1.声明对象
    val list = List(1, 2, 3, 4)
    // 2.增加元素，返回新的list
    val list1 = list :+ 1
    // 3.遍历list
    list1.foreach(println)
    // 4.空集合Nil
    // 一般用于增加数据
    val list2 = 1 :: 2 :: 3 :: 4 :: Nil
    println(list2.mkString(","))

    // 添加集合
    val list3 = 1 :: 2 :: 3 :: list1 :: Nil
    println(list3.mkString(",")) // 输出结果 1,2,3,List(1, 2, 3, 4, 1)

    // 我们需要将list1的元素作为一个一个的个体使用，也就是扁平化操作
    val list4 = 1 :: 2 :: 3 :: list1 ::: Nil
    println(list4.mkString(",")) // 输出结果 1,2,3,1,2,3,4,1

    // 5.连接集合
    val list5 = List.concat(list3, list4)
    list5.foreach(println)

    // 6.创建一个指定重复数量的列表
    val list6 = List.fill[String](3)("Hello")
    list6.foreach(println)

  }
}

2.2.2 可变list

import scala.collection.mutable.ListBuffer

object Scala_Coll {
  def main(args: Array[String]): Unit = {
    // 1.可变list
    var list1 = new ListBuffer[Int]
    // 2.增加数据
    list1.append(1,2,3,4)
    val list2 = list1 :+ 5
    list1+=5
    println(list1.mkString(","))
    println(list2.mkString(","))
    val list3 = list1 ++ list2
    println(list3.mkString(","))

    // 3.修改数据
    list1.update(1,10)
    println(list1(1))

    // 4.删除数据
    list1.remove(1,2)
    println(list1.mkString(","))
    // 5.获取数据
    println(list1(1))

  }
}

2.2.3 可变list和不可变list的相互转换

import scala.collection.mutable.ListBuffer

object Scala_Coll {
  def main(args: Array[String]): Unit = {
    // 创建一个不可变集合
    var list = List(1,2,3,4) 
    // 将不可变集合转变为可变集合
    val buffer = list.toBuffer
    // 将可变集合buffer转变为不可变集合
    val list1 = buffer.toList
  }
}

2.3 Map映射

2.3.1 不可变Map

import scala.collection.mutable.ListBuffer

object Scala_Coll {
  def main(args: Array[String]): Unit = {
    // 1.创建Map 两种方式
    val map1 = Map("a"->"张三","b"->"李四","c"->"王五")
    val map2 = Map(("a","张三"),("b","李四"),("c","王五"))
    println(map1)
    println(map2)

    // 2.添加数据
    val map3 = map1 + ("d" -> "张三丰")
    println(map3)

    // 3.删除数据
    val map4 = map3 - "d"
    println(map4)

    // 4.修改数据
    val map5 = map4.updated("b", "黄蓉")
    println(map5)

    // 5.遍历
    map5.foreach(println)

    // 6.获取指定key的值
    val str = map5.apply("a")
    println(str)

    // 7.获取可能存在的key值
    val maybeString:Option[String] = map5.get("a")
    println(maybeString.get) // 如果是从None值获取会发生异常
    println(maybeString.getOrElse(-1)) // 如果获取到返回值，获取不到返回默认值

    // 更加简洁的用法
    val value = map5.getOrElse("d", -1)
    println(value)
    
  }
}

2.3.2 可变Map

import scala.collection.mutable

object Scala_Coll {
  def main(args: Array[String]): Unit = {
    // 声明可变Map
    val map1 = mutable.Map("a" -> "郭靖", "b" -> "黄蓉")
    val map2 = mutable.Map(("a","杨过"),("b","小龙女"))

    // 添加数据
    map1.put("c","郭襄")
    val map3 = map1 + ("d" -> "郭芙")
    map1 += ("d"->"郭芙")

    // 修改数据
    map1.update("d","郭破虏")
    map1("d") = "郭芙"

    // 删除数据
    map1.remove("d")
  }
}

2.4 元组

object Scala_Coll {
  def main(args: Array[String]): Unit = {
    // 元组可以看成是容纳元素的容器，最多可以容纳22个元素
    // 声明一个元组
    val tuple = (1, "a", "张三丰", 18)

    // 元组中的数据可以通过数据的顺序来访问
    println(tuple._1)
    println(tuple._2)
    println(tuple._3)
    println(tuple._4)

    // 元组遍历
    val iterator = tuple.productIterator
    while (iterator.hasNext){
      println(iterator.next())
    }

    // 对偶元组:只有两个元素,也可以叫键值对
    val map = Map(("a", "张三丰"), ("b", "张翠山")) //这种声明方式，里面就是对偶元组
  }
}