scala中的集合框架

最新推荐文章于 2021-06-01 14:11:05 发布
置顶 最新推荐文章于 2021-06-01 14:11:05 发布
阅读量773 收藏
点赞数 3
分类专栏： 陶笔记 文章标签： scala的集合框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43006059/article/details/83411764
版权

Scala的集合框架
Scala把集合框架分为3种：
1.序列:Seq
2.集：Set
3.映射：Map iterable
每一个集合都有两个包：根据包进行区别可变和不可变
1.不可变集合 scala.collection.immutable 默认的，不需要导入的
2.可变集合 scala.collecion.mutable.*
重点：元组,数组 ,List,Map,Set
元组 非常灵活
可以存储不同类型的参数
1.元组使用（）封装
(1)如何创建：new Tuple(n)
(2)n:元组中存储元素的个数，但是最多只能存储22个
(3)元组下标从1开始
(4)元组的取值
①例如val tp2=new Tuple3(1,”哈哈”,2.4)
②取值：tp2._1（1），tp2._2（哈哈），tp2._3（2.4）
2.对偶元组：一种特殊的元组
例如：val tup2=(“name”,20)
Map(k,v)中的每一个元素，就是对偶元组
元组的元素交换：tup2.swap
3.拉链操作：zip zipWithIndex
例如：

scala> val teacher=Array("haiyuan","lichen","shilaoshi")
teacher: Array[String] = Array(haiyuan, lichen, shilaoshi)

scala> val tizhong=Array(100,300,200,120)
tizhong: Array[Int] = Array(100, 300, 200, 120)

scala> val nameAndtizhong=teacher.zip(tizhong)
nameAndtizhong: Array[(String, Int)] = Array((haiyuan,100), (lichen,300), (shilaoshi,200))
scala> nameAndtizhong.zipWithIndex
res8: Array[((String, Int), Int)] = Array(((haiyuan,100),0), ((lichen,300),1), ((shilaoshi,200),2))
嵌套的对偶元组

4.取嵌套三组中的元素

scala> val teacher=Array("haiyuan","lichen","shiguangxin")
teacher: Array[String] = Array(haiyuan, lichen, shiguangxin)

scala> val weight=Array(100,180,150,120)
weight: Array[Int] = Array(100, 180, 150, 120)

scala> val nameAndWeight=teacher.zip(weight)
nameAndWeight: Array[(String, Int)] = Array((haiyuan,100), (lichen,180), (shiguangxin,150))

scala> nameAndWeight.zipWithIndex
res0: Array[((String, Int), Int)] = Array(((haiyuan,100),0), ((lichen,180),1), ((shiguangxin,150),2))
//取Array中的第一个
scala> res0(0)
res2: ((String, Int), Int) = ((haiyuan,100),0)

//取嵌套元组中的第一个
scala> res2._1
res3: (String, Int) = (haiyuan,100)

//取元组的第一个元素
scala> res3._1
res6: String = haiyuan

数组
数组综述：
1.不可变数组：Array:长度不可变，内容可以变化
2.可变数组：
(1)ArrayBuffer:长度和内容都可以变化
(2)导包：scala.collection.mutable.ArrayBuffer

数组的定义方式
Array
1.Val arr:Array[Double]=Array(11.2,3.2)
(1)取值：arr(0)
(2)赋值：arr(0)=10.0
①赋值已有的元素，元素会被覆盖
2.Val arr2:Array[Int]=new ArrayInt

scala> val arr=new Array(4)
arr: Array[Nothing] = Array(null, null, null, null)

注意：
1.Nothing是报错的标识
2.Null是空的意思

ArrayBuffer（ArrayBuffer:必须导包）

scala>import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer

//arrayBuffer添加或者删除元素：
scala> val arr=ArrayBuffer(1,2,3,4,7,8)
arr: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 7, 8)

scala>arr+=5
res7: arr.type = ArrayBuffer(1, 2, 3, 4, 7, 8, 5)

scala> arr++=Array(6,9)
res8: arr.type = ArrayBuffer(1, 2, 3, 4, 7, 8, 5, 6, 9)

scala> arr-=5
res9: arr.type = ArrayBuffer(1, 2, 3, 4, 7, 8, 6, 9)

scala>arr--=Array(6,8)
res10: arr.type = ArrayBuffer(1, 2, 3, 4, 7, 9)

//插入元素：insert(n:Int,m:Int*)
//插入元素的时候，插入在指定索引的前面
scala>res10.insert(5,6)

