第一章.集合

1.不可变数组的创建

  1. package com.atguigu.chapter07
  3. object $01_ImmutableArray {
  4.   /**
  5.    * 不可变数组的创建(不可变集合,就是指该集合对象不可修改,每次修改就会返回一个新对象,而不会对原对象进行修改)
  6.    *    1.通过new的方式: new Array[元素类型](数组长度)
  7.    *    2.通过apply方法: Array[元素类型](初始元素,....)
  8.    *
  9.    * 集合添加,删除的通用方法的区别
  10.    *    a.带+与带-的区别:
  11.    *       带+是添加元素
  12.    *       带-是删除元素
  13.    *    b.一个+/-与两个+/-的区别
  14.    *       一个+/-是添加/删除单个元素
  15.    *       两个+/-是添加/删除一个指定集合中的所有元素
  16.    *    c.冒号在前与冒号在后以及不带冒号的区别
  17.    *       冒号在前是将元素添加到集合最后面
  18.    *       冒号在后是将元素添加到集合最前面
  19.    *       不带冒号将元素添加到集合最后面
  20.    *    d.带=与不带=的区别
  21.    *       带=是修改集合本身
  22.    *       不带=是生成新集合,原集合没有改变
  23.    *    e.updated与update的区别
  24.    *       updated是生成一个新集合
  25.    *       update是修改原集合
  26.    */
  27.   def main(args:Array[String]):Unit={
  28.     //1.通过new的方式:new Array[元素类型](数组长度)
  29.     val arr = new Array[Int](5)
  30.     println(arr.toList)
  31.     //2.通过apply方法:Array[元素类型](初始元素 )
  32.     val arr2 = Array[Int](10,2,3,6,5)
  33.     println(arr2.toList)
  34.     //添加元素
  35.     //添加单个元素
  36.     val arr3 = arr2.:+(20)
  37.     println(arr2.toList)
  38.     println(arr3.toList)
  39.     println(arr2.eq(arr3))
  40.     //添加一个集合所有元素
  41.     val arr5 = arr2.++(Array(100, 300, 200))
  42.     println(arr5.toList)
  43.     println(arr2.toList)
  45.     val arr6 = arr2.++:(Array(500, 700, 200))
  46.     println(arr6.toList)
  47.     //删除元素
  49.     //获取元素
  50.     println(arr6(0))
  51.     //修改元素
  52.     arr6(0) = 1000
  53.     println(arr6.toList)
  54.     //遍历
  55.     for (elem <- arr6) {
  56.       println(elem)
  57.     }
  58.     //不可变转可变
  59.     val arr7 = arr6.toBuffer
  60.     println(arr7)
  61.   }
  63. }

2.可变数组的创建

  1. package com.atguigu.chapter07
  3. import scala.collection.mutable.ArrayBuffer
  5. object $02_MutableArray {
  6.   /**
  7.    * 创建可变数组(可变数组,就是这个集合可以直接对原对象进行修改,而不会返回新的对象)
  8.    *    1.通过new方式: new ArrayBuffer[元素类型]()
  9.    *    2.通过apply方法: ArrayBuffer[元素类型](初始元素,...)
  10.    */
  11.   def main(args: Array[String]): Unit = {
  12.     //1.通过new的方式: new ArrayBuffer[元素类型]()
  13.     val arr = new ArrayBuffer[Int]()
  14.     println(arr)
  15.     //2.通过apply方法:ArrayBuffer[元素类型](初始元素,....)
  16.     val arr2 = ArrayBuffer[Int](10, 2, 5, 3, 7, 9)
  17.     println(arr2)
  18.     //添加元素
  19.     val arr3 = arr2.+:(20)
  20.     println(arr2)
  21.     println(arr3)
  22.     val arr4 = arr2.:+(30)
  23.     println(arr4)
  24.     arr2.+=(40)
  25.     println(arr2)
  26.     arr2.+=:(50)
  27.     println(arr2)
  28.     val arr5 = arr2.++(Array(100, 200, 300))
  29.     println(arr5)
  30.     println(arr2)
  31.     val arr6 = arr2.++:(Array(400, 500, 600))
  32.     println(arr6)
  33.     arr2.++=(Array(100,250,305,305))
  34.     println(arr2)
  35.     arr2.++=:(Array(505,605,705))
  36.     println(arr2)
  37.     //删除
  38.     val arr7 = arr2.-(305)
  39.     println(arr2)
  40.     println(arr7)
  41.     arr2.-=(305)
  42.     println(arr2)
  43.     arr2.--=(Array(605,50,10,2))
  44.     println(arr2)
  45.     //获取元素
  46.     println(arr2(0))
  47.     //修改元素
  48.     arr2(0)=1000
  49.     println(arr2)
  50.     //遍历
  51.     for (elem <- arr2) {
  52.       println(s"elem=${elem}")
  53.     }
  54.     //可变转不可变
  55.     val arr10 = arr2.toArray
  56.     println(arr10.toList)
  57.     //多维数组
  58.     val arr11 = Array.ofDim[Int](3, 4)
  59.     println(arr11.size)
  60.     println(arr11(0).size)
  61.   }
  63. }

