十八、Scala的Iterable、Seq、Set、Map集合

最新推荐文章于 2024-05-07 14:02:27 发布
最新推荐文章于 2024-05-07 14:02:27 发布
阅读量1.1k 收藏 2
点赞数 1
分类专栏： Scala 文章标签： scala 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Buluchacha/article/details/121078255
版权

Scala的Iterable、Seq、Set、Map集合

1. Iterable

1.1 概述

Iterable代表一个可以迭代的集合，它继承了Traversable特质，同时也是其他集合的父特质。最重要的是，它定义了获取迭代器(iterator)的方法：def iterator:Iterator[A] ，这是一个抽象方法，它的具体实现类需要实现这个方法，从而实现迭代的返回集合中的元素

1.2 分类

Traversable提供了两种遍历数据的方式：

  • iterator()方法：属于主动迭代，我们可以通过hasNext()检查是否还有元素，并且可以主动地调用next()方法获取元素，即我们可以自主地控制迭代过程
  • foreach()方法：属于被动迭代，我们只提供一个函数，并不能控制遍历的过程，即迭代过程是由集合本身控制的

1.3 遍历集合

示例：
在这里插入图片描述

object ClassDemo {
	def main(args:Array[String]):Unit = {
		//1.定义一个列表
		val list = (1 to 5).toList
		//2.通过iterator()方法遍历
		//2.1通过集合对象(list)来获取其对应的迭代器对象
		val it:Iterator[Int] = list.iterator
		//2.2判断是否还有下一个元素，因为不知道集合中有多少个元素，所以采用循环来实现
		while (it.hasNext) {
			//只要能走到这里，说明集合中有元素
			//2.3通过next()方法来获取指定的元素
			val num = it.next()
			println(num) 
		}
		
		//3.通过foreach()方法遍历
		//普通版
		list.foreach((x:Int) => println(x))

		//优化版
		list.foreach(println(_))
	}
}
//1
//2
//3
//4
//5

1.4 分组遍历

如果遇到将Iterable对象中的元素分成固定大小的组，然后遍历这种需求，就可以通过grouped()方法实现。

格式：

def grouped(size:Int):Iterator[Iterable[A]]

示例：
在这里插入图片描述

