$04[Scala(集合)上]

最新推荐文章于 2024-07-26 16:01:19 发布
最新推荐文章于 2024-07-26 16:01:19 发布
阅读量78 收藏
点赞数
分类专栏： # scala语法 文章标签： scala 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52210776/article/details/125706227
版权

第一章.集合

1.不可变数组的创建

package com.atguigu.chapter07

object $01_ImmutableArray {
  /**
   * 不可变数组的创建(不可变集合,就是指该集合对象不可修改,每次修改就会返回一个新对象,而不会对原对象进行修改)
   *    1.通过new的方式: new Array[元素类型](数组长度)
   *    2.通过apply方法: Array[元素类型](初始元素,....)
   *
   * 集合添加,删除的通用方法的区别
   *    a.带+与带-的区别:
   *       带+是添加元素
   *       带-是删除元素
   *    b.一个+/-与两个+/-的区别
   *       一个+/-是添加/删除单个元素
   *       两个+/-是添加/删除一个指定集合中的所有元素
   *    c.冒号在前与冒号在后以及不带冒号的区别
   *       冒号在前是将元素添加到集合最后面
   *       冒号在后是将元素添加到集合最前面
   *       不带冒号将元素添加到集合最后面
   *    d.带=与不带=的区别
   *       带=是修改集合本身
   *       不带=是生成新集合,原集合没有改变
   *    e.updated与update的区别
   *       updated是生成一个新集合
   *       update是修改原集合
   */
  def main(args:Array[String]):Unit={
    //1.通过new的方式:new Array[元素类型](数组长度)
    val arr = new Array[Int](5)
    println(arr.toList)
    //2.通过apply方法:Array[元素类型](初始元素 )
    val arr2 = Array[Int](10,2,3,6,5)
    println(arr2.toList)
    //添加元素
    //添加单个元素
    val arr3 = arr2.:+(20)
    println(arr2.toList)
    println(arr3.toList)
    println(arr2.eq(arr3))
    //添加一个集合所有元素
    val arr5 = arr2.++(Array(100, 300, 200))
    println(arr5.toList)
    println(arr2.toList)

    val arr6 = arr2.++:(Array(500, 700, 200))
    println(arr6.toList)
    //删除元素

    //获取元素
    println(arr6(0))
    //修改元素
    arr6(0) = 1000
    println(arr6.toList)
    //遍历
    for (elem <- arr6) {
      println(elem)
    }
    //不可变转可变
    val arr7 = arr6.toBuffer
    println(arr7)
  }

}

2.可变数组的创建

package com.atguigu.chapter07

import scala.collection.mutable.ArrayBuffer

object $02_MutableArray {
  /**
   * 创建可变数组(可变数组,就是这个集合可以直接对原对象进行修改,而不会返回新的对象)
   *    1.通过new方式: new ArrayBuffer[元素类型]()
   *    2.通过apply方法: ArrayBuffer[元素类型](初始元素,...)
   */
  def main(args: Array[String]): Unit = {
    //1.通过new的方式: new ArrayBuffer[元素类型]()
    val arr = new ArrayBuffer[Int]()
    println(arr)
    //2.通过apply方法:ArrayBuffer[元素类型](初始元素,....)
    val arr2 = ArrayBuffer[Int](10, 2, 5, 3, 7, 9)
    println(arr2)
    //添加元素
    val arr3 = arr2.+:(20)
    println(arr2)
    println(arr3)
    val arr4 = arr2.:+(30)
    println(arr4)
    arr2.+=(40)
    println(arr2)
    arr2.+=:(50)
    println(arr2)
    val arr5 = arr2.++(Array(100, 200, 300))
    println(arr5)
    println(arr2)
    val arr6 = arr2.++:(Array(400, 500, 600))
    println(arr6)
    arr2.++=(Array(100,250,305,305))
    println(arr2)
    arr2.++=:(Array(505,605,705))
    println(arr2)
    //删除
    val arr7 = arr2.-(305)
    println(arr2)
    println(arr7)
    arr2.-=(305)
    println(arr2)
    arr2.--=(Array(605,50,10,2))
    println(arr2)
    //获取元素
    println(arr2(0))
    //修改元素
    arr2(0)=1000
    println(arr2)
    //遍历
    for (elem <- arr2) {
      println(s"elem=${elem}")
    }
    //可变转不可变
    val arr10 = arr2.toArray
    println(arr10.toList)
    //多维数组
    val arr11 = Array.ofDim[Int](3, 4)
    println(arr11.size)
    println(arr11(0).size)
  }

}