3.不可变List创建

  1. package com.atguigu.chapter07
  3. object $03_ImmutableList {
  4.   /**
  5.    * 不可变List创建
  6.    *    1.通过apply方法: List[元素类型]{初始元素,.....}
  7.    *    2.通过::方法创建: 初始元素::初始元素::...::Nil/不可变List
  8.    *      Nil就是空的不可变List,Nil与不可变List关系类似Null与String的关系,Nil一般用于给不可变list赋予初始值,在赋予初始值的
  9.    *      时候必须定义变量类型
  10.    *    添加元素:
  11.    *    ::是添加单个元素,是生成一个新集合,原集合没有改变
  12.    *    :::是添加一个集合所有元素,是生成一个新集合,原集合没有改变
  13.    *
  14.    */
  15.   def main(args: Array[String]): Unit = {
  16.     //1.通过apply方法:List[元素类型](初始元素)
  17.     val list1 = List[Int](1, 4, 3, 2, 7, 9)
  18.     println(list1)
  19.     //2.通过::方法创建:初始元素::初始元素::...::Nil/不可变List
  20.     val list2 = 1 :: 2::3::6::Nil
  21.     println(list2)
  23.     var list3:List[Int]=Nil
  24.     println(list3)
  25.     //添加元素
  26.     val list4 = list2.:+(10)
  27.     println(list4)
  28.     val list5 = list2.+:(20)
  29.     println(list5)
  30.     val list6 = list2.::(30)
  31.     println(list6)
  32.     val list7 = list2.++(Array(100, 300, 200))
  33.     println(list7)
  34.     val list8 = list2.++:(List(100, 300, 200))
  35.     println(list8)
  36.     val list9 = list2.:::(List(5050, 405))
  37.     println(list9)
  39.     //删除元素
  41.     //获取元素
  42.     println(list9(0))
  43.     //修改元素
  44.     //list9(0)=1000
  45.     //println(list9)
  46.     val list10 = list9.updated(0, 1000)
  47.     println(list10)
  48.   }
  49. }