object ClassDemo {
	def main(args:Array[String]):Unit = {
		//1.定义一个Iterable集合
		val list = (1 to 13).toIterable
		
		//2.对Iterable集合分组
		//方式一：合并版（推荐）
		//2.1获取迭代器对象
		val it = list.grouped(5)
		//2.2判断迭代器中是否有元素
		while (it.hasNext) {
			//2.3如果有，则获取元素，并打印
			val result = it.next()
			println(result)
		}

		//方式二：分解版
		//第一次获取
		val b1 = it.hasNext
		if (b1) {
			val.result1 = it.next()
			println(b1, result1) //(true, Vecotr(1,2,3,4,5))
		//第二次获取
		val b2 = it.hasNext
		if (b2) {
			val.result2 = it.next()
			println(b2, result2) //(true, Vecotr(6,7,8,9,10))
		//第三次获取
		val b3 = it.hasNext
		if (b3) {
			val.result3 = it.next()
			println(b3, result3) //(true, Vecotr(11,12,13))
		}
		
	}
}
//Vecotr(1,2,3,4,5)
//Vecotr(6,7,8,9,10)
//Vecotr(11,12,13)

1.5 按照索引生成元组

Iterable集合中存储的每个元素都是有索引的，如果我们想按照元素 -> 索引这种格式，生成一个新的集合，此时需要用到zipWithIndex()方法。

示例：
在这里插入图片描述

object ClassDemo {
	def main(args:Array[String]):Unit = {
		//1.定义一个Iterable集合
		val list1 = Iterable("A", "B", "C", "D", "E")
		
		//2.通过zipWithIndex()方法，按字符串->索引这种格式，生成新的集合
		val list2:Iterable[(String, Int)] = list1.zipWithIndex

		//3.重新按照 索引->字符串这种格式，生成新的集合
		val list3:Iterable[(Int, String)] = list2.map(x => x._2 -> x._1)
		
		//4.打印结果
		list3.foreach(println(_))
	}
}
//(0,A)
//(1,B)
//(2,C)
//(3,D)
//(4,E)

1.6 判断集合是否相同

有时，我们不仅想判断两个集合中的元素是否全部相同，而且要求这两个集合元素的迭代顺序保持一致，此时用sameElements()方式实现

示例：
在这里插入图片描述

object ClassDemo {
	def main(args:Array[String]):Unit = {
		//1.定义一个Iterable集合
		val list1 = Iterable("A", "B", "C")
		
		//2.通过sameElements()方法，判断list1和Iterable("A", "B", "C")集合是否相同
		println(list1.sameElements(Iterable("A", "B", "C"))) //true

		//3.通过sameElements()方法，判断list1和Iterable("A", "C", "B")集合是否相同
		println(list1.sameElements(Iterable("A", "C", "B"))) //false
		
		//4.通过sameElements()方法，判断list1和list2是否相同
		val list2 = Iterable("A", "B", "C", "D")
		println(list1.sameElements(list2))) //false
	}
}
//

2. Seq

2.1 概述

Seq特质代表按照一定顺序排列的元素序列，序列是一种特别的可迭代集合，它的元素特点是有序（元素存取顺序一致），可重复，有索引

2.2 分类

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.3 创建Seq集合

示例：
在这里插入图片描述

object ClassDemo {
	def main(args:Array[String]):Unit = {
		val s1 = (1 to 5).toSeq
		print(s1)
	}
}
//Range(1,2,3,4,5)

2.4 获取长度及元素

因为Seq集合的每个元素都是有索引的，所以我们可以通过索引直接获取其对应的元素，而且通过length()或size()方法获取集合的长度

示例：
在这里插入图片描述

object ClassDemo {
	def main(args:Array[String]):Unit = {
		val s1 = (1 to 5).toSeq
		//打印长度
		println(s1.length, s1.size) //(5, 5)
		//获取索引为2的元素
		//方式一：通过集合名(索引)的方式实现
		println(s1(2)) //3
		//方式二:通过集合的伴生对象的apply()方法实现
		println(s1.apply(2)) //3
	}
}

2.5 获取指定元素的索引值

格式：
在这里插入图片描述

示例：
在这里插入图片描述

object ClassDemo {
	def main(args:Array[String]):Unit = {
		val s1 = Seq(1, 2, 4, 6, 4, 3, 2)
		println(s1.indexOf(2)) //1
		println(s1.lastIndexOf(2)) //6
		println(s1.indexWhere(x => x < 5 && x % 2 == 0)) //1
		println(s1.indexWhere(x => x < 5 && x % 2 == 0, 2)) //4
		println(s1.lastIndexWhere(x => x < 5 && x % 2 == 0)) //6
		println(s1.indexOfSlice(Seq(1,2))) //0
		println(s1.indexOfSlice(Seq(1,2), 3)) //-1	
	}
}

2.6 判断是否包含指定数据

格式：
在这里插入图片描述

示例：
在这里插入图片描述

object ClassDemo {
	def main(args:Array[String]):Unit = {
		val s1 = (1 to 10).toSeq
		println(s1.startsWith(Seq(1,2))) //true
		println(s1.startsWith(Seq(1,3))) //false
		println(s1.endsWith(Seq(9,10))) //true
		println(s1.endsWith(Seq(8,9))) //false
		println(s1.contains(3) //true
		println(s1.containsSlice(Seq(1,2))) //true
		println(s1.containsSlice(Seq(1,3)))  //false	
	}
}

2.7 修改指定的元素

格式：
在这里插入图片描述

示例：
在这里插入图片描述

object ClassDemo {
	def main(args:Array[String]):Unit = {
		val s1 = (1 to 5).toSeq
		println(s1) //Range(1,2,3,4,5)
		
		val s2 = s1.update(2, 10)
		println(s2) //Vector(1,2,10,4,5)
		
		/*
			第一个参数：起始索引
			第二个参数：替换后的元素
			第三个参数：替换几个
		*/
		val s3 = s1.patch(1, Seq(10, 20), 3)
		println(s3) //Vector(1,10,20,5)
	}
}

3. Stack

3.1 概述

栈的元素特点是先进后出。由于历史原因，Scala当前的库中还包含一个immutable.Stack，但当前已标记为弃用，因为设计不优雅且性能不佳。因为栈设计大量元素的进出，常用的还是可变栈，例如mutable.Stack, mutable.ArrayStack

在这里插入图片描述

3.2 常用方法

在这里插入图片描述

3.3 演示Stack可变栈

示例：
在这里插入图片描述

import scala.collection.mutable

object ClassDemo {
	def main(args:Array[String]):Unit = {
		val s1 = mutable.Stack(1,2,3,4,5)
		println(s1) //Stack(1,2,3,4,5)
		
		println(s1.top) //1
		println(s1.push(6)) //Stack(6,1,2,3,4,5)
		println(s1.pushAll(Seq(11,22,33))) //Stack(33,22,11,6,1,2,3,4,5)
		println(s1.pop()) //33
		s1.clear()
		println(s1) //stack()
	}
}

3.4 演示ArrayStack可变栈

示例：
在这里插入图片描述

import scala.collection.mutable

object ClassDemo {
	def main(args:Array[String]):Unit = {
		val s1 = mutable.ArrayStack(1,2,3,4,5)
		println(s1) //ArrayStack(1,2,3,4,5)
		
		s1.dup()
		println(s1) //ArrayStack(1,1,2,3,4,5)
		s1.preserving({
			//当该方法中的内容执行完毕后，栈中的数据会恢复
			s1.clear()
			println('hi')
		}) //hi
		println(s1) //ArrayStack(1,2,3,4,5)
	}
}

4. Queue

4.1 概述

队列的元素特点是先进先出，常用的队列是可变队列：mutable.Queue，它内部是以MutableList数据结构实现的。

在这里插入图片描述

4.2 常用方法

在这里插入图片描述

示例：
在这里插入图片描述

import scala.collection.mutable

object ClassDemo {
	def main(args:Array[String]):Unit = {
		val q1 = mutable.Queue(1,2,3,4,5)
		println(q1) //Queue(1,2,3,4,5)
		
		q1.enqueue(6)
		println(q1) //Queue(1,2,3,4,5,6)
		q1.enqueue(7,8,9)
		println(q1) //Queue(1,2,3,4,5,6,7,8,9)
		println(q1.dequeue()) //1
		println(q1.dequeueFirst(_ % 2 != 0)) //Some(3)
		println(q1.dequeueAll(_ % 2 == 0)) //ArrayBuffer(2,4,6,8)
		println(q1) //Queue(5,7,9)
	}
}

5. Set

5.1 概述

Set集合中的元素不包含重复的元素

5.2 分类

在这里插入图片描述
示例：
在这里插入图片描述

import scala.collection.{SortedSet, mutable}

object ClassDemo {
	def main(args:Array[String]):Unit = {
		val s1 = SortedSet(1,4,3,2,5)
		println(s1) //TreeSet(1,2,3,4,5)
		
		val s2 = mutable.HashSet(1,4,3,2,5)
		println(s2) //Set(1,5,2,3,4)

		val s3 = mutale.LinkedHashSet(1,4,3,2,5)
		println(s3) //Set(1,4,3,2,5)
	}
}

6. Map

6.1 概述

Map表示映射，包含键值对的集合，基本操作类似于Set集合的操作。

6.2 分类

在这里插入图片描述
示例：
在这里插入图片描述

import scala.collection.{SortedSet, mutable}

object ClassDemo {
	def main(args:Array[String]):Unit = {
		val m1 = Map('A' -> 1, 'B' -> 2, 'C' -> 3)
		
		//遍历
		//方式一：通过普通for循环实现
		for((k,v) <- map) println(k,v)
		//(A,1)
		//(B,2)
		//(C,3)
		//方式二：通过foreach函数实现
		map.foreach(println(_))
		//(A,1)
		//(B,2)
		//(C,3)

		println(map.filterKeys(_ == 'B')) //Map(B -> 2)
	}
}

7. 案例：统计字符个数

需求：
在这里插入图片描述

步骤：
在这里插入图片描述

import scala.collection.mutable
import scala.io.StdIn

object ClassDemo {
	def main(args:Array[String]):Unit = {
		//1.提示用户录入字符串，并接收
		println('请录入一个字符串：')
		val str = StdIn.readLine()
		//2.定义Map集合，用来存储字符及其出现的次数
		val map = mutable.Map[Char, Int]()
		//3.将字符串转成字符数组
		val chs = str.toCharArray
		//4.遍历字符数组，获取每一个字符
		for(k <- chs) {
			//5.1如果字符是第一次出现，就将其次数记录为1
			if (map.contains(k)) {
				map += (k -> 1)
			} else {
			//5.2如果字符是重复出现，就将其次数+1，然后重新存储
				map += (k -> (map.getOrElse(k, 1) + 1))
			}
		}
		//6.遍历集合，查看结果
		map.foreach(println(_))
	}
}
孤岛使者
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Scala(18) -- scala的集合（Iterable、Seq、Stack、Queue、Set、Map）
erainm
09-22 760
1. Iterable 2. Seq 3. Stack 4. Queue 5. Set 6.Map 7. 案例
scala集合Iterable-API
wenthkim的博客
01-12 5032
Iterable新增的接口不多，这篇是Iterable API的用例，还是来一张scala抽象接口图: 注意:迭代器有一个很重要的特点是，数据迭代一次就不存在了 创建两个Iterable,默认实现是List val i1 = Iterable(1,2,3,4,5) val i2 = Iterable(6,7,8,9,10) 1.抽象方法 //迭代输出每个数据 结果:12345 ...
22_Scala集合Seq
最新发布
m0_52474839的博客
05-07 564
也就是将java.util.HashMap[String,String]起别名为JavaHashMap。scala中Seq是一个特质trait，无法直接构建对象，所以底层采用的是List集合。此类运算符都是表示集合从：端进行+操作。由于底层关系，上述两种写法都可以。起别名关键字type。
Scala学习 --------- Iterable常用方法
Z_Data的博客
11-20 3460
因为Iterable是所有集合的父类，所以其方法在所有集合中都适用   4.6.1 sum/max/min/count sum/max/min count统计偶数的个数 4.6.2 filter过滤 4.6.3 flatten 扁平化处理 扁平化处理：集合中的元素如果是多个集合，则将多个集合拆解成一个集合。 案例： 4.6.4 diff/int...
Scala第十八章节(Iterable集合、Seq集合、Set集合、Map集合以及统计字符个数案例)
m0_56525833的博客
04-03 1497
1. 掌握Iterable集合相关内容. 2. 掌握Seq集合相关内容. 3. 掌握Set集合相关内容. 4. 掌握Map集合相关内容. 5. 掌握统计字符个数案例.
【Scala笔记——道】Scala 循环遍历 for详解
weixin_34061482的博客
06-22 1365
Scala for循环 基本使用 增强型for循环 scala基本for循环如下，代码将names遍历并打印包含的名字。 val names = Seq("Kitty", "Tom", "Luke", "Kit") for (name <- names) { println(name) } 相较Java，语法层面来看只是将...
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...
浅析scala中map与flatMap的区别
08-25
map 和 flatMap 函数都是 Scala 中非常重要的函数，它们都可以将一个函数应用于集合中的每个元素，但是它们之间存在着很大的区别。map 函数将每个元素映射为一个新对象，而 flatMap 函数将每个元素映射为一个新集合...
Scala-part2集合框架
11-13
快速掌握集合，Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质 在Scala中集合有可变（mutable）和不可变（immutable）两种类型
头歌Scala中集合的使用
04-13
Scala中集合的使用 大学生 1. List 列表的使用 2. Set 集合的使用 3.Map 映射的使用 4. 元组的使用
Scala Json 和 map/ bean对象的转换
01-07
需求：需要将一个格式是[String,MonthValue]的map转换为json，这里YearValue是自定义的case class。 MonthValue长这样，这里需要加上@BeanProperty注解，否则 fastjson解析不到。 case class MonthValue(@Bean...
SCALA 集合框架文档翻译-Trait Iterable
李兵的专栏
12-16 1338
Iterable 特质         在SCALA集合层级中顶端特质 Traversable 的下一个特质是 Iterable。这个特质中的所有方法都是依据抽象方法 iterator 而实现的，这个抽象方法能一个接一个产生集合中的元素。Traversable 特质中的 foreach 方法在 Iterable 中也是依据 iterator 方法实现的。下面是实现的代码： def fo
Scala Sequence List
weixin_33946605的博客
03-08 302
2019独角兽企业重金招聘Python工程师标准>>> ...
Scala集合概述：Iterable、Seq、Map
黑马程序员官方博客
02-16 875
Iterable代表一个可以迭代的集合, 它继承了Traversable特质, 同时也是其他集合的父特质. 最重要的是, 它定义了获取迭代器(iterator)的方法:, 这是一个抽象方法, 它的具体实现类需要实现这个方法, 从而实现迭代的返回集合中的元素Seq特质代表按照一定顺序排列的元素序列, 序列是一种特别的可迭代集合, 它的元素特点是有序(元素存取顺序一致), 可重复, 有索引表示栈数据结构, 元素特点是先进后出。
Scala中Seq转Map的方法(:_*)
GulfMoon
07-05 4359
近日在学习Kafka源码的时候，对代码中 .toSeq: _*的语法不是很理解，于是在scala shell中做了几次尝试，理解了其中的用法含义。 1. 源码 topicRegistry的数据结构： 2. 尝试 1）Seq(1,2,3,4) 回到源码查看topicRegistry的数据结构，发现调用toSeq方法的数据结构是元组的List，而且语法:_*是在Map()构造函数...
Scala之循环总结
zp17834994071的博客
07-30 924
大家都知道，scala语言和kava语言有很多相似之处，那么循环呢？不用说，肯定也有很多相似的地方，但也有不同的地方，今天就给大家归纳总结下scala中的几种循环使用语法。 while循环 和java中的while循环一样，如果给的循环条件为true，会重复执行循环内的语句，直到条件变为false，语法也是一样的 语法： while(循环条件){ 循环代码块 } 举例： var num = 0 while (num < 10) { println(num) num =
Scala数组函数（seq~zipWithIndex）
qq_43012693的博客
10-29 804
seq 产生当前序列的sequential视图 var a=Array(1,2,3,4,5) a.seq scala.collection.mutable.IndexedSeq[Int] = WrappedArray(1, 2, 3, 4, 5) size 序列的大小 scala> a.size res2: Int = 5 slice 取出当前序列中，from 到 until 之间的元素。 不包含until。 val a=Array(1,2,3,4,5,6,7,8) a.slice(1,4) A
【Scala】集合总结（一）——Array、List、Set、Map、Tuple的创建、访问、遍历方法
克里斯的博客
01-19 1012
一、Scala集合简介 （1）Scala 的集合有三大类：序列 Seq、集 Set、映射 Map，所有的集合都扩展自 Iterable 特质。 （2）对于几乎所有的集合类，Scala 都同时提供了可变和不可变的版本，分别位于以下两 个包： 不可变集合：scala.collection.immutable 可变集合： scala.collection.mutable （3）Scala 不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而 不会对原对象进行修改。类
Scala基础【seq、set、map、元组、WordCount、队列、并行】
weixin_43923463的博客
07-30 1284
并行多核，一个物理核拆分成了多个虚拟核，每个线程可以抢占一个，当多个线程抢占同一个虚拟核称为并发，反之为并行，同时执行。思路二将（“helloscala”，4）转换成（“hello”，4），（“scala”，4），再进行相同单词相加。并发多个线程不按照顺序抢占CPU资源，当一个线程抢到之后，其他线程阻塞，也可以理解为交叉执行，一个线程执行一段时间。逃逸分析方法返回对象，但对象被回收了，或者是对象来自于外部，方法执行完毕之后，也将对象弹栈。Map集合特性数据无序，k不能重复，v可以重复。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值