一.Array

package com.bigdata.scala.day01

/**

 * @description: 不可变数组&&可变数组

 * @author: HaoWu

 * @create: 2020/7/24

 */

object $10_Array {

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

    //**************************不可变数组*********************************//

    //1.创建

    val arr1 = new Array[String](10) //方式一

    val arr2 = Array[String]("aaa", "bbb", "ccc") //方式二

    //2.新增

    val arr3 = arr2.+:("ddd") //添加元素，返回新数组

    val arr4 = arr2.++(arr3) //添加数组，返回新数组

    arr4(0) = "eee" //修改元素

    //3.查询

    val str: String = arr4(0) //根据索引，获取单值

    arr4.foreach(x => println(x)) //遍历

    //4.删除

    val arr5: Array[String] = arr2.drop(2) //删除前2个元素

    //5.转可变数组

    val buffer = arr5.toBuffer

    //********************************可变数组*******************************//

    //1.创建

    import scala.collection.mutable.ArrayBuffer //导入可变的包

    val muarr: ArrayBuffer[String] = new ArrayBuffer[String](10) //方式一

    val muarr1: ArrayBuffer[String] = ArrayBuffer("aaa", "bbb", "ccc") //方式二

    //2.新增

    val muarr2 = muarr1.+:("eee") //添加元素，返回新数组

    muarr1.+=:("eee") //可变数组添加单个元素

    muarr1.append("hhh", "iii") //可变数组后添加个元素

    muarr1.++=(ArrayBuffer("fff", "ggg")) //可变数组添加数组

    muarr1.insert(1, "abc", "bcd") //从索引位置开始添加多个元素

    //3.查询

    muarr1.foreach(println(_))

    //4.修改

    muarr1(2) = "dfg" //根据索引更新单个元素

    //5.删除

    muarr1 - "aaa" //根据值，删除单个元素

    muarr1.remove(1) //根据索引，删除单个元素

    muarr1 --= ArrayBuffer("bbb", "ccc") //根据值，删除多个元素

    val muarr11 = muarr1 -- ArrayBuffer("bbb", "ccc") //根据值，删除多个元素，返回新数组

    //6.转不可变数组

    val array = muarr1.toArray

    //********************************多维数组*******************************//

    //创建

    val dimArr: Array[Array[Int]] = Array.ofDim[Int](2,3)

    //遍历

    dimArr.foreach(x=>x.foreach(y=>println(y)))

  }

}

二. List

package com.bigdata.scala.day01

/**

 * @description: 不可变List&&可变List

 * @author: HaoWu

 * @create: 2020/7/24

 */

object $09_List {

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

    //**************************不可变List*********************************//

    //1.创建

    val list = List(1, 2, 3, 4, 5, 6) //设置值

    var list1: List[Int] = Nil //创建，设置空list

    //2.新增

    val list2 = list.+:(7) //在前添加单个元素，返回List

    val list3 = list.:+(8) //在后添加单个元素，返回List

    val list4 = list.::(9) //在后添加单个元素，返回List

    val list5 = 9 :: list //在前添加单个元素，返回List

    val list6 = list ::: List(1, 2, 3) //在后添加集合，返回List

    val list7 = List(1, 2, 3) ::: list //在前添加集合，返回List

    //3.查询

    list.foreach(x => println(x))

    //**************************可变List*********************************//

    //1.创建

    import scala.collection.mutable.ListBuffer //导包

    val listBuffer = ListBuffer(1, 2, 3, 4, 5)

    //2.新增

    listBuffer.+=(1, 2, 3) //在后添加多个元素

    listBuffer ++= List(7, 8, 9) //在后添加集合元素

    //3.查询

    listBuffer.foreach(x => println(x))

    //4.删除

    listBuffer.remove(1) //根据索引删除单个元素

    listBuffer -= 4 //删除第一个元素，4代表第4个元素

    listBuffer --= List(1,3,5) //删除包含集合中的元素

  }

}

三.Set

package com.bigdata.scala.day01

/**

 * @description: TODO

 * @author: HaoWu

 * @create: 2020年07月24日

 */

object $11_Set {

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

    //**************************不可变Set*********************************//

    //1.创建

    val set = Set(1, 2, 3, 4)

    //2.新增

    val set1 = set + (8, 9, 10) //添加元素，个数可变

    val set2 = set ++ Set(4, 5, 6) //添加Set

    //3.查询

    set.foreach(println(_))

    //4.删除

    val set3 = set1 - (8, 9) //删除元素，个数可变

    val set4 = set2 -- Set(4, 5) //删除Set

    //**************************可变Set*********************************//

    //1.创建

    import scala.collection.mutable.Set //导包

    val muSet = Set(1, 2, 3)

    //2.新增

    muSet += 4 //添加单个元素

    muSet ++= Set(5, 6) //添加Set集合

    //3.查询

    muSet.foreach(x => println(x))

    //4.删除

    muSet -= 10 //删除单个元素

    muSet --= Set(5,6) //删除Set集合

  }

}

四.Tuple

元组一旦定义，元素不可以删除，不能修改。

package com.bigdata.scala.day01

/**

 * @description: TODO

 * @author: HaoWu

 * @create: 2020年07月24日

 */

object $13_Tuple {

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

    //1.创建

    val tuple = ("zhangsan", 20, "Beijing") //Tuple3类型

    val tuple1 = ("name", "lisi") //对偶元祖，Tupl2类型

    val tuple2 = ("name" -> "lisi")

    val tuple3 = List[(String, Int, String)](

      ("zhangsan", 20, "beijing"),

      ("lisi", 30, "shenzhen")) //集合元素是元祖

    //2.查询

    val value1 = tuple._1

    val value2 = tuple._2

    val value3 = tuple._3

  }

}

五.Map

package com.bigdata.scala.day01

/**

 * @description: TODO

 * @author: HaoWu

 * @create: 2020年07月24日

 */

object $12_Map {

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

    //**************************不可变Map*********************************//

    //1.创建

    val map = Map[String, String](

      "name" -> "zhangsan",

      "age" -> "20",

      "address" -> "BeiJing") //方式一

    val map2 = Map[String, String](

      ("name", "lisi"),

      ("age", "30"),

      ("address", "ShenZhen")) //方式二

    //2.新增/修改

    val map11 = map.+("email" -> "1001", "id" -> "11") //添加元素

    val map21 = map2 + (("dept", "11")) //添加元素

    val map22 = map2.++(map) //添加Map

    //3.查询

    val value = map11.getOrElse("email", "null") //根据key获取值，key不存在值设null

    map.foreach(x => println(x._1)) //遍历key

    map.keys.foreach(x => println(x)) //遍历key

    map.values.foreach(x => println(x)) //遍历value

    //**************************可变Map***********************************//

    //1.创建

    import scala.collection.mutable.Map

    val muMap = Map[String, String](

      ("name", "lisi"),

      ("age", "20")) //方式一

    val muMap2 = Map[String, String](

      ("name", "lisi"),

      ("age", "30")) //方式二

    //2.新增/修改

    muMap += (("address", "Henan")) //添加单个元素

    muMap2 += ("address" -> "Henan") //添加单个元素

    //3.查询

    val value1 = muMap.getOrElse("email", "null") //根据key获取值，key不存在值设null

    muMap.foreach(x => println(x._1)) //遍历key

    muMap.keys.foreach(x => println(x)) //遍历key

    muMap.values.foreach(x => println(x)) //遍历value

    //4.删除

    muMap -= "name"

  }

}