4.可变List创建

  1. package com.atguigu.chapter07
  3. import scala.collection.mutable.ListBuffer
  5. object $04_MutableList {
  6.   /**
  7.    * 可变List 的创建
  8.    *    1.通过apply方法: ListBuffer[元素类型](初始元素)
  9.    *    2.通过new方式
  10.    */
  11.   def main(args: Array[String]): Unit = {
  12.     //1.通过apply方法:ListBuffer[元素类型](初始元素,....)
  13.     val list1 = ListBuffer[Int](1,4,2,7,9)
  14.     println(list1)
  15.     //2.通过new方式: new ListBuffer[元素类型]()
  16.     val list2 = new ListBuffer[Int]()
  17.     println(list2)
  18.     //添加元素
  19.     val list3 = list1.+:(10)
  20.     println(list3)
  21.     val list4 = list1.:+(20)
  22.     println(list4)
  23.     list1.+=(40)
  24.     println(list1)
  25.     list1.+=:(50)
  26.     println(list1)
  27.     //在指定角标位置插入元素
  28.     list1.insert(1,10,20,30)
  29.     println(list1)
  30.     //删除元素
  31.     list1.remove(1,3)
  32.     println(list1)
  34.     val list5 = list1.-(50)
  35.     println(list5)
  36.     list1.-=(50)
  37.     println(list1)
  38.     val list6 = list1.--(List(1,2,7))
  39.     println(list6)
  40.     println(list1)
  41.     list1.--=(List(1,2,7))
  42.     println(list1)
  44.     //获取元素
  45.     println(list1(0))
  46.     //修改元素
  47.     list1(0)=100
  48.     println(list1)
  49.     list1.update(1,90)
  50.     println(list1)
  51.     val list11 = list1.updated(2,4)
  52.     println(list1)
  53.     println(list11)
  54.   }
  56. }

5.不可变set创建

  1. package com.atguigu.chapter07
  3. object $05_ImmutableSet {
  4.   /**
  5.    * 不可变set的创建
  6.    *     通过apply方法: Set[元素类型](初始元素,...)
  7.    *     set的特性:不重复,无序
  8.    */
  9.   def main(args: Array[String]): Unit = {
  10.     //通过apply方法:Set[元素类型](初始元素,....)
  11.     val set1= Set[Int](1,2,5,3,1,9,10)
  12.     println(set1)
  13.     //添加元素
  14.     val set2 = set1.+(20)
  15.     println(set2)
  16.     val set3 = set1.++(List(100,300,200,700))
  17.     val set4 = set1.++(List(100,300,200,700))
  18.     println(set3)
  19.     println(set4)
  21.     var set10 = Set[Int](1,3,5,7,9)
  22.     val set11 = set10
  23.     println("-------------------------------")
  24.     set10.+=(20)
  25.     set10=set10.+(20)
  26.     println(set10)
  27.     println(set11.eq(set10))
  28.     //删除元素
  29.     val set5 = set1.-(10)
  30.     println(set5)
  31.     val set6 = set1.--(List(2,3,5))
  32.     println(set6)
  33.   }
  35. }

6.可变set的创建

  1. package com.atguigu.chapter07
  3. import scala.collection.mutable
  5. object $06_MutableSet {
  6.   /**
  7.    * 可变set的创建:
  8.    *    通过apply方法的创建: mutable.Set[元素类型](初始元素,....)
  9.    */
  10.   def main(args: Array[String]): Unit = {
  11.     //通过apply方法创建:mutable.Set[元素类型](初始元素,....)
  12.     val set1 = mutable.Set[Int](10,20,30,40)
  13.     //添加元素
  14.     val set2 = set1.+(50)
  15.     println(set2)
  16.     set1.+=(60)
  17.     println(set1)
  18.     val set3 = set1.++(List(70,100,300,80))
  19.     println(set3)
  20.     val set4 = set1.++:(List(70,100,300,80))
  21.     println(set4)
  22.     set1.++=(List(500,700,200,300))
  23.     println(set1)
  24.     //删除元素
  25.     val set6 = set1.-(60)
  26.     println(set6)
  27.     set1.-=(700)
  28.     println(set1)
  29.     set1.--=(List(500,200,300))
  30.     println(set1)
  32.     //获取元素
  33.     //修改元素
  34.     set1.update(500,true)
  35.     println(set1)
  36.     set1.update(60,false)
  37.     println(set1)
  39.   }
  41. }

