scala入门4-集合

最新推荐文章于 2023-04-20 00:00:00 发布

程序猿-瑞瑞

最新推荐文章于 2023-04-20 00:00:00 发布

阅读量183

点赞数

分类专栏： scala

本文链接：https://blog.csdn.net/weixin_39743356/article/details/110007202

版权

scala 专栏收录该内容

10 篇文章 2 订阅

订阅专栏

基于Java学习scala

集合

集合

1、简介

集合有三大类序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质。

对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本，分别位于以下两个包

不可变集合：scala.collection.immutable	（这个默认导入，修改时会生成新的集合，不会对原有集合进行修改）
可变集合：  scala.collection.mutable	（这个使用时要导入）

集合的基本操作

1.+/-
	对一个元素进行操作添加/删除
2.++/--
	对一个集合的元素进行操作添加/删除
3.:
	在前，添加元素到末尾
	在后，添加元素到开头
	不带，添加元素到末尾
4.=
	对原集合进行操作

2、集合基础api

1.不可变数组Array

def main(args: Array[String]): Unit = {
	//创建--------------------------------------------------------
	//1.Array[元素类型](值,值,...)
	val arr1 = new Array[String](3)
	//2.new Array[元素类型](长度)
	val arr2 = Array[String]("a", "b", "c")

	//Array没有重写toString方法，默认打印的是内存地址，故转为ArrayBuffer打印
	println(arr1)
	println(arr1.toBuffer)
	println(arr2.toBuffer)

	//获取--------------------------------------------------------
	println("-" * 100)
	println(arr2(0))
	println(arr2(1))

	//修改--------------------------------------------------------
	println("-" * 100)
	arr1.update(0, "a")
	arr1(1) = "v"
	println(arr1.toBuffer)
	//updated为修改后生成新的array，对原本的数组不做修改
	val newArr = arr1.updated(2, "newA")
	println(newArr.toBuffer)
	println(arr1.toBuffer)

	//添加--------------------------------------------------------
	println("-" * 100)
	val arr4 = arr1.+:("d")
	val arr5 = arr1.:+("o")
	//原本数组不会变
	println(arr1.toBuffer)
	//.+:将元素加在前
	println(arr4.toBuffer)
	//.:+将元素加在后
	println(arr5.toBuffer)

	//批量添加--------------------------------------------------------
	println("-" * 100)
	//.++和.:++一样都是将元素加在后
	val arr6 = arr1.++(Array[String]("m", "n", "q"))
	val arr7 = arr1.:++(Array[String]("m", "n", "q"))
	val arr8 = arr1.++:(Array[String]("m", "n", "q"))
	println(arr6.toBuffer)
	println(arr7.toBuffer)
	println(arr8.toBuffer)

	//没有删除--------------------------------------------------------
}