scala>res10
res13: arr.type = ArrayBuffer(1, 2, 3, 4, 7, 6, 9)

//移除元素：remove(n:Int,m:Int)
//移除元素是指定索引后几位数字
scala>res13.remove(2,3)

scala>res13
res15: arr.type = ArrayBuffer(1, 2, 6, 9)

//清空数组：clear
scala> res13.clear

scala>res13
res18: arr.type = ArrayBuffer()

//判断是否为空：isEmpty
scala> res13.isEmpty
res19: Boolean = true

scala>ab1.in注意需要按Tab，而不是Enter
indexOf   indexOfSlice   indexWhere   indices   init   inits   insert   insertAll   intersect

数组常用的方法
Max:最大值
Min:最小值
Sum:求和
Sorted:排序
Reverse:反转

scala> ab1.max
res29: Int = 5

scala> ab1.min
res30: Int = 2

scala>ab1.sum
res31: Int = 13

scala> ab1.sorted
res32: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(2, 3, 3, 5)

scala> ab1.sorted.reverse
res33: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(5, 3, 3, 2)

List
1.不可变List:长度和内容都不可变，默认的
2.可变的List:
(1)ListBuffer长度和内容都可变
(2)导包：scala.collection.mutable.ListBuffer

不可变的List

//定义方式：
scala> val list=List[Int](1,2,3,6,7)
list: List[Int] = List(1, 2, 3, 6, 7)

scala> val list1=6::4::8::Nil
list1: List[Int] = List(6, 4, 8)
3.：：Nil是组成List的两个单位
Nil代表空列表
scala> List[Int]()==Nil
res1: Boolean = true
4.：：方法（添加元素放在首位）
scala> 5::list
res2: List[Int] = List(5, 1, 2, 3, 6, 7)

可变的ListBuffer

//定义方式

scala> import scala.collection.mutable.ListBuffer
import scala.collection.mutable.ListBuffer

scala> val list1=ListBuffer[Int](1,2,3)
list1: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3)

//集合基本操作
+=
++=
-+
–+
Insert
Remove
Clear
isEmpty

scala>list1+=13
res3: list1.type = ListBuffer(1, 2, 3, 13)

scala> list1++=List(12,4,5,6)
res6: list1.type = ListBuffer(1, 2, 3, 13, 12, 4, 5, 6)

scala> list1.insert(7)

scala>list1
res9: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 13, 12, 4, 5, 6)

scala>list1.remove(1)
res10: Int = 2

scala>list1.clear

scala> list1
res14: scala.collection.mutable.ListBuffer[Int] = ListBuffer()

集合间的转换
可变List:
1.通过toList（）方法，转换为不可变的List
2.toBuffer 可以转化为ArrayBuffer
注意：转换后，是新的集合，不是之前的那个集合
scala> list1.toList
res20: List[Int] = List(12, 11, 1, 2)

scala>* list1.toBuffer
res21: scala.collection.mutable.Buffer[Int] = ArrayBuffer(12, 11, 1, 2)

头元素和尾元素
1.一个List元素，分为两部分：头元素（head）+尾元素（tail）
2.头元素：第一个元素
3.尾元素：除了第一个元素的其他元素都是尾元素

scala> val list=List(1,3,4,6,7)
list: List[Int] = List(1, 3, 4, 6, 7)

scala> list.head
res22: Int = 1

scala> list.tail
res23: List[Int] = List(3, 4, 6, 7)

scala> res23.tail
res24: List[Int] = List(4, 6, 7)

scala> res23.tail.tail
res25: List[Int] = List(6, 7)

Map
1.不可变的Map，默认的
2.可变的Map,导包：scala.collection.mutiable.Map
3.Map中存在的元素，都是对偶元素
4.Key是唯一的

不可变map

 def main(args: Array[String]): Unit = {
  //    定义形式
  val mp: Map[String, Int] = Map[String, Int]("haiyuan" -> 100, "lichen" -> 300)
  val mp2: mutable.HashMap[String, Int] = new mutable.HashMap[String, Int]()
  //    两个map能和并吗？
  val MP3 = mp ++ mp2
  //    取值，跟据k取V
  val m1: Option[Int] = mp.get("haiyuan")
  //    option some (有值) None(取不到值)
  //    println(mp.get("haiyuan1"))
  val else1: Int = mp.getOrElse("haiyuan1", 100)
  println(else1)
}

