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", "张翠山")) // 这种申明形式，外面就是对偶元组
  }
}