[Ljava.lang.String;@5fe5c6f
ArrayBuffer(null, null, null)
ArrayBuffer(a, b, c)
----------------------------------------------------------------------------------------------------
a
b
----------------------------------------------------------------------------------------------------
ArrayBuffer(a, v, null)
ArrayBuffer(a, v, newA)
ArrayBuffer(a, v, null)
----------------------------------------------------------------------------------------------------
ArrayBuffer(a, v, null)
ArrayBuffer(d, a, v, null)
ArrayBuffer(a, v, null, o)
----------------------------------------------------------------------------------------------------
ArrayBuffer(a, v, null, m, n, q)
ArrayBuffer(a, v, null, m, n, q)
ArrayBuffer(m, n, q, a, v, null)

2.可变数组

def main(args: Array[String]): Unit = {
	//创建
	//ArrayBuffer[元素类型](初始元素,...)
	val arr1 = ArrayBuffer[Int](2, 1, 4)
	//new ArrayBuffer[元素类型]()
	val arr2 = new ArrayBuffer[Int]()
	println(arr1)
	println(arr2)

	//获取--------------------------------------------------------
	println("-" * 100)
	println(arr1(0))

	//修改--------------------------------------------------------
	println("-" * 100)
	arr1.update(0, 10)
	arr1(1) = 20
	println(arr1)
	//updated为修改后生成新的array，对原本的数组不做修改
	val newArr = arr1.updated(2, 30)
	println(newArr)
	println(arr1)

	//添加--------------------------------------------------------
	println("-" * 100)
	val arr3 = arr1.+:(5)
	val arr4 = arr1.:+(6)
	println(arr3)
	println(arr4)
	println(arr1) //原本数组不会变

	arr1.+=(88)
	arr1.+=:(99)
	println(arr1) //修改原数组

	//批量添加--------------------------------------------------------
	println("-" * 100)
	//.++和.:++一样都是将元素加在后
	val arr5 = arr1.++(Array[Int](1, 2, 3))
	val arr6 = arr1.:++(Array[Int](1, 2, 3))
	val arr7 = arr1.++:(Array[Int](1, 2, 3))
	println(arr5)
	println(arr6)
	println(arr7)
	//有=号的修改原数组
	println(arr1)
	arr1.++=(Array[Int](1, 2, 3))
	println(arr1)
	arr1.++=:(Array[Int](1, 2, 3))
	println(arr1)

	//删除--------------------------------------------------------
	println("-" * 100)
	println(arr1)
	arr1.remove(1) //删除角标的数据
	println(arr1)
	arr1.remove(0, 2) //从角标0开始，删除两个数据
	println(arr1)

	//转化与多维数组--------------------------------------------------------
	println("-" * 100)
	//可变数组转不可变数组
	println(arr1.toArray)

	//多维数组
	val array = Array.ofDim[Int](3,4)
	println(array.length)
	println(array(0).length)
}

3.不可变List

def main(args: Array[String]): Unit = {
	//创建List
	//方式1  List[元素类型](初始元素,...)
	val list1 = List[Int](1, 2, 3)
	//方式2
	// 元素 :: 元素 :: .. :: list/Nil
	//:: 最后面必须要是一个List或者是Nil,Nil就是相当于是List的子类
	val list2 = 1 :: 2 :: 3 :: Nil
	val list3 = 3 :: 4 :: list2
	val list4 = list2 :: 3 :: 4 :: 5 :: Nil //这种方式创建的数据，会把list2当成一个元素
	println(list1)
	println(list2)
	println(list3)
	println(list4)

	//获取--------------------------------------------------------
	println("-" * 100)
	println(list1(1))
	//修改--------------------------------------------------------
	println("-" * 100)
	val list5 = list1.updated(0, 12)
	println(list1)
	println(list5)
	//没有删除--------------------------------------------------------
	//添加--------------------------------------------------------
	println("-" * 100)
	println(list1)
	val list6 = list1.+:(100)
	val list7 = list1.:+(100)
	val list8 = list1.++(Array[Int](9, 99, 999))
	val list9 = list1.:++(Array[Int](9, 99, 999))
	val list10 = list1.++:(Array[Int](9, 99, 999))
	val list11 = 100 :: list1
	val list12 = list1 ::: list1

	println(list6)
	println(list7)
	println(list8)
	println(list9)
	println(list10)
	println(list11)
	println(list12)
	println(list1)
}

4.可变ListBuffer

def main(args: Array[String]): Unit = {
	//创建--------------------------------------------------------
	//ListBuffer[元素类型](初始元素,...)
	val list1 = ListBuffer[Int](1, 2, 3)
	println(list1)

	//获取--------------------------------------------------------
	println("-" * 100)
	println(list1(1))

	//修改--------------------------------------------------------
	println("-" * 100)
	val list2 = list1.updated(0, 12)
	println(list1)
	println(list2)
	list1(0)=19
	list1.update(1,20)
	println(list1)

	//添加--------------------------------------------------------
	println("-" * 100)
	println(list1)
	val list6 = list1.+:(100)
	val list7 = list1.:+(100)
	val list8 = list1.++(Array[Int](9, 99, 999))
	val list9 = list1.:++(Array[Int](9, 99, 999))
	val list10 = list1.++:(Array[Int](9, 99, 999))
	println(list6)
	println(list7)
	println(list8)
	println(list9)
	println(list10)
	println(list1)

	list1.+=(8)
	println(list1)
	list1.++=(Array[Int](9, 99, 999))
	println(list1)
	list1.append(10000)
	println(list1)

	//删除--------------------------------------------------------
	println("-" * 100)
	println(list1)
	list1.remove(0)
	println(list1)
	list1.-=(999)
	println(list1)
	list1.-=(888)//没有这个元素的话啥也不删除
	println(list1)
	list1.--=(Array[Int](9, 99, 999))
	println(list1)
}

5、不可变set

def main(args: Array[String]): Unit = {
	//set的特点: 无序、不重复
	//创建	Set[元素类型](初始元素,...)
	val set1 = Set[String]("a", "b", "c")
	println(set1)

	//新增
	println("-"*100)
	val set2 = set1.+("d")
	val set3 = set1.++(Array[String]("e", "r", "p"))

	println(set1)
	println(set2)
	println(set3)

	//删除
	println("-"*100)
	val set4 = set1.-("a")
	val set5 = set1.--(Array[String]("a","b","d"))
	println(set4)
	println(set5)
	println(set1)

}

6、可变set

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

	//创建  mutable.Set[元素类型](初始元素,...)
	val set1 = mutable.Set[Int](52, 123, 18, 0)
	println(set1)

	//添加元素
	println("-" * 100)
	val set2 = set1.+(10)
	println(set2)
	println(set1)

	set1.addOne(99) //修改本身
	set1.+=(20)
	println(set1)

	val set3 = set1.++(Array(100, 200))
	println(set3)
	set1.++=(Array(300, 400))
	println(set1)

	//删除元素
	println("-" * 100)
	val set4 = set1.-(300)
	set1.-=(400)
	println(set4)
	println(set1)

	val set6 = set1.--(Array(300, 0, 20))
	set1.--=(Array(123, 99))
	println(set6)
	println(set1)

	set1.remove(52)
	println(set1)

	//修改
	println("-" * 100)
	set1.update(9999, true) //为true为添加
	println(set1)
	set1.update(9999, false) //为false相当于删除
	println(set1)
}

