18.可变和不可变集合

可变和不可变集合

对可变集合中数据的增删改之后会返回一个新的集合

• Scala不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而不会对原对象进行修改。类似于java中的String对象

• 可变集合，就是这个集合可以直接对原对象进行修改，而不会返回新的对象。类似于java中StringBuilder对象

数组

可变数组

def main(args: Array[String]): Unit = {

        val arrayBuffer = new ArrayBuffer[String]()

        // 增加到最后
        arrayBuffer.append("ads","das ")
        // 增加到指定位置
        arrayBuffer.insert(0,"321")

        // 修改
        arrayBuffer(0)="das"    // 和update是一样的，在编译时会将这种写法自动转换成下面那种
        arrayBuffer.update(0, "eaw")

        // 删除
        arrayBuffer.remove(1)
        // 从1开始删除2数
        arrayBuffer.remove(1,2)
        // 可变数组也可以产生新的
        // drop是原方法操作后产生新的集合，
        val buffer = arrayBuffer.drop(1)
        // 从右往左删除
        val buffer2 = arrayBuffer.dropRight(2)
        // 在可变集合中，调用运算符的操作会产生新的集合,使用+=不会产生新的集合
        val buffer3 = arrayBuffer.-("321")
        // 使用+=不会创建一个新的数组
        buffer3 += "3"


    }

不可变数组

object Scala02Array {
    def main(args: Array[String]): Unit = {

        // 集合-Array-->数组
        // 创建
        // 反编译的源码就是java中的String数组
        // 创建一。
        val array = new Array[String](3)

        // 创建二,类似于java中的赋予初值的创建数组方式
        val strings1 = Array("1", "2", "3")

        // 元素操作
        // 访问数组元素需要采用小括号定位
        // 在Scala中访问数组元素需要使用小括号.修改数据
        array(0) = "a"
        array(1) = "b"
        array(2) = "c"

        // 增加元素,返回了一个新的数组
        val strings = array :+ "d"

        // 数组可以增加数据，添加后会产生新的数组，所以array是不可变的
        val array2 = array +: "d"
        // Scala中的运算符如果使用冒号结尾，那么其调用的顺序为从右到左
        val array3 = "d" +: array // array.+:(e)
        // 集合打印
        // 实际就是java中的数组
//        println(s"array = ${array}")
//        println(s"array(1) = ${array(1)}")
        for (s <- array){
            println(s"s = ${s}")
        }
        array.foreach((s)=> println(s"s = ${s}"))

        // forEach表示对array中的每一个元素用一个函数处理，该函数的输入为string，返回值为Unit
        array.foreach(println((_)))
        array.foreach(println)
        println(array.mkString(","))
        println(strings.mkString(","))
        println(array2.mkString(","))

    }
}

可变和不可变的集合

    def main(args: Array[String]): Unit = {
        val array = Array(1, 2, 3)
        val buffer: mutable.Buffer[Int] = array.toBuffer

    val array1 = buffer.toArray
    }

序列

不可变序列List

集合——Seq——List()

 def main(args: Array[String]): Unit = {
        val ints = List(1, 2, 3)
        // 集合-Seq-List
        // immutable,不可变
        val list = ints
        val list4 = 1 :: 2 :: 3 :: 4 :: List()
        val list5 = 1 :: 2 :: 3 :: 4 :: Nil
        // 增加数据
        val list2 = list :+ 2
        val list3 = 2 :: list
        val list10: List[Int] = list :+ 3
        val list11: List[Int] = 3 +: list
        // 把list当一个整体。 Nil等同于List()
        val list6 = 4 :: list :: Nil
        // ：：： 表示把一个整体拆分为一个一个的个体使用，将这个操作称之为扁平化操作。把集合拆掉
        val list7 = 5 :: list ::: Nil
        // ++:也是扁平化操作
        // 修改
        // 不能直接修改
        //list(0) = 5
        val list1 = list.updated(0, 5)
        ints
        println(list4)

       //    List(1,2,3)

        val list8: List[Any] = 1 :: ints :: Nil
        val list9: List[Int] = 1 :: 2 :: Nil

        // 三个冒号表示把一个整体拆分成一个一个的个体操作
    }

可变序列

    def main(args: Array[String]): Unit = {
        // 集合-Seq-List(可变)
        val listBuffer = ListBuffer(1, 2, 3, 4)
        listBuffer.insert(12)
        listBuffer.update(1,3)
        listBuffer(0)= 2
        listBuffer.remove(1)
        listBuffer.foreach(println(_))
    }

Map

不可变Map

  def main(args: Array[String]): Unit = {
        // Map
        val wordToCount = mutable.Map("a" -> 1, "b" -> 2, "c" -> 3)

        // 获取指定key的值
        // java中取一个不存在key，返回值为null
        // Scala去一个不存在key，返回值为None
        // Scala取一个存在的key，返回为some
        // Scala中从Map取一个数据的结果类型为Option（选项），只有两个值，一个为some,一个为null
        val value = wordToCount.get("a")
        val value1 = wordToCount.get("d")

        println(s"value = ${value.get}")
        println(s"value1 = ${value1.getOrElse(3)}")

        val i = wordToCount.getOrElse("d", 0)
        println(s"i = ${i}")

        // Scala中Option专门为了解决空指针异常的。

        wordToCount.keys
        wordToCount.values
        wordToCount.iterator
        wordToCount.keysIterator
        val tuple: (Int, String, Int) = (1, "2", 3)
        tuple.productIterator
    }

可变Map

 def main(args: Array[String]): Unit = {

        //（1）创建可变集合
        val map = mutable.Map( "a"->1, "b"->2, "c"->3 )

        //（3）向集合增加数据
        map.+=("d"->4)

        // 将数值4添加到集合，并把集合中原值1返回
        val maybeInt: Option[Int] = map.put("a", 4)
        println(maybeInt.getOrElse(0))

        //（4）删除数据
        map.-=("b", "c")

        //（5）修改数据
        map.update("d",5)
        map("d") = 5

        //（2）打印集合
        map.foreach((kv)=>{println(kv)})
    }
}

Option

Option在Scala中主要用于处理空指针异常，Option有两个字类，some和None,为None就是Null.

Tuple

可以将不同类型的元素存在一个集合中，Scala中当List泛型为Any时也可以放所有类型的元素

可变tuple

  def main(args: Array[String]): Unit = {
        // Tuple:=>无关数据元素的组合
        val tuple1: (Int, String, String, Int) = (1, "tttt", "zzz", 20)

        // 元组数据需要通过顺序号来访问其中的数据

        println(tuple1._1)
        println(tuple1._2)
        println(tuple1._3)

        // Scala元组中元素的数量最多只能放22个，函数的参数列表个数也是20个
        // productIterator可以生成迭代器
        tuple1.productIterator.foreach(println)

        // 索引访问
        println(s"tuple1.productElement(0) = ${tuple1.productElement(0)}")
    }
    
     def main(args: Array[String]): Unit = {
        // 如果元组中元素只有两个，那么将这样的元组称之为对偶元组
        // 也称之为 -- 键值对 --
        val tuple2 = ("a",1)

        // 键值对，返回的也是元组
        val tuple3 = "b".->(2)

        val map = mutable.Map(("a", 1), ("b", 2))

        // 循环keyValue
        for(kv <- map>){

        }

    }