可变map（导包）

def main(args: Array[String]): Unit = {
    import scala.collection.mutable.Map
    import scala.collection.mutable.HashMap
    val mmp: mutable.Map[String, Int] = Map[String, Int]()
    //    如何添加元素
    val mmp3: Option[Int] = mmp.put("haiyuan", 100)
    //    还能如何添加
    mmp += ("chuanwang" -> 99)
    //    一下添加两个元素
    mmp += (("lichen", 300), ("shilaoshi", 120))
  }
}

Map迭代key和value

def main(args: Array[String]): Unit = {
  val mp1: Map[String, Int] = Map[String, Int]("haiyuan" -> 120, "licheng" -> 175, "huahua" -> 88)
  for (i <- mp1) {
    println(i._1, i._2)
    println(i._1)
    println(i._2)
  }

  for ((k, v) <- mp1) {
    println(k, v)
    println(k)
    println(v)
  }

  for ((k, _) <- mp1) {
    println(k)
  }

  for ((_, v) <- mp1) {
    println(v)
  }

  val ks: Iterator[String] = mp1.keysIterator
  //如何遍历
  while (ks.hasNext) {
    println(ks.next())
  }
  //还能怎么做
  mp1.foreach(println)

  ks.foreach(println)

  //迭代v
  val values: Iterable[Int] = mp1.values
  //遍历方式
  values.foreach(println)
}

Set
集合，元素不能重复
1.不可变，长度，内容都不可变
2.可变：
(1)长度，内容都可变
(2)导包：scala.collection.mutable.Set
不可变set

scala> val set=Set(1,2,3,3,4,2,4,5)
set: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)

可变set

scala> import scala.collection.mutable.Set
import scala.collection.mutable.Set

scala> val set=Set[Int](10)
set: scala.collection.mutable.Set[Int] = Set(10)

scala> set+=12
res26: set.type = Set(12, 10)

scala> set+=11
res27: set.type = Set(12, 10, 11)

//不重复
scala> set+=11
res28: set.type = Set(12, 10, 11)

scala> set+=(11,23,45)
res29: set.type = Set(12, 45, 10, 11, 23)

scala> set++=Set(111,222)
res31: set.type = Set(12, 45, 222, 111, 10, 11, 23)

scala> set.remove(11)
res32: Boolean = true

scala> set.remove(1)
res33: Boolean = false

scala> set.head
res36: Int = 12

scala> set.tail
res37: scala.collection.mutable.Set[Int] = Set(45, 222, 111, 10, 23)

scala> set.foreach(println)
12
45
222
111
10
23

//set本身用的不多，但是我们要去重的时候，就可以用到
scala> val list=List(11,22,33,11,22,12,123,123,444)
list: List[Int] = List(11, 22, 33, 11, 22, 12, 123, 123, 444)

scala> val list1=list.toSet
list1: scala.collection.immutable.Set[Int] = Set(33, 444, 22, 12, 123, 11)

scala> list1.toList
res40: List[Int] = List(33, 444, 22, 12, 123, 11)

运算符重载的方法

scala> 3+2
res42: Int = 5

scala> 2+(4)
res43: Int = 6

scala> 1.to(10)
res44: scala.collection.immutable.Range.Inclusive = Range 1 to 10

scala> val list=List(2,3,4,51,55)
list: List[Int] = List(2, 3, 4, 51, 55)

scala> list.head
res45: Int = 2

scala> list head
res47: Int = 2