7、元组

def main(args: Array[String]): Unit = {
	//元组最多只能存放22个元素
	
	//创建
	val tuple1 = (1, 300, "yire")
	//二元元组，可以表示为键值对
	val tuple2 = "fang" -> "24"
	println(tuple1)
	println(tuple2)
	//一旦创建无法修改其长度和元素
	//取值
	val value1 = tuple1._1
	val value2 = tuple1._2
	val value3 = tuple1._3
	println(value1)
	println(value2)
	println(value3)
}

8、不可变map

def main(args: Array[String]): Unit = {
	//创建
	//1、Map[K的类型,V的类型]( (K,V),(K,V),... )
	val map = Map[String, Int](("zhangsan", 20), ("lisi", 30), ("zhangsan", 40))
	//2、Map[K的类型,V的类型] ( K -> V ,...)
	val map2 = Map[String, Int]("zhangsan" -> 20, "lisi" -> 30)

	println(map)
	println(map2)

	//添加元素
	println("-" * 100)
	val map3 = map.+("wangwu" -> 30)
	val map4 = map.++(Map(("aa", 1), ("bb", 2)))
	println(map3)
	println(map4)

	val map5 = map.++:(Map(("aa", 1), ("bb", 2), ("zhangsan2", 40)))
	println(map5)
	//变添加完返回的是hashmap
	println(map5.getClass)

	//更新
	println("-" * 100)
	val map6 = map5.updated("cc", 100) //没有则添加
	val map7 = map5.updated("lisi", 13) //有才修改
	println(map6)
	println(map7)

	//获取key对应的value数据
	println("-" * 100)
	val maybeInt:Option[Int] = map6.get("dd")//Option: 提醒外部当前可能返回数据为空需要进行处理
	println(map6.get("dd"))//Some: 表示非空,数据封装在Some中,后续可以通过get方法获取数据
	println(map6.get("cc"))//None: 表示为空
	println(map6.getOrElse("dd", 1000))

	//获取map所有的key
	println("-"*100)
	for (key <- map6.keys) {
	println(key)
	}

	//获取所有的value
	println("-"*100)
	for (value <- map6.values) {
	println(value)
	}
}

9、可变map

def main(args: Array[String]): Unit = {
	//创建
	//1、mutable.Map[K的类型,V的类型]( (K,V),(K,V),.. )
	val map1 = mutable.Map[String, Int](("zhangsan", 20), ("lisi", 30))
	//2、mutable.Map[K的类型,V的类型]( K->V,.. )
	val map2 = mutable.Map[String, Int]("zhangan" -> 30, "lisi" -> 20)

	println(map1)
	println(map2)

	//添加元素
	println("-" * 100)
	val map3 = map1.+("wangwu" -> 25)
	map1.+=("aa" -> 10)
	println(map3)
	println(map1)

	val map4 = map1.++(Map[String, Int]("cc" -> 1, "dd" -> 2))
	val map5 = map1.++:(Map[String, Int]("ee" -> 10, "ff" -> 20, "aa" -> 30))
	println(map4)
	println(map5)

	map1.++=(Map[String, Int]("pp" -> 100, "ww" -> 200))
	println(map1)

	map1.put("tt", 1000)
	println(map1)

	//删除元素
	println("-"*100)
	val map6 = map1.-("aa")
	println(map6)

	map1.-=("ww")
	println(map1)

	val map7 = map1.--(List("lisi", "tt"))
	println(map7)

	map1.--=(List("zhangsan", "pp"))
	println(map1)

	map1.remove("lisi")
	println(map1)

	//获取元素
	println("-"*100)
	println(map1.getOrElse("ddd", -1))

	//获取所有key
	println("-"*100)
	for (key <- map1.keys) {
	println(key)
	}

	//获取所有的vlaue
	println("-"*100)
	for (value <- map1.values) {
	println(value)
	}

	//修改元素
	println("-"*100)
	map1("aa") = 1000
	println(map1)

	map1.update("tt", 100)
	println(map1)

	val map10 = map1.updated("tt", 1)
	println(map10)
	println(map1)

}

程序猿-瑞瑞

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
scala入门4-集合

基于Java学习scala集合1、简介2、集合基础api1.不可变数组Array2.可变数组3.不可变List4.可变ListBuffer5、不可变set6、可变set7、元组集合1、简介集合有三大类序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质。对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本，分别位于以下两个包不可变集合：scala.collection.immutable （这个默认导入，修改时会生成新的集合，不会对原有集合进行修改）可变集合
复制链接

扫一扫