3.不可变List创建

package com.atguigu.chapter07

object $03_ImmutableList {
  /**
   * 不可变List创建
   *    1.通过apply方法: List[元素类型]{初始元素,.....}
   *    2.通过::方法创建: 初始元素::初始元素::...::Nil/不可变List
   *      Nil就是空的不可变List,Nil与不可变List关系类似Null与String的关系,Nil一般用于给不可变list赋予初始值,在赋予初始值的
   *      时候必须定义变量类型
   *    添加元素:
   *    ::是添加单个元素,是生成一个新集合,原集合没有改变
   *    :::是添加一个集合所有元素,是生成一个新集合,原集合没有改变
   *
   */
  def main(args: Array[String]): Unit = {
    //1.通过apply方法:List[元素类型](初始元素)
    val list1 = List[Int](1, 4, 3, 2, 7, 9)
    println(list1)
    //2.通过::方法创建:初始元素::初始元素::...::Nil/不可变List
    val list2 = 1 :: 2::3::6::Nil
    println(list2)

    var list3:List[Int]=Nil
    println(list3)
    //添加元素
    val list4 = list2.:+(10)
    println(list4)
    val list5 = list2.+:(20)
    println(list5)
    val list6 = list2.::(30)
    println(list6)
    val list7 = list2.++(Array(100, 300, 200))
    println(list7)
    val list8 = list2.++:(List(100, 300, 200))
    println(list8)
    val list9 = list2.:::(List(5050, 405))
    println(list9)

    //删除元素

    //获取元素
    println(list9(0))
    //修改元素
    //list9(0)=1000
    //println(list9)
    val list10 = list9.updated(0, 1000)
    println(list10)
  }
}

4.可变List创建

package com.atguigu.chapter07

import scala.collection.mutable.ListBuffer

object $04_MutableList {
  /**
   * 可变List 的创建
   *    1.通过apply方法: ListBuffer[元素类型](初始元素)
   *    2.通过new方式
   */
  def main(args: Array[String]): Unit = {
    //1.通过apply方法:ListBuffer[元素类型](初始元素,....)
    val list1 = ListBuffer[Int](1,4,2,7,9)
    println(list1)
    //2.通过new方式: new ListBuffer[元素类型]()
    val list2 = new ListBuffer[Int]()
    println(list2)
    //添加元素
    val list3 = list1.+:(10)
    println(list3)
    val list4 = list1.:+(20)
    println(list4)
    list1.+=(40)
    println(list1)
    list1.+=:(50)
    println(list1)
    //在指定角标位置插入元素
    list1.insert(1,10,20,30)
    println(list1)
    //删除元素
    list1.remove(1,3)
    println(list1)

    val list5 = list1.-(50)
    println(list5)
    list1.-=(50)
    println(list1)
    val list6 = list1.--(List(1,2,7))
    println(list6)
    println(list1)
    list1.--=(List(1,2,7))
    println(list1)

    //获取元素
    println(list1(0))
    //修改元素
    list1(0)=100
    println(list1)
    list1.update(1,90)
    println(list1)
    val list11 = list1.updated(2,4)
    println(list1)
    println(list11)
  }

}

5.不可变set创建

package com.atguigu.chapter07

object $05_ImmutableSet {
  /**
   * 不可变set的创建
   *     通过apply方法: Set[元素类型](初始元素,...)
   *     set的特性:不重复,无序
   */
  def main(args: Array[String]): Unit = {
    //通过apply方法:Set[元素类型](初始元素,....)
    val set1= Set[Int](1,2,5,3,1,9,10)
    println(set1)
    //添加元素
    val set2 = set1.+(20)
    println(set2)
    val set3 = set1.++(List(100,300,200,700))
    val set4 = set1.++(List(100,300,200,700))
    println(set3)
    println(set4)

    var set10 = Set[Int](1,3,5,7,9)
    val set11 = set10
    println("-------------------------------")
    set10.+=(20)
    set10=set10.+(20)
    println(set10)
    println(set11.eq(set10))
    //删除元素
    val set5 = set1.-(10)
    println(set5)
    val set6 = set1.--(List(2,3,5))
    println(set6)
  }

}

6.可变set的创建

package com.atguigu.chapter07

import scala.collection.mutable