7.元组

  1. package com.atguigu.chapter07
  3. object $07_Tuple {
  4.   /**
  5.    * 元组的创建:
  6.    *     1.通过()创建:(初始元素,初始元素,....)
  7.    *     2.针对二元元组:K-> V
  8.    *     scala中二元元组表示KV键值对
  9.    * 元组最多只能存放22个元素
  10.    * 元组一旦创建,元素和长度都不可改变
  11.    * 元组获取元素:元组名._角标[元组的角标从1开始]
  12.    */
  13.   class Region(val name:String,val school:School)
  14.   class School(val name:String,val student:Student)
  15.   class Student(val name:String,val age:Int)
  16.   def main(args: Array[String]): Unit = {
  17.     //通过()创建:(初始元素,初始元素,....)
  18.     val t1 = ("zhangsan",20,"shenzhen")
  19.     val t2 = "lisi" -> 20
  20.     println(t1)
  21.     println(t2)
  22.     println(t1._1)
  23.     println(t1._2)
  24.     println(t1._3)
  27.     println("---------------------------")
  28.     val list = List("1 zhangsan 20 shenzhen","2 lisi 30 beijing","3 wangwu 40 tianjin")
  29.     val list2 = for(element<-list) yield {
  30.       val arr = element.split(" ")
  31.       (arr(0),arr(1),arr(2),arr(3))
  32.     }
  33.     println(list2)
  36.     val list3 = List(
  37.       new Region("宝安区1",new School("宝安中学1",new Student("张三1",21))),
  38.       new Region("宝安区2",new School("宝安中学2",new Student("张三2",22))),
  39.       new Region("宝安区3",new School("宝安中学3",new Student("张三3",23))),
  40.       new Region("宝安区4",new School("宝安中学4",new Student("张三4",24)))
  41.     )
  43.     val list4 = for (elem <- list3) yield{
  44.       (elem.name,(elem.school.name,(elem.school.student.name,elem.school.student.age)))
  46.     }
  47.     for (elem <- list4) {
  48.       println(elem._2._2._1)
  49.     }
  50.   }
  52. }

8.不可变map的创建

  1. package com.atguigu.chapter07
  3. object $08_ImmutableMap {
  4.   /**
  5.    * 不可变map的创建:
  6.    *    通过apply方法: Map[k的类型,v的类型]((K,V), K->V)
  7.    *    map获取value的值:getOrElse(key,默认值) [key如果在map中存在则返回value值,如果不存在则返回默认值]
  8.    *    Option:提醒外部当前结果有可能为空需要处理
  9.    *       Some:代表有值
  10.    *       None:代表为空
  11.    */
  12.   def main(args: Array[String]): Unit = {
  13.     //通过apply方法:Map[K的类型,V的类型]((K,V),K->V)
  14.     val map = Map[String,Int]("zhangsan"->20,("lisi",30),"wangwu"->22)
  15.     println(map)
  16.     //添加元素
  17.     val map2 = map.+("aa" -> 20)
  18.     println(map2)
  19.     val map3 = map.++(List("cc"->30,"ac"->40,"dc"->50))
  20.     println(map3)
  21.     val map4 = map.++:(List("cc"->30,"ac"->40,"dc"->50))
  22.     println(map4)
  23.     //删除元素
  24.     val map5 = map.-("lisi")
  25.     println(map5)
  26.     val map6 = map4.--(List("dc","cc","ac"))
  27.     println(map6)
  28.     //修改元素
  29.     val map7 = map.+("zhangsan"->200)
  30.     println(map7)
  31.     //map("zhangsan")=1000
  32.     //println(map)
  33.     val map8 = map.updated("lisi",1000)
  34.     println(map8)
  35.     //获取元素
  36.     // println(map("lisi_1"))
  37.     println(map.get("lisi").get)
  38.     //println(map.get("lisi_1"))
  39.     println(map.getOrElse("lisi_1", -1))
  41.     //获取所有的key
  42.     println(map.keySet)
  43.     //获取所有的value
  44.     println(map.values)
  45.     for (elem <- map) {
  46.       println(elem)
  47.     }
  48.   }
  50. }