scala> list.tail
res46: List[Int] = List(3, 4, 51, 55)
活出别致的高傲
关注
专栏目录
Scala整合Spring框架
Chaos的博客
05-19 627
Scala整合Spring框架 本文将介绍如何通过将优秀的编程语言Scala整合当今世界最为流行的框架Spring中。为了清楚地阐释Scala与Spring的整合原理，本文将使用一个简单的示例应用。 Scala近期正式发布了2.8版本，这门优秀的编程语言将简洁、清晰的语法与面向对象和函数式编程范式无缝融合起来，同时又完全兼容于Java，这样Scala就能使用Java开发者所熟知的Java API和众多的框架了。在这种情况下，我们可以通过Scala改进并简化现有的Java框架。此外，Scala的学习门..
Scala 框架
11-15
Scala框架，光宇play的框架，这个只是一个模板，需要的自己下载
Scala之集合框架
tangshiweibbs的专栏
04-09 828
package com.uplooking.bigdata.p3   /**   * 集合框架   * 1、Scala中的集合体系主要包括：Iterable、Seq（IndexSeq）、Set（SortedSet）、   * Map（SortedMap）。其中Iterable是所有集合trait的根trait。实际上Seq、Set、和Map都是   * 子trait
Scala 集合框架
weixin_40578689的博客
12-04 254
scala中的集合分为三类:Seq(序列),Set(集),Map(映射),三者都扩展自Iterable. 每一类集合，都可以分为两个种类。 不可变集合， scala.collection.immutable._   默认使用,不需要导包. 可变集合， scala.collection.mutable._          需要手动导入包,才能使用. 分别属于不同的包。 Array 也是一...
Scala 集合类
lantian0802的专栏
05-22 1055
这个章节的内容包含 基本数据结构 List Set Tuple Maps 函数组合器 map foreach filter zip partition find drop and dropWhile foldRight and foldLeft flatten flatMap 广义的函数组合器 如何处理好Map? 基
scala集合框架
Internation985的博客
08-21 387
课程目标， scala的集合框架 元组 数组 List集合 Map集合 Set集合 集合上的常用方法 什么是scala集合框架 2.1scala集合框架分为三大类；序列seq 集合set 映射Map Such as： Seq是列表，适合存有序重复数据，进行快速插入/删除元素等场景 Set是集合，适合存无序非重复数据，进行快速查找海量元素等场景 总之，最大的区别不在语言实现上，而是数据结构的使用上 2.2集合主要有两个类型，可变和不可变类型(val var) 默认情况下都是不可变集合，如果需要可变
Scala-part2集合框架
11-13
Scala集合框架的设计使得开发者可以根据具体需求选择最合适的集合类型。不可变集合适用于不需要修改的场景，而可变集合则适用于需要频繁修改的场景。理解不同集合类型之间的差异和特性有助于编写更高效、更安全的...
Scala集合框架详解：数组、列表和映射
- 不可变性：Scala的集合框架中，大部分集合类都是不可变的，即一旦创建便不能修改，这种设计能够避免并发访问带来的竞态条件。 - 统一接口：Scala的集合框架提供了统一的集合接口，使得不同类型的集合能够以相同的...
Scala集合（二）Java开发Java经验技巧共10页
最新发布
11-22
1. Scala集合框架：介绍Scala集合库的基本结构，如Seq、Set、Map等，以及它们与Java集合的区别。 2. 高级特性：可能涉及函数式编程的概念，如高阶函数、惰性求值和不可变性，以及这些特性如何在Scala集合中实现。 3....
Scala集合框架详解：List、Set和Map的使用与性能分析
本文旨在全面介绍Scala集合框架中List、Set和Map的使用方法，并对它们的性能进行详细分析和比较。通过阅读本文，读者将能够深入了解Scala集合框架的特点、常用操作，以及如何根据实际需求选择合适的集合类型。最后，...
scala函数式编程系列（五）--- scala集合框架
qq_824203453_的博客
07-08 5008
版权声明：本文为博主原创文章，未经博主允许不得转载!! 欢迎访问:https://blog.csdn.net/qq_21439395/article/details/80962530 交流QQ: 824203453   1. 集合框架 1.1.     集合综述 Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质 在Scala中集合有可...
scala集合框架图
知其然，知其所以然
03-01 1030
美图欣赏： 一.scala集合 所有的集合类都在包中发现scala.collection或它的子包中的一个mutable，immutable和generic 在三个变种通过客户端代码存在所需的大多数集合类，分别位于包分别。 scala.collection， scala.collection.immutable和scala.collection.mutable 每个变体在可变性方面都有不...
Scala框架选择
weixin_34025151的博客
08-16 204
为什么80%的码农都做不了架构师？>>> ...
Scala集合
06-01 215
Scala集合 Scala提供了一套很好的集合实现，提供了一些集合类型的抽象。 Scala 集合分为可变的和不可变的集合。 可变集合可以在适当的地方被更新或扩展。这意味着你可以修改，添加，移除一个集合的元素。 而不可变集合类，相比之下，永远不会改变。不过，你仍然可以模拟添加，移除或更新操作。但是这些操作将在每一种情况下都返回一个新的集合，同时使原来的集合不发生改变。 接下来我们将为大家介绍几种常用集合类型的应用： 序号 集合及描述 1 Scala List(列表) List
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

活出别致的高傲

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值