object $06_MutableSet {
  /**
   * 可变set的创建:
   *    通过apply方法的创建: mutable.Set[元素类型](初始元素,....)
   */
  def main(args: Array[String]): Unit = {
    //通过apply方法创建:mutable.Set[元素类型](初始元素,....)
    val set1 = mutable.Set[Int](10,20,30,40)
    //添加元素
    val set2 = set1.+(50)
    println(set2)
    set1.+=(60)
    println(set1)
    val set3 = set1.++(List(70,100,300,80))
    println(set3)
    val set4 = set1.++:(List(70,100,300,80))
    println(set4)
    set1.++=(List(500,700,200,300))
    println(set1)
    //删除元素
    val set6 = set1.-(60)
    println(set6)
    set1.-=(700)
    println(set1)
    set1.--=(List(500,200,300))
    println(set1)

    //获取元素
    //修改元素
    set1.update(500,true)
    println(set1)
    set1.update(60,false)
    println(set1)

  }

}

7.元组

package com.atguigu.chapter07

object $07_Tuple {
  /**
   * 元组的创建:
   *     1.通过()创建:(初始元素,初始元素,....)
   *     2.针对二元元组:K-> V
   *     scala中二元元组表示KV键值对
   * 元组最多只能存放22个元素
   * 元组一旦创建,元素和长度都不可改变
   * 元组获取元素:元组名._角标[元组的角标从1开始]
   */
  class Region(val name:String,val school:School)
  class School(val name:String,val student:Student)
  class Student(val name:String,val age:Int)
  def main(args: Array[String]): Unit = {
    //通过()创建:(初始元素,初始元素,....)
    val t1 = ("zhangsan",20,"shenzhen")
    val t2 = "lisi" -> 20
    println(t1)
    println(t2)
    println(t1._1)
    println(t1._2)
    println(t1._3)


    println("---------------------------")
    val list = List("1 zhangsan 20 shenzhen","2 lisi 30 beijing","3 wangwu 40 tianjin")
    val list2 = for(element<-list) yield {
      val arr = element.split(" ")
      (arr(0),arr(1),arr(2),arr(3))
    }
    println(list2)


    val list3 = List(
      new Region("宝安区1",new School("宝安中学1",new Student("张三1",21))),
      new Region("宝安区2",new School("宝安中学2",new Student("张三2",22))),
      new Region("宝安区3",new School("宝安中学3",new Student("张三3",23))),
      new Region("宝安区4",new School("宝安中学4",new Student("张三4",24)))
    )

    val list4 = for (elem <- list3) yield{
      (elem.name,(elem.school.name,(elem.school.student.name,elem.school.student.age)))

    }
    for (elem <- list4) {
      println(elem._2._2._1)
    }
  }

}

8.不可变map的创建

package com.atguigu.chapter07

object $08_ImmutableMap {
  /**
   * 不可变map的创建:
   *    通过apply方法: Map[k的类型,v的类型]((K,V), K->V)
   *    map获取value的值:getOrElse(key,默认值) [key如果在map中存在则返回value值,如果不存在则返回默认值]
   *    Option:提醒外部当前结果有可能为空需要处理
   *       Some:代表有值
   *       None:代表为空
   */
  def main(args: Array[String]): Unit = {
    //通过apply方法:Map[K的类型,V的类型]((K,V),K->V)
    val map = Map[String,Int]("zhangsan"->20,("lisi",30),"wangwu"->22)
    println(map)
    //添加元素
    val map2 = map.+("aa" -> 20)
    println(map2)
    val map3 = map.++(List("cc"->30,"ac"->40,"dc"->50))
    println(map3)
    val map4 = map.++:(List("cc"->30,"ac"->40,"dc"->50))
    println(map4)
    //删除元素
    val map5 = map.-("lisi")
    println(map5)
    val map6 = map4.--(List("dc","cc","ac"))
    println(map6)
    //修改元素
    val map7 = map.+("zhangsan"->200)
    println(map7)
    //map("zhangsan")=1000
    //println(map)
    val map8 = map.updated("lisi",1000)
    println(map8)
    //获取元素
    // println(map("lisi_1"))
    println(map.get("lisi").get)
    //println(map.get("lisi_1"))
    println(map.getOrElse("lisi_1", -1))

    //获取所有的key
    println(map.keySet)
    //获取所有的value
    println(map.values)
    for (elem <- map) {
      println(elem)
    }
  }

}

9.可变map的创建

package com.atguigu.chapter07

import scala.collection.mutable

object $09_MutableMap {