9.可变map的创建

  1. package com.atguigu.chapter07
  3. import scala.collection.mutable
  5. object $09_MutableMap {
  7.   /**
  8.    * 可变Map的创建: mutable.Map[K的类型,V的类型](K->V,(K,V),...)
  9.    */
  10.   def main(args: Array[String]): Unit = {
  11.     val map = mutable.Map[String, Int]("aa" -> 10, "cc" -> 20, "dd" -> 30, "ac" -> 40)
  12.     println(map)
  13.     //添加元素
  14.     val map2 = map.+("tt"->60)
  15.     println(map2)
  16.     map.+=("pp"->70)
  17.     println(map)
  18.     val map3 = map.++(List("cd"->100,"ce"->200,"fc"->300))
  19.     println(map3)
  20.     val map4 = map.++:(List("cd"->100,"ce"->200,"fc"->300))
  21.     println(map4)
  22.     map.++=(List("yy"->20,"oo"->30))
  23.     println(map)
  24.     map.put("hello",30)
  25.     println(map)
  26.     //删除元素
  27.     val map5 = map.-("hello")
  28.     println(map5)
  29.     map.-=("oo")
  30.     println(map)
  31.     val map6 = map.--(List("yy","dd","hello"))
  32.     println(map6)
  33.     map.--=(List("pp","cc","hello"))
  34.     println(map)
  35.     map.remove("yy")
  36.     println(map)
  37.     //获取元素
  38.     println(map.getOrElse("dd", -1))
  39.     println(map.keys)
  40.     println(map.values)
  41.     //修改元素
  42.     map("dc")=300
  43.     println(map)
  44.     map.update("pp",100)
  45.     println(map)
  46.   }
  48. }

10.不可变队列的创建

  1. package com.atguigu.chapter07
  3. import scala.collection.immutable.Queue
  5. object $10_ImmutableQuene {
  6.   //不可变队列的创建: Queue[元素类型](初始元素,...)
  7.   def main(args: Array[String]): Unit = {
  8.     //创建队列
  9.     val queue = Queue[Int](10,3,2,6,8,9)
  10.     println(queue)
  11.     //添加元素
  12.     val queue2 = queue.+:(20)
  13.     println(queue2)
  14.     val queue3 = queue.:+(20)
  15.     println(queue3)
  16.     val queue4 = queue.++(List(100,200,400,300))
  17.     println(queue4)
  18.     val queue5 = queue.++:(List(100,200,400,300))
  19.     println(queue5)
  20.     val queue6 = queue.enqueue(50)
  21.     println(queue6)
  22.     //删除元素
  23.     val queue7 = queue.dequeue
  24.     println(queue7)
  25.     //获取元素
  26.     println(queue(0))
  27.     //修改元素
  28.     val queue10 = queue.updated(1,100)
  29.     println(queue10)
  30.   }
  32. }

11.可变队列的创建

  1. package com.atguigu.chapter07
  3. import scala.collection.mutable
  5. object $11_MutableQueue {
  6.   //可变队列的创建:mutable.Queue[元素类型](初始元素,....)
  7.   def main(args: Array[String]): Unit = {
  8.     val q1 = mutable.Queue[Int](10,3,2,7,9,4)
  9.     //添加元素
  10.     val q2 = q1.:+(30)
  11.     println(q2)
  12.     val q3 = q1.+:(40)
  13.     println(q3)
  14.     q1.+=(50)
  15.     println(q1)
  16.     q1.+=:(60)
  17.     println(q1)
  18.     val q4 = q1.++(List(100,300,200))
  19.     println(q4)
  20.     val q6 = q1.++:(List(400,500,600))
  21.     println(q6)
  22.     q1.++=(List(1000,40000))
  23.     println(q1)
  24.     q1.enqueue(300)
  25.     println(q1)
  26.     //删除元素
  27.     q1.dequeue()
  28.     println(q1)
  29.     q1.dequeueAll(x=>x%2==0)
  30.     println(q1)
  31.     //获取元素
  32.     println(q1(0))
  33.     //修改元素
  34.     q1(0)=300
  35.     println(q1)
  36.   }
  38. }