  /**
   * 可变Map的创建: mutable.Map[K的类型,V的类型](K->V,(K,V),...)
   */
  def main(args: Array[String]): Unit = {
    val map = mutable.Map[String, Int]("aa" -> 10, "cc" -> 20, "dd" -> 30, "ac" -> 40)
    println(map)
    //添加元素
    val map2 = map.+("tt"->60)
    println(map2)
    map.+=("pp"->70)
    println(map)
    val map3 = map.++(List("cd"->100,"ce"->200,"fc"->300))
    println(map3)
    val map4 = map.++:(List("cd"->100,"ce"->200,"fc"->300))
    println(map4)
    map.++=(List("yy"->20,"oo"->30))
    println(map)
    map.put("hello",30)
    println(map)
    //删除元素
    val map5 = map.-("hello")
    println(map5)
    map.-=("oo")
    println(map)
    val map6 = map.--(List("yy","dd","hello"))
    println(map6)
    map.--=(List("pp","cc","hello"))
    println(map)
    map.remove("yy")
    println(map)
    //获取元素
    println(map.getOrElse("dd", -1))
    println(map.keys)
    println(map.values)
    //修改元素
    map("dc")=300
    println(map)
    map.update("pp",100)
    println(map)
  }

}

10.不可变队列的创建

package com.atguigu.chapter07

import scala.collection.immutable.Queue

object $10_ImmutableQuene {
  //不可变队列的创建: Queue[元素类型](初始元素,...)
  def main(args: Array[String]): Unit = {
    //创建队列
    val queue = Queue[Int](10,3,2,6,8,9)
    println(queue)
    //添加元素
    val queue2 = queue.+:(20)
    println(queue2)
    val queue3 = queue.:+(20)
    println(queue3)
    val queue4 = queue.++(List(100,200,400,300))
    println(queue4)
    val queue5 = queue.++:(List(100,200,400,300))
    println(queue5)
    val queue6 = queue.enqueue(50)
    println(queue6)
    //删除元素
    val queue7 = queue.dequeue
    println(queue7)
    //获取元素
    println(queue(0))
    //修改元素
    val queue10 = queue.updated(1,100)
    println(queue10)
  }

}

11.可变队列的创建

package com.atguigu.chapter07

import scala.collection.mutable

object $11_MutableQueue {
  //可变队列的创建:mutable.Queue[元素类型](初始元素,....)
  def main(args: Array[String]): Unit = {
    val q1 = mutable.Queue[Int](10,3,2,7,9,4)
    //添加元素
    val q2 = q1.:+(30)
    println(q2)
    val q3 = q1.+:(40)
    println(q3)
    q1.+=(50)
    println(q1)
    q1.+=:(60)
    println(q1)
    val q4 = q1.++(List(100,300,200))
    println(q4)
    val q6 = q1.++:(List(400,500,600))
    println(q6)
    q1.++=(List(1000,40000))
    println(q1)
    q1.enqueue(300)
    println(q1)
    //删除元素
    q1.dequeue()
    println(q1)
    q1.dequeueAll(x=>x%2==0)
    println(q1)
    //获取元素
    println(q1(0))
    //修改元素
    q1(0)=300
    println(q1)
  }

}
ly的学习笔记
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
scala的集合类型
Oak_Komorebi的博客
08-03 1383
一、集合类型 集合是⼀种用来存储各种对象和数据的容器。Scala 集合分为可变的和不可变的集合。 1. 不可变集合可以安全的并发访问。 2. 可变集合可以在适当的地⽅被更新或扩展。这意味着你可以修改，添加，移除⼀个集合的元素。 Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质，意味着 集合的基本特点是⽀持迭代遍历的。 scala集合两个主要的包： # 不可变集合 scala.collection.immutable (Scala默认采用.
Scala 数组集合
01-07
Scala 常用数组集合简单总结 数组 Array-数组 //伴⽣对象创建数组 var a1=Array(1,2,3,5,4) //创建⻓度为5的数组，所有值都是0 var a2=new Array[Int](5) //获取⻓度 a1.length a2.size //修改 a1(1) = -1 a1.update...
$04[SparkCore(transformation转换算子)下]
m0_52210776的博客
07-11 52
2.groupByKey 3.reduceByKey 图解: 图解 图解
浏览器开发者工具，选中dom元素之后，在控制台使用$0-$4分别指代最近选中的5个html元素
qq_17335549的博客
12-24 651
浏览器开发者工具，选中dom元素之后，在控制台使用$0-$4分别指代最近选中的5个html元素
scala集合
weixin_53898747的博客
04-03 917
scala集合
Scala集合
qq_45041581的博客
06-05 743
Scala集合/入门
Scala——集合
qq_42873479的博客
03-23 2808
Scala——集合7 集合7.1 集合简介7.2 数组7.3 列表List7.4 Set集合7.5 Map集合7.6 元组7.7 集合常用函数7.8 队列7.9 并行集合 7 集合 7.1 集合简介 集合简介： （1）Scala 的集合有三大类：序列 Seq、集 Set、映射 Map，所有的集合都扩展自 Iterable特质。 （2）对于几乎所有的集合类，Scala 都同时提供了可变和不可变的版本，分别位于以下两个包 不可变集合：scala.collection.immutable 可变集合： scala.
Scala集合常用函数超详细
热门推荐
楚生辉的博客
09-29 1万+
大家好，我是楚生辉，在未来的日子里我们一起来学习Scala相关的技术，一起努力奋斗，遇见更好的自己！Scala是一门的编程语言，一种类似的编程语言，设计初衷是实现可伸缩的语言 、并集成和的各种特性。今天着重分享一下集合常用函数相关知识，有需要的小伙伴可以自行获取与学习~
Scala之集合
lslslslslss的博客
01-22 1109
一、集合简介 （1）Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质。 （2）对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本，分别位于以下两个包。 不可变集合：scala.collection.immutable 可变集合： scala.collection.mutable （3）不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而不会对原对象进行修改。类似于java中的String对象 （4）可变集合，就是这个.
scala集合添加元素
cx201125的博客
03-09 1355
val list = List(1,2,3) // :: 用于的是向队列的头部追加数据,产生新的列表, x::list,x就会添加到list的头部 println(4 :: list) //输出: List(4, 1, 2, 3) // .:: 这个是list的一个方法;作用和上面的一样,把元素添加到头部位置; list.::(x); println( list.:: (5)) //输出: List(5, 1, 2, 3) // :+ 用于在list尾部追加元素;
Scala集合练习
weixin_45536884的博客
12-05 582
object Homework_Scala_03 { def main(args: Array[String]): Unit = { //1.创建一个List(3,2,4,6,7,5,1,0,9,8) val list: List[Int] = List(3,2,4,6,7,5,1,0,9,8) println("创建的集合为："+list) //2.将list中...
头歌Scala中集合的使用
04-13
Scala中集合的使用 大学生 1. List 列表的使用 2. Set 集合的使用 3.Map 映射的使用 4. 元组的使用
Scala 集合数据操作示例
11-13
map[B](f: (A) ? B): List[B] 定义一个变换,把该变换应用到列表的每个元素中,原列表不变，返回一个新的列表数据
Scala集合类型.md
08-07
Scala集合类型.md
Scala-part2集合框架
11-13
快速掌握集合，Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质 在Scala中集合有可变（mutable）和不可变（immutable）两种类型
Scala学习笔记20: Future 和Promise
最新发布
Taerge0110的博客
07-26 276
在 Scala 中, `Future` 和 `Promise` 是用于处理异步操作的强大工具 ; 它们就像一对搭档, 协同工作, 优雅地管理着那些需要花费时间的任务 .
探索Perl的图形用户界面开发：工具、技巧与实践
2402_85762143的博客
07-23 1126
Perl的GUI开发提供了多种工具和方法，允许开发者根据项目需求和个人偏好选择合适的工具包。通过遵循最佳实践和利用Perl的强大功能，开发者可以创建出既美观又实用的GUI应用程序。随着技术的不断发展，Perl社区也在不断推出新的工具和库，以支持更高效、更现代的GUI开发。本文只是一个入门指南，深入学习Perl GUI开发还需要阅读更多的文档、参与社区讨论和实践项目。希望本文能为你的Perl GUI开发之旅提供一些帮助和启发。
Spark实时（三）：Structured Streaming入门案例
Lansonli（蓝深李）的博客
07-24 652
我们使用Structured Streaming来监控socket数据统计WordCount。
探索Perl的奇妙世界：入门学习与实战指南
sinner小屋
07-25 1411
《探索Perl的奇妙世界：入门学习与实战指南》为大家提供了一个全面的Perl编程学习路径，从基础知识到高级技巧，涵盖了Perl在Web开发、数据库操作和生物信息学中的实际应用。通过详实的代码案例和实战演练，本书帮助大家深入理解Perl的强大功能和灵活性。同时，文中还探讨了Perl的优势与局限，以及其在未来的发展潜力，适合所有希望提升Perl编程技能